From 96788ee1ceaccaf86c5912c139c2beb0a7959d0e Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 08:09:42 +0000
Subject: [PATCH 01/13] docs: mark the Spring and Quarkus mocks as internal API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The classes in `com.vaadin.browserless.mocks` and
`com.vaadin.browserless.quarkus.mocks` are built by the framework itself —
`SpringBrowserlessTest`, `QuarkusBrowserlessTest` and the application contexts
construct them as local variables, and no published signature accepts or
returns one. Say so, using the same wording as `BaseBrowserlessTest`, so they
stay free to change.

`MockWebApplicationContext` and `SpringSecurityRequestCustomizer` already
carried a shorter note; they now use the full sentence like the rest.
---
 .../vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java  | 3 +++
 .../browserless/quarkus/mocks/MockQuarkusServletService.java  | 3 +++
 .../java/com/vaadin/browserless/mocks/MockSpringServlet.java  | 3 +++
 .../vaadin/browserless/mocks/MockSpringServletService.java    | 3 +++
 .../com/vaadin/browserless/mocks/MockSpringVaadinSession.java | 3 +++
 .../vaadin/browserless/mocks/MockWebApplicationContext.java   | 4 ++--
 .../browserless/mocks/SpringSecurityRequestCustomizer.java    | 4 ++--
 7 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java
index 18c45bfb..52db1da3 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java
@@ -36,6 +36,9 @@
  * {@link MockQuarkusServletService} is used instead of vanilla
  * {@link com.vaadin.quarkus.QuarkusVaadinServletService}.
  *
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ * 
  * @since 1.0
  */
 public class MockQuarkusServlet extends QuarkusVaadinServlet {
diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServletService.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServletService.java
index 4186c39e..d44da1e2 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServletService.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServletService.java
@@ -37,6 +37,9 @@
  * </ul>
  * The class is intentionally opened, to be extensible in user's library.
  *
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ * 
  * @since 1.0
  */
 public class MockQuarkusServletService extends QuarkusVaadinServletService {
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
index 5bde516d..591110ee 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
@@ -47,6 +47,9 @@
  * {@link MockSpringServletService} is used instead of vanilla
  * {@link com.vaadin.flow.spring.SpringVaadinServletService}.
  *
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ * 
  * @author mavi
  * @since 1.0
  */
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
index f5b49e61..3a5f854c 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
@@ -38,6 +38,9 @@
  * </ul>
  * The class is intentionally opened, to be extensible in user's library.
  *
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ * 
  * @author mavi
  * @since 1.0
  */
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
index 826c9697..a1695496 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
@@ -35,6 +35,9 @@
  * {@link MockVaadin#afterSessionClose}.</li>
  * </ul>
  *
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ * 
  * @author mavi
  * @since 1.0
  */
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java
index d048f2f8..f78c7ad5 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java
@@ -40,8 +40,8 @@
 /**
  * An adapter to make a generic Spring ApplicationContext act like a
  * WebApplicationContext.
- *
- * For internal use only.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
  *
  * @since 1.0
  */
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java b/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
index 7c442009..49e7df5f 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
@@ -19,8 +19,8 @@
 
 /**
  * Configures mock request with authentication details from Spring Security.
- *
- * For internal use only.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
  *
  * @since 1.0
  */

From 922bd5883244435a31c9773250fd723efca3f76b Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 08:18:09 +0000
Subject: [PATCH 02/13] refactor!: port the mocks package from Kotlin to Java
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The 12 Kotlin files under `shared/src/main/kotlin/com/vaadin/browserless/mocks`
become 14 Java files. First phase of removing Kotlin from `shared`; the plan for
the rest is in `de-kotlin-plan.md`.

`MockHttpEnvironment.kt` splits into `MockHttpEnvironment`, `MockServletConfig`
and `MockUtils`, and the top-level helpers of `MockVaadinServlet.kt` become
statics on `MockVaadinServlet`. Every class is marked internal, and the KDoc is
rewritten as Javadoc: each mock now says which container behaviour it
reproduces and where it stops.

Kotlin properties are kept as accessors rather than flattened into public
fields, so most call sites are untouched — including the Kotlin ones, which see
a Java getter/setter pair as a property.

Breaking changes:

* `MockVaadinServlet.createServletService` declares `throws ServiceException`
  and `createDeploymentConfiguration` declares `throws ServletException`, as
  `VaadinServlet` does. An override that calls `super` has to declare it too.
* `MockHttpEnvironment.INSTANCE.setLocalPort(…)` becomes
  `MockHttpEnvironment.setLocalPort(…)`; same for `MockVaadinHelper`.
* `MockHttpSession.Companion.create(…)` becomes `MockHttpSession.create(…)`.
* `MockRequest.isUserInRole` takes a `BiPredicate` and the principal provider a
  `Supplier`, in place of the Kotlin function types.
* The `HttpSession.attributes` extension is gone; use
  `new SessionAttributeMap(session)`.
* `MockResponse` no longer exposes `_status`, `_bufferSize`, `_locale`,
  `_contentType` and `_characterEncoding`; use the `HttpServletResponse`
  getters and setters that back them.
* The `WebBrowser(request)` factory is renamed `createWebBrowser(request)`.

`MockInstantiator` is now `@Deprecated(forRemoval = true)` and forwards
`getPageTitleGenerator()`, which the wrapper was missing.
---
 .gitignore                                    |   2 +
 CONVENTIONS.md                                |   4 +-
 de-kotlin-plan.md                             | 338 ++++++++
 guidelines/repository.md                      |   7 +-
 .../browserless/mocks/MockRequestTest.kt      |   2 +-
 .../mocks/SessionAttributeMapTest.kt          |   2 +-
 .../vaadin/browserless/mocks/MockContext.java | 506 ++++++++++++
 .../mocks/MockHttpEnvironment.java            | 154 ++++
 .../browserless/mocks/MockHttpSession.java    | 243 ++++++
 .../browserless/mocks/MockInstantiator.java   | 152 ++++
 .../vaadin/browserless/mocks/MockRequest.java | 744 ++++++++++++++++++
 .../browserless/mocks/MockResponse.java       | 306 +++++++
 .../vaadin/browserless/mocks/MockService.java | 114 +++
 .../browserless/mocks/MockServletConfig.java  | 105 +++
 .../vaadin/browserless/mocks/MockUtils.java   |  57 ++
 .../browserless/mocks/MockVaadinHelper.java   | 372 +++++++++
 .../browserless/mocks/MockVaadinServlet.java  | 254 ++++++
 .../browserless/mocks/MockVaadinSession.java  |  70 ++
 .../vaadin/browserless/mocks/MockedUI.java    | 179 +++++
 .../mocks/SessionAttributeMap.java            | 205 +++++
 .../vaadin/browserless/internal/MockVaadin.kt |  15 +-
 .../vaadin/browserless/mocks/MockContext.kt   | 294 -------
 .../browserless/mocks/MockHttpEnvironment.kt  |  69 --
 .../browserless/mocks/MockHttpSession.kt      | 146 ----
 .../browserless/mocks/MockInstantiator.kt     |  91 ---
 .../vaadin/browserless/mocks/MockRequest.kt   | 351 ---------
 .../vaadin/browserless/mocks/MockResponse.kt  | 166 ----
 .../vaadin/browserless/mocks/MockService.kt   |  47 --
 .../browserless/mocks/MockVaadinHelper.kt     | 170 ----
 .../browserless/mocks/MockVaadinServlet.kt    | 116 ---
 .../browserless/mocks/MockVaadinSession.kt    |  38 -
 .../com/vaadin/browserless/mocks/MockedUI.kt  | 124 ---
 .../browserless/mocks/SessionAttributeMap.kt  | 109 ---
 .../BuilderVaadinConfigurationTest.java       |   4 +-
 .../mocks/MockInstantiatorTest.java           |   2 +-
 .../mocks/BrowserlessLookupInitializerTest.kt |  16 +-
 36 files changed, 3827 insertions(+), 1747 deletions(-)
 create mode 100644 de-kotlin-plan.md
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockHttpEnvironment.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockService.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockServletConfig.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockUtils.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockContext.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpEnvironment.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpSession.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockInstantiator.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockRequest.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockResponse.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockService.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinHelper.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinServlet.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinSession.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/MockedUI.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/mocks/SessionAttributeMap.kt

diff --git a/.gitignore b/.gitignore
index e6a82ae2..47021b1f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
 target
 spotless-index
+*.iml
+.idea
diff --git a/CONVENTIONS.md b/CONVENTIONS.md
index 2eadf3ff..4f03c060 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -109,8 +109,8 @@ and session lifecycle events through the `VaadinService` event bus, and forward
 `Instantiator` calls to the real instantiator instead of reimplementing them.
 
 New code in `shared` is written in Java. The Kotlin sources under
-`shared/src/main/kotlin` are the older mock and internal layer and are being
-ported to Java; do not add new Kotlin files there.
+`shared/src/main/kotlin` are the older internal layer and are being ported to
+Java; do not add new Kotlin files there.
 
 See [`guidelines/architecture.md`](guidelines/architecture.md).
 
diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
new file mode 100644
index 00000000..9fb1a0de
--- /dev/null
+++ b/de-kotlin-plan.md
@@ -0,0 +1,338 @@
+# Migrating the Kotlin sources to plain Java
+
+Working plan for removing Kotlin from `browserless-test`. The goal is that
+`shared/src/main` is 100% Java and that downstream consumers of
+`browserless-test-shared` pull no Kotlin runtime transitively.
+
+## Current state
+
+| Area | Files | LOC | Notes |
+| --- | --- | --- | --- |
+| `shared/src/main/kotlin/…/mocks` | 12 | 1,721 | servlet API mocks, `MockService`, `MockedUI` |
+| `shared/src/main/kotlin/…/internal` | 12 | 3,043 | `MockVaadin`, `Locator`, `Routes`, `PrettyPrintTree`, utilities |
+| `shared/src/main/kotlin/…/component/Grid.kt` | 1 | 901 | the heaviest single file |
+| `junit6/src/test/kotlin` | 23 | ~3,050 | DynaTest + Karibu DSL |
+| `shared/src/test/kotlin` | 2 | 144 | DynaTest |
+
+`spring`, `quarkus`, `junit6/src/main` and `locator-processor` are already pure
+Java, but about 48 Java files reference the Kotlin packages and 24 call sites go
+through Kotlin file facades (`LocatorKt`, `PrettyPrintTreeKt`, `GridKt`,
+`UtilsKt`, `BasicUtilsKt`, `ShortcutsKt`).
+
+## Prior art
+
+`origin/feat/no-kotlin-grid` carries a complete five-commit port of all 25
+main-source Kotlin files, verified green on all four suites
+(20 / 1007 / 29 / 27 tests). It branched from `a333ccc` and is 82 commits behind
+`main`, so it is a source to rebase from, not a branch to merge.
+
+Reviewer notes from that effort live on the branch in `de-kotlin-review/`.
+
+Drift to reconcile while rebasing — most files differ only by the
+commercial → Apache license header swap (`08abcfa`); the real drift is:
+
+| File | Drift | Why |
+| --- | --- | --- |
+| `internal/MockVaadin.kt` | +222 | reload / window-name plumbing, `liveUI`, `fireSessionDestroyAndDrain`, multi-user session objects |
+| `mocks/MockInstantiator.kt` | +118 | deprecated, forwarders hand-unrolled |
+| `internal/PrettyPrintTree.kt` | +93 | `hrefValue()` already rewritten in plain Java reflection — expect a conflict with Phase 3 |
+| `component/Grid.kt` | +86 | selection and click additions |
+| `mocks/MockedUI.kt` | +82 | `navigate()` override and `toLocation()` |
+| `internal/TestingLifecycleHook.kt` | +60 | slot / children rules |
+| `mocks/MockRequest.kt` | +60 | role checker, principal provider |
+| `mocks/MockHttpSession.kt` | +39 | `changeSessionId()` |
+
+`df099d0` already dropped `kotlin-reflect` on `main`, so that dependency win is
+banked independently of this work.
+
+## Phases
+
+Each phase is independently mergeable and leaves the build green.
+
+### Phase 0 — prerequisites
+
+Decisions that constrain later phases:
+
+- **Nullability annotations.** 11 Java files in `shared`, `spring` and
+  `quarkus` import `org.jetbrains.annotations.@NotNull` / `@Nullable`, which
+  arrives transitively via `kotlin-stdlib`. Move them to JSpecify (already used
+  in 5 files) or add a direct `org.jetbrains:annotations` dependency. Without
+  this the build breaks the moment `kotlin-stdlib` leaves compile scope.
+- **`SearchSpec.count`.** Pick the replacement for `kotlin.ranges.IntRange`
+  (the prior effort introduced a small `CountRange` helper). This constrains
+  Phases 4 and 5.
+- **Test-side Kotlin.** In or out of scope — see below.
+
+### Phase 1 — `mocks/` — done
+
+12 Kotlin files → 14 Java files, on `refactor/no-kotlin-mocks`. All five suites
+match the `main` baseline exactly: shared 42, junit6 1406, junit6-cdi-tests 4,
+spring 41, quarkus 31.
+
+- `MockHttpEnvironment.kt` splits into `MockHttpEnvironment`,
+  `MockServletConfig` and a `MockUtils.putOrRemove` helper.
+- `MockVaadinServlet.kt`'s top-level factories (`serviceSafe`,
+  `createVaadinServletRequest` / `…Response`, `_createVaadinSession`,
+  `WebBrowser(request)`) become statics on `MockVaadinServlet`. The last one is
+  renamed `createWebBrowser` to avoid clashing with
+  `com.vaadin.flow.server.WebBrowser`.
+- `SessionAttributeMap` becomes a public class; the `HttpSession.attributes`
+  extension property disappears and callers construct it directly.
+- `MockInstantiator`'s `Instantiator by delegate` is unrolled by hand — see the
+  silent-risk list below.
+- `MockRequest` keeps an explicit `setUserInRole(BiPredicate)` setter, matching
+  what Kotlin's `is`-prefix property convention emitted.
+- `MockVaadinServlet.createServletService` now declares
+  `throws ServiceException`, as its `VaadinServlet` superclass does — see the
+  breaking changes below.
+- KDoc is rewritten as Javadoc rather than carried over verbatim: `[Foo]`
+  becomes `{@link Foo}`, `*` bullets become `<ul><li>`, and every public member
+  gets `@param` / `@return`. A mock's class Javadoc states which container
+  behavior it reproduces and where it stops, per
+  [`guidelines/documenting.md`](guidelines/documenting.md). Once Dokka is gone
+  (Phase 5) this is what `maven-javadoc-plugin` publishes.
+
+### Phase 2 — `internal/` utilities
+
+`BasicUtils`, `ComponentUtils`, `ElementUtils`, `DepthFirstTreeIterator`,
+`Renderers`, `Shortcuts`, `TestingLifecycleHook`, `Utils`.
+
+One Java utility class per Kotlin file: `public final`, private constructor,
+top-level and extension functions become `public static` methods with the
+receiver as the first parameter. The leading-underscore convention
+(`_fireEvent`, `_isVisible`, `_saneFetchLimit`) is preserved.
+
+`TestingLifecycleHook` splits into the interface plus a `TestingLifecycleHooks`
+holder, because a Java interface cannot hold the mutable global that the Kotlin
+top-level `var testingLifecycleHook` provided.
+
+### Phase 3 — `PrettyPrintTree` + `Routes`
+
+`MockRouteNotFoundError` and `MockInternalSeverError` move to their own files
+(Java allows one public class per file). Reconcile against `main`'s rewritten
+`hrefValue()`, which already removed the `kotlin-reflect` usage this phase was
+originally about.
+
+Fix `junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java:40`
+(`PrettyPrintTree.Companion.ofVaadin`) in this phase. It only runs on test
+failure, so a green suite does not catch it.
+
+### Phase 4 — `Locator` + `MockVaadin`
+
+The behaviorally sensitive phase.
+
+- `Locator.kt` → `Locator` + `SearchSpec`.
+- `MockVaadin.kt` → `MockVaadin` + `SessionObjects` + `UIFactory` +
+  `MockRequestCustomizer` + `MockPage`.
+- `runUIQueue` needs the `sneakyThrow` idiom, or `AsyncTest`'s
+  `expectThrows(ExecutionException)` fails — Kotlin rethrows arbitrary
+  throwables where Java cannot.
+- Keep `UIFactory`'s SAM method named `invoke()` so `MockedUI::new` call sites
+  and the Spring / Quarkus constructors keep binding.
+
+### Phase 5 — `Grid.kt` and the kotlin-stdlib drop
+
+- `Sequence<T>` returns (`_rowSequence`) become `Stream<T>` built over
+  `DepthFirstTreeIterator` + `Spliterator`. Laziness matters: `TreeGrid._size()`
+  is `_rowSequence().count()`.
+- The `KProperty1` overloads of `HeaderRow.getCell` / `FooterRow.getCell` have
+  no callers — drop them; the `getCell(String)` overloads stay.
+- Delete `shared/src/main/kotlin`, move `kotlin-stdlib` to test scope, replace
+  Dokka with `maven-javadoc-plugin`.
+
+### Phase 6 — test-side Kotlin (separate decision)
+
+The 25 Kotlin test files are test-scoped, so they never reach consumers, and
+leaving them keeps the port's risk down. They also keep `kotlin-maven-plugin`,
+`dynatest` and `karibu-dsl` in the build, against `guidelines/testing.md`.
+
+Recommended: land Phases 1–5 first, then convert the ~3,200 LOC of DynaTest to
+JUnit 6 Java. `group { … }` / `test { … }` map cleanly onto `@Nested` /
+`@Test`, and `AllTests.kt` is a pure aggregator that disappears. This is the one
+phase where a mistake can silently delete coverage, so it needs a test-count
+diff rather than just a green build.
+
+## Breaking changes
+
+Four genuinely breaking changes, all in `com.vaadin.browserless.internal`,
+`.mocks` or `.component`, or already deprecated.
+
+### Checked exceptions reappear on overridable methods
+
+Kotlin has no checked exceptions, so a Kotlin `override` declared none even when
+the Java superclass did. In Java the `throws` clause comes back:
+`MockVaadinServlet.createServletService` declares `throws ServiceException` and
+`createDeploymentConfiguration` declares `throws ServletException`.
+
+Overriding either still compiles — an override may throw fewer exceptions — but
+an override that calls `super` has to declare the exception, which it did not
+have to before. `BuilderVaadinConfigurationTest` in this repository was the only
+affected caller. The alternative, omitting the `throws` clause and rethrowing
+through `sneakyThrow`, keeps every caller compiling but propagates a checked
+exception from a method that does not declare it; the honest signature won.
+
+Watch for the same pattern in later phases, wherever a Kotlin override sits on
+top of a Java method that declares checked exceptions.
+
+### Kotlin types in signatures
+
+| Symbol | Where | Impact |
+| --- | --- | --- |
+| `kotlin.ranges.IntRange` | `SearchSpec.count`, `Grid._dump(IntRange)`, `Utils.IntRange.size`, `ComponentQuery.LocatorSpec.count` | **Breaking.** `ComponentQuery.withResultsSize(int)`, the documented entry point, is unaffected; only direct `SearchSpec` users break |
+| `kotlin.Unit` | return type of the `SearchSpec<T>.() -> Unit` block in `_get` / `_find` / `_expect*`; `ComponentQuery.java` imports it today | becomes `Consumer<SearchSpec<T>>` |
+| `kotlin.jvm.functions.Function0<UI>` | `UIFactory`, plus three `@Deprecated(forRemoval = true)` constructors in `MockSpringServlet`, `MockSpringServletService`, `MockSpringVaadinSession` | **Breaking:** those three constructors have to go — a Java `UIFactory` no longer extends `Function0`, so `MockedUI::new` becomes ambiguous against them. No in-repo callers |
+| `kotlin.jvm.functions.Function1` / `Function2` | `MockVaadin.mockRequestFactory`, `MockRequest.isUserInRole`, `MockRequest.userPrincipalProvider`, `PrettyPrintTree.prettyStringHook`, `DepthFirstTreeIterator(root, children)`, `findAncestor(predicate)`, `SearchSpec.toPredicate()` | swap to `Function` / `Predicate` / `BiPredicate` / `Supplier` / `BiConsumer`. `toPredicate()` changes from `predicate(c)` to `predicate.test(c)` |
+| `kotlin.reflect.KClass` | `MockVaadinHelper.BrowserlessLookupInitializer.additionalServices` (`protected open`, subclassed in `BrowserlessLookupInitializerTest`) | becomes `Map<Class<?>, Class<?>>` |
+| `kotlin.reflect.KProperty1` | `HeaderRow.getCell` / `FooterRow.getCell` in `Grid.kt` | no callers — drop |
+
+### Generated shapes that vanish
+
+- **Every `*Kt` facade class.** 24 in-repo Java call sites get rewritten; any
+  external caller breaks.
+- **`.Companion` accessors** — `PrettyPrintTree.Companion.ofVaadin` (live in
+  `TreeOnFailureExtension`), `TestingLifecycleHook.Companion.getDefault`,
+  `MockHttpSession.Companion.create`.
+- **`INSTANCE` on a Kotlin `object`.** A `var` on an `object` is not a public
+  static field: it compiles to a private static backing field plus accessors on
+  the singleton, reached from Java as
+  `MockHttpEnvironment.INSTANCE.setLocalPort(…)`. The Java port gives the same
+  accessor names as statics, so `INSTANCE`-qualified calls break. Same for
+  `MockVaadinHelper`.
+- **`Companion` and other Kotlin synthetics** — `MockContext.Companion`,
+  `MockHttpSession.Companion` (whose `create` becomes a real static),
+  `MockInstantiator.Companion`, the `$default` bridges behind default arguments,
+  and the `DefaultConstructorMarker` constructors. All replaced by real Java
+  statics and overloads.
+- **`data class` members** — `Routes.copy()` / `componentN()` / `equals` /
+  `hashCode`, and the same on `SessionObjects`. `RoutesTest` uses the two-arg
+  `Routes(…)` form, so the constructor set `@JvmOverloads` produced has to be
+  written out by hand.
+- **`is`-prefix property setters.** Kotlin's `var isUserInRole` emits
+  `setUserInRole(…)`, not `setIsUserInRole`. `MockSpringServlet` calls it
+  cross-module — preserve the exact name.
+- **Underscore-prefixed property accessors** — `BasicUtilsKt.get_saneFetchLimit()`,
+  `UtilsKt.getContext(…)`, `UtilsKt.getMock(…)`. Java-idiomatic renames here are
+  silent source breaks outside the repo, so keep the name unless the value is
+  reachable another way.
+
+  Phase 1 renamed five of them: `MockResponse`'s `_bufferSize`,
+  `_characterEncoding`, `_contentType`, `_locale` and `_status` were public
+  Kotlin `var`s and are now private fields. Every one is reachable through the
+  `HttpServletResponse` getter/setter pair it backs (`getStatus` /
+  `setStatus`, …), and nothing in the repo read them, so only the synthetic
+  `get_status()`-style accessors are gone.
+- **`internal` visibility is public in bytecode**, and Java already relies on
+  it: `UtilsKt.findClass` / `findClassOrThrow` from `spring`, and `MockPage`
+  from `BrowserlessUIContext`. These must stay `public` in Java.
+
+### Silent-behavior risks
+
+No compile error catches these.
+
+1. **`MockInstantiator : Instantiator by delegate`.** Kotlin generates
+   forwarders only for *abstract* members, which is why the methods Flow
+   declares as `default` already had to be hand-written (the
+   `PageTitleGenerator` bug). A Java port must forward every method explicitly,
+   or calls silently fall through to Flow's defaults. Highest-risk item, and it
+   bit the prior effort: its port forwarded 10 of `Instantiator`'s 11 instance
+   methods, dropping `getPageTitleGenerator()`. Check the port against the
+   interface's own member list, not against the Kotlin source.
+2. **`Element.equals()` is overridden in Vaadin.** Kotlin `==` is `.equals()`;
+   translating it to Java `==` becomes identity comparison. This already broke
+   `ElementUtilsTest` during the prior effort.
+3. **Extension resolution is static in Kotlin.** `Button.caption` shadowing
+   `Component.caption` has to become an `instanceof` short-circuit inside one
+   generic method.
+4. **`check()` / `require()` message text.** Tests assert on exact messages from
+   `checkEditableByUser`, `MockPage.reload` and `setupServlet`. Preserve them
+   verbatim.
+5. **Construction-time flag capture.** `PrettyPrintTree` caches
+   `prettyPrintUseAscii` in its constructor; a Java port reading the static per
+   call behaves differently when the flag is toggled mid-test.
+6. **`ComponentUtils.dataProvider`'s `HasDataProvider<*>` branch** relies on a
+   recursive extension-property lookup with no Java equivalent. The prior port
+   dropped it and stayed green — verify against today's `Grid` / `ComboBox`
+   testers.
+
+### What Kotlin consumers lose
+
+Tests written in Kotlin against the internal API lose the reified / receiver
+DSL: `_get<Button> { id = "foo" }` becomes
+`Locator._get(Button::class.java) { it.id = "foo" }`. The public surface
+(`BaseBrowserlessTest`, `ComponentQuery`, `ui.findButton()`, the testers,
+`MockVaadin.setup` / `tearDown`) is unaffected — `@JvmStatic` on the Kotlin
+`object`s already exposed exactly the shapes a Java class produces.
+
+## Build changes
+
+- `shared/pom.xml` — drop the `kotlin-maven-plugin` main execution, drop Dokka
+  in favour of `maven-javadoc-plugin`, drop the `build-helper`
+  `add-kotlin-sources-for-source-jar` execution, move `kotlin-stdlib` to `test`
+  scope.
+- `junit6/pom.xml` — the `kotlin-maven-plugin` `compile` execution points at a
+  `src/main/kotlin` that does not exist. Dead config, remove it.
+- Root `pom.xml` — drop `dokka.version`; keep `kotlin.version` only while
+  test-side Kotlin lives. The Spotless `<kotlin>` block goes with the last
+  `.kt` file.
+- No `japicmp` / `revapi` gate exists in CI, so nothing enforces compatibility
+  automatically. The breaking-change list above has to be checked by hand.
+
+## Translation reference
+
+| Kotlin | Java |
+| --- | --- |
+| top-level `object Foo` | `public final class Foo`, private constructor, static members |
+| top-level `val foo: T` | `public static T foo()` |
+| top-level `var foo: T` | `public static` getter + setter over a private field, **not** a public field |
+| `var foo` on an `object` | `public static` getter + setter, keeping Kotlin's accessor names |
+| `fun X.foo(): R` | `public static R foo(X x)` |
+| `val X.foo: R` | `public static R foo(X x)` |
+| `var X.foo: R` | `foo(X)` + `foo(X, R)` |
+| `interface I by delegate` | explicit forwarding of every method |
+| `data class D(…)` | POJO plus explicit `equals` / `hashCode` / `toString` / `copy` |
+| `fun interface F : () -> R` | `@FunctionalInterface interface F { R invoke(); }` |
+| `(T) -> R` | `Function<T, R>` (or `Consumer` / `Predicate` / `Supplier`) |
+| `SearchSpec<T>.() -> Unit` | `Consumer<SearchSpec<T>>` |
+| `Sequence<T>` | `Stream<T>` via `Spliterator`, to keep laziness |
+| `inline fun <reified T> foo()` | `<T> T foo(Class<T> type)` |
+| `when (x) { is A -> … }` | `instanceof` chain |
+| `buildString { … }` | `StringBuilder` |
+| `coerceAtLeast(0)` | `Math.max(0, x)` |
+| KDoc `[Foo]` | `{@link Foo}` |
+
+## Verifying a port against the Kotlin it replaces
+
+Reading the Kotlin source is not enough to know what the published API is: a
+`val`/`var` looks like a field and compiles to accessors over a private one, and
+a `object` adds an `INSTANCE`. Phase 1's first pass flattened properties into
+public fields in ten classes before this check caught it.
+
+Build `main` in a throwaway worktree and diff the compiled surface:
+
+```bash
+git worktree add /tmp/kt-baseline main
+(cd /tmp/kt-baseline && mvn -o -q clean compile -DskipTests -pl shared -am)
+
+for c in MockContext MockRequest …; do
+  for cp in /tmp/kt-baseline/shared/target/classes shared/target/classes; do
+    javap -p -cp "$cp" com.vaadin.browserless.mocks.$c \
+      | grep -E '^  (public|protected)' | sed 's/^  //; s/\bfinal //' | sort
+  done | …   # diff the two listings
+done
+```
+
+Every surviving difference has to be one you can name and justify. After
+Phase 1 the list was: checked exceptions reappearing on overrides, Kotlin
+synthetics (`Companion`, `INSTANCE`, `$default`, `DefaultConstructorMarker`)
+replaced by real statics and overloads, and `Function0`/`Function2` becoming
+`Supplier`/`BiPredicate` — which is the point of the exercise.
+
+## Verification per phase
+
+```bash
+rm -rf */target          # stale artifacts across modules caused two false alarms before
+mvn clean install
+mvn test                 # baseline: shared 20, junit6 1007, spring 29, quarkus 27
+mvn spotless:check
+mvn dependency:tree -pl shared -Dscope=compile | grep -i kotlin   # empty after Phase 5
+```
diff --git a/guidelines/repository.md b/guidelines/repository.md
index afed716e..2a076b20 100644
--- a/guidelines/repository.md
+++ b/guidelines/repository.md
@@ -5,8 +5,9 @@
 - **Java 21+**, **Maven** (multi-module, parent `com.vaadin:vaadin-parent`).
 - **Vaadin 25 / Flow** as a `provided` dependency, one fixed version per
   branch — see [Flow Version](flow-version.md).
-- **Kotlin** for the older mock and internal layer in `shared/src/main/kotlin`.
-  New code is Java; the Kotlin is being ported over time.
+- **Kotlin** for the older internal layer in `shared/src/main/kotlin`.
+  New code is Java; the Kotlin is being ported over time. The `mocks` package
+  has already been ported — see [`de-kotlin-plan.md`](../de-kotlin-plan.md).
 - **JUnit 6 (Jupiter)** for the published test API and for this repository's
   own tests. A few legacy Kotlin tests still use DynaTest and Karibu DSL.
 - **ClassGraph** for classpath scanning (routes, testers).
@@ -44,7 +45,7 @@ modules that declare testers.
   `Locator`, `Locators`, `CommercialLocators` and the `Has*Filter` mixins. The
   `*Locator` classes themselves are generated into
   `target/generated-sources/annotations`.
-- **The mocks** live in `com.vaadin.browserless.mocks` (Kotlin):
+- **The mocks** live in `com.vaadin.browserless.mocks` (Java):
   `MockService`, `MockVaadinServlet`, `MockRequest`, `MockResponse`,
   `MockHttpSession`, `MockedUI`.
 - **Internal helpers** live in `com.vaadin.browserless.internal` (Kotlin):
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt
index 3b5ba9f3..98d05fb0 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt
@@ -132,7 +132,7 @@ class MockRequestTest : DynaTest({
         expect(false) { request.isUserInRole("foo") }
         request.userPrincipalInt = MockPrincipal("foo", listOf("foo"))
         expect(false) { request.isUserInRole("foo") }
-        request.isUserInRole = { p, r -> (p as MockPrincipal).isUserInRole(r) }
+        request.isUserInRole = java.util.function.BiPredicate { p, r -> (p as MockPrincipal).isUserInRole(r) }
         expect(true) { request.isUserInRole("foo") }
     }
 })
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt
index 7ec96c68..6ed3153e 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt
@@ -26,7 +26,7 @@ class SessionAttributeMapTest : DynaTest({
     lateinit var attrs: MutableMap<String, Any>
     beforeEach {
         session = MockHttpSession.create(MockContext())
-        attrs = session.attributes
+        attrs = SessionAttributeMap(session)
     }
 
     group("size") {
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java
new file mode 100644
index 00000000..076b4801
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java
@@ -0,0 +1,506 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterRegistration;
+import jakarta.servlet.RequestDispatcher;
+import jakarta.servlet.Servlet;
+import jakarta.servlet.ServletContext;
+import jakarta.servlet.ServletRegistration;
+import jakarta.servlet.SessionCookieConfig;
+import jakarta.servlet.SessionTrackingMode;
+import jakarta.servlet.descriptor.JspConfigDescriptor;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.EventListener;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static com.vaadin.browserless.mocks.MockUtils.putOrRemove;
+
+/**
+ * A standalone {@link ServletContext}, backed by the build output of the module
+ * under test.
+ * <p>
+ * It models the three things Vaadin asks a context for: init parameters and
+ * attributes, which are held in memory and are where the {@code Lookup} and the
+ * {@code ApplicationConfiguration} end up; resource lookup, which serves the
+ * files a deployed war would have; and logging, which goes to SLF4J.
+ * <p>
+ * Resources are resolved the way a war layout would resolve them, in this
+ * order: the {@link #realPathRoots} of the current module, then
+ * {@code META-INF/resources} on the classpath (which is where a jar contributes
+ * static files), then, for a {@code /VAADIN/} path, the classpath root. A
+ * {@code /VAADIN/../} path is normalized and refused, as a container refuses to
+ * serve outside the exposed directory.
+ * <p>
+ * Everything a test has no use for — servlet, filter and listener registration,
+ * request dispatch, session tracking configuration — throws
+ * {@link UnsupportedOperationException} rather than pretending to succeed, so a
+ * test that needs one fails loudly instead of running against a fiction. The
+ * reported servlet API version is 3.0, which is what Vaadin's own version
+ * checks accept.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockContext implements ServletContext, Serializable {
+
+    private static final Logger LOG = LoggerFactory
+            .getLogger(MockContext.class);
+
+    @Override
+    public <T extends Servlet> T createServlet(Class<T> clazz) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public int getEffectiveMajorVersion() {
+        return 3;
+    }
+
+    @Override
+    public URL getResource(String path) throws MalformedURLException {
+        // for example @HtmlImport("frontend://reviews-list.html") will expect
+        // the resource to be present in the war file,
+        // which is typically located in $CWD/src/main/webapp/frontend, so let's
+        // search for that first
+        String realPath = getRealPath(path);
+        if (realPath != null) {
+            return new File(realPath).toURI().toURL();
+        }
+
+        // nope, fall back to class loading.
+        //
+        // for example
+        // @HtmlImport("frontend://bower_components/vaadin-button/src/vaadin-button.html")
+        // will try to look up
+        // the following resources:
+        //
+        // 1. /frontend/bower_components/vaadin-button/src/vaadin-button.html
+        // 2. /webjars/vaadin-button/src/vaadin-button.html
+        //
+        // we need to match the latter one to a resource on classpath
+
+        if (path.startsWith("/")) {
+            URL resource = Thread.currentThread().getContextClassLoader()
+                    .getResource("META-INF/resources" + path);
+            if (resource != null) {
+                return resource;
+            }
+        }
+
+        if (path.startsWith("/VAADIN/")) {
+            // Vaadin 8 exposed directory
+            String p = path;
+            if (p.contains("..")) {
+                // to be able to resolve
+                // ThemeResource("../othertheme/img/foo.png") which work from
+                // the browser.
+                p = Paths.get(p).normalize().toString();
+                // convert Windows path separators to Linux ones, so that the
+                // follow-up code works
+                p = p.replace('\\', '/');
+            }
+            // reject to serve "/VAADIN/../" resources
+            if (p.startsWith("/VAADIN/")) {
+                String stripped = p.startsWith("/") ? p.substring(1) : p;
+                URL resource = Thread.currentThread().getContextClassLoader()
+                        .getResource(stripped);
+                if (resource != null) {
+                    return resource;
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public void addListener(String className) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public <T extends EventListener> void addListener(T t) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void addListener(Class<? extends EventListener> listenerClass) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public ClassLoader getClassLoader() {
+        return Thread.currentThread().getContextClassLoader();
+    }
+
+    @Override
+    public Enumeration<String> getAttributeNames() {
+        return attributes.keys();
+    }
+
+    @Override
+    public int getMajorVersion() {
+        return 3;
+    }
+
+    @Override
+    public void log(String msg) {
+        LOG.error(msg);
+    }
+
+    @Override
+    public void log(String message, Throwable throwable) {
+        LOG.error(message, throwable);
+    }
+
+    @Override
+    public FilterRegistration getFilterRegistration(String filterName) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void setSessionTrackingModes(
+            Set<SessionTrackingMode> sessionTrackingModes) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public boolean setInitParameter(String name, String value) {
+        return initParameters.putIfAbsent(name, value) == null;
+    }
+
+    @Override
+    public InputStream getResourceAsStream(String path) {
+        try {
+            URL url = getResource(path);
+            return url == null ? null : url.openStream();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public RequestDispatcher getNamedDispatcher(String name) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public Map<String, ? extends FilterRegistration> getFilterRegistrations() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public Set<SessionTrackingMode> getDefaultSessionTrackingModes() {
+        Set<SessionTrackingMode> set = new HashSet<>();
+        set.add(SessionTrackingMode.COOKIE);
+        set.add(SessionTrackingMode.URL);
+        return set;
+    }
+
+    @Override
+    public String getMimeType(String file) {
+        String mime = URLConnection.guessContentTypeFromName(file);
+        return mime != null ? mime : "application/octet-stream";
+    }
+
+    @Override
+    public void declareRoles(String... roleNames) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public <T extends Filter> T createFilter(Class<T> clazz) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    private List<String> realPathRoots = Arrays
+            .asList("src/main/webapp/frontend", "src/main/webapp");
+
+    /**
+     * Returns the module-relative folders {@link #getRealPath(String)} resolves
+     * a path against, in order; the first one holding the file wins.
+     * <p>
+     * These stand in for the war root of a deployed application. Defaults to
+     * {@code src/main/webapp/frontend} and {@code src/main/webapp}.
+     *
+     * @return the folders searched for a real path
+     */
+    public List<String> getRealPathRoots() {
+        return realPathRoots;
+    }
+
+    /**
+     * Replaces the folders {@link #getRealPath(String)} resolves against. Point
+     * them elsewhere for a project that keeps its static files in another
+     * place.
+     *
+     * @param realPathRoots
+     *            the module-relative folders to search, in order
+     */
+    public void setRealPathRoots(List<String> realPathRoots) {
+        this.realPathRoots = realPathRoots;
+    }
+
+    @Override
+    public String getRealPath(String path) {
+        for (String realPathRoot : realPathRoots) {
+            try {
+                File realPath = new File(moduleDir(), realPathRoot + "/" + path)
+                        .getCanonicalFile().getAbsoluteFile();
+                if (realPath.getAbsolutePath()
+                        .startsWith(new File(realPathRoot).getAbsolutePath())
+                        && realPath.exists()) {
+                    return realPath.getAbsolutePath();
+                }
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return null;
+    }
+
+    private final Map<String, String> initParameters = new HashMap<>();
+
+    /**
+     * Returns the context init parameters, live and directly modifiable.
+     * <p>
+     * Writing here is not the same as calling
+     * {@link #setInitParameter(String, String)}, which follows the servlet
+     * contract and refuses to overwrite a parameter that is already set. Most
+     * parameters are read once, when {@code ApplicationConfiguration} is first
+     * created and cached, so a value that has to be seen must be in place
+     * before anything else touches the context.
+     *
+     * @return the init parameters
+     */
+    public Map<String, String> getInitParameters() {
+        return initParameters;
+    }
+
+    @Override
+    public String getInitParameter(String name) {
+        return initParameters.get(name);
+    }
+
+    @Override
+    public int getMinorVersion() {
+        return 0;
+    }
+
+    @Override
+    public JspConfigDescriptor getJspConfigDescriptor() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void removeAttribute(String name) {
+        attributes.remove(name);
+    }
+
+    @Override
+    public String getServletContextName() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public FilterRegistration.Dynamic addFilter(String filterName,
+            String className) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public FilterRegistration.Dynamic addFilter(String filterName,
+            Filter filter) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public FilterRegistration.Dynamic addFilter(String filterName,
+            Class<? extends Filter> filterClass) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public String getContextPath() {
+        return "";
+    }
+
+    @Override
+    public SessionCookieConfig getSessionCookieConfig() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public String getVirtualServerName() {
+        return "mock/localhost"; // Tomcat returns "Catalina/localhost"
+    }
+
+    private int sessionTimeout = 30;
+
+    @Override
+    public int getSessionTimeout() {
+        return sessionTimeout;
+    }
+
+    @Override
+    public void setSessionTimeout(int sessionTimeout) {
+        this.sessionTimeout = sessionTimeout;
+    }
+
+    private String requestCharacterEncoding = null;
+
+    @Override
+    public String getRequestCharacterEncoding() {
+        return requestCharacterEncoding;
+    }
+
+    @Override
+    public void setRequestCharacterEncoding(String encoding) {
+        this.requestCharacterEncoding = encoding;
+    }
+
+    private String responseCharacterEncoding = null;
+
+    @Override
+    public String getResponseCharacterEncoding() {
+        return responseCharacterEncoding;
+    }
+
+    @Override
+    public void setResponseCharacterEncoding(String encoding) {
+        this.responseCharacterEncoding = encoding;
+    }
+
+    @Override
+    public ServletContext getContext(String uripath) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public RequestDispatcher getRequestDispatcher(String path) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    private final ConcurrentHashMap<String, Object> attributes = new ConcurrentHashMap<>();
+
+    @Override
+    public Object getAttribute(String name) {
+        return attributes.get(name);
+    }
+
+    @Override
+    public void setAttribute(String name, Object value) {
+        putOrRemove(attributes, name, value);
+    }
+
+    @Override
+    public ServletRegistration getServletRegistration(String servletName) {
+        return null;
+    }
+
+    @Override
+    public <T extends EventListener> T createListener(Class<T> clazz) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public ServletRegistration.Dynamic addServlet(String servletName,
+            String className) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public ServletRegistration.Dynamic addServlet(String servletName,
+            Servlet servlet) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public ServletRegistration.Dynamic addServlet(String servletName,
+            Class<? extends Servlet> servletClass) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public ServletRegistration.Dynamic addJspFile(String servletName,
+            String jspFile) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public int getEffectiveMinorVersion() {
+        return 0;
+    }
+
+    @Override
+    public Map<String, ? extends ServletRegistration> getServletRegistrations() {
+        return new HashMap<>();
+    }
+
+    @Override
+    public Set<String> getResourcePaths(String path) {
+        return new HashSet<>();
+    }
+
+    @Override
+    public Enumeration<String> getInitParameterNames() {
+        return Collections.enumeration(initParameters.keySet());
+    }
+
+    @Override
+    public String getServerInfo() {
+        return "Mock";
+    }
+
+    @Override
+    public Set<SessionTrackingMode> getEffectiveSessionTrackingModes() {
+        Set<SessionTrackingMode> set = new HashSet<>();
+        set.add(SessionTrackingMode.COOKIE);
+        set.add(SessionTrackingMode.URL);
+        return set;
+    }
+
+    private static File moduleDir() {
+        File dir = new File("").getAbsoluteFile();
+        // Workaround for https://youtrack.jetbrains.com/issue/IDEA-188466
+        // When using $MODULE_DIR$, IDEA will set CWD to, say,
+        // ui-testing/.idea/modules/ui-testing-module
+        // We need to revert that back to ui-testing/ui-testing-module
+        if (dir.getAbsolutePath().contains("/.idea/modules")) {
+            dir = new File(dir.getAbsolutePath().replace("/.idea/modules", ""));
+        }
+        return dir;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpEnvironment.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpEnvironment.java
new file mode 100644
index 00000000..d81f46c7
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpEnvironment.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+/**
+ * The connection details every {@link MockRequest} reports.
+ * <p>
+ * There is no HTTP connection behind a browserless test, so the values a
+ * container would derive from one are read from here instead. Set one to put
+ * the application under test into the situation you want to assert on —
+ * {@code setSecure(true)} to exercise a code path that requires HTTPS, for
+ * example.
+ * <p>
+ * The values are global and are <em>not</em> reset between tests, so a test
+ * that changes one has to restore it afterwards, or later tests will see it.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class MockHttpEnvironment {
+
+    private MockHttpEnvironment() {
+    }
+
+    private static int localPort = 8080;
+
+    private static int serverPort = 8080;
+
+    private static int remotePort = 8080;
+
+    private static String authType = null;
+
+    private static boolean isSecure = false;
+
+    /**
+     * Returns the port {@link MockRequest#getLocalPort()} reports, i.e. the one
+     * the request was received on. Defaults to {@code 8080}.
+     *
+     * @return the local port
+     */
+    public static int getLocalPort() {
+        return localPort;
+    }
+
+    /**
+     * Sets the port {@link MockRequest#getLocalPort()} reports.
+     *
+     * @param localPort
+     *            the local port
+     */
+    public static void setLocalPort(int localPort) {
+        MockHttpEnvironment.localPort = localPort;
+    }
+
+    /**
+     * Returns the port {@link MockRequest#getServerPort()} reports, i.e. the
+     * one the request was addressed to. Defaults to {@code 8080}.
+     *
+     * @return the server port
+     */
+    public static int getServerPort() {
+        return serverPort;
+    }
+
+    /**
+     * Sets the port {@link MockRequest#getServerPort()} reports.
+     *
+     * @param serverPort
+     *            the server port
+     */
+    public static void setServerPort(int serverPort) {
+        MockHttpEnvironment.serverPort = serverPort;
+    }
+
+    /**
+     * Returns the port {@link MockRequest#getRemotePort()} reports, i.e. the
+     * client's. Defaults to {@code 8080}.
+     *
+     * @return the remote port
+     */
+    public static int getRemotePort() {
+        return remotePort;
+    }
+
+    /**
+     * Sets the port {@link MockRequest#getRemotePort()} reports.
+     *
+     * @param remotePort
+     *            the remote port
+     */
+    public static void setRemotePort(int remotePort) {
+        MockHttpEnvironment.remotePort = remotePort;
+    }
+
+    /**
+     * Returns the authentication scheme {@link MockRequest#getAuthType()}
+     * reports, such as
+     * {@link jakarta.servlet.http.HttpServletRequest#FORM_AUTH}.
+     * <p>
+     * Defaults to {@code null}, i.e. the request is not authenticated — which
+     * is independent of the principal the request carries, set through
+     * {@link MockRequest#setUserPrincipalInt(java.security.Principal)}.
+     *
+     * @return the authentication scheme, or {@code null}
+     */
+    public static String getAuthType() {
+        return authType;
+    }
+
+    /**
+     * Sets the authentication scheme {@link MockRequest#getAuthType()} reports.
+     *
+     * @param authType
+     *            the authentication scheme, or {@code null} for an
+     *            unauthenticated request
+     */
+    public static void setAuthType(String authType) {
+        MockHttpEnvironment.authType = authType;
+    }
+
+    /**
+     * Tells whether {@link MockRequest#isSecure()} reports the request as
+     * having arrived over HTTPS. Defaults to {@code false}; nothing else about
+     * the request changes with it.
+     *
+     * @return {@code true} if requests are reported as secure
+     */
+    public static boolean isSecure() {
+        return isSecure;
+    }
+
+    /**
+     * Sets whether {@link MockRequest#isSecure()} reports the request as having
+     * arrived over HTTPS.
+     *
+     * @param isSecure
+     *            {@code true} to report requests as secure
+     */
+    public static void setSecure(boolean isSecure) {
+        MockHttpEnvironment.isSecure = isSecure;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java
new file mode 100644
index 00000000..2d7dcfe0
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.ServletContext;
+import jakarta.servlet.http.HttpSession;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static com.vaadin.browserless.mocks.MockUtils.putOrRemove;
+
+/**
+ * A standalone {@link HttpSession}, backed by an in-memory attribute map.
+ * <p>
+ * Attribute storage, invalidation and
+ * {@link jakarta.servlet.http.HttpServletRequest#changeSessionId()} behave the
+ * way a servlet container implements them, including the failure modes: every
+ * accessor throws {@link IllegalStateException} once the session has been
+ * invalidated. Ids come from a sequential counter rather than being random, so
+ * test output stays readable.
+ * <p>
+ * What is not modeled: the session is never expired on its own, so
+ * {@link #getMaxInactiveInterval()} is stored and reported but never acted on,
+ * and {@link #getLastAccessedTime()} always reports {@code 0}. There is no
+ * request loop to update it.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockHttpSession implements HttpSession, Serializable {
+
+    private volatile String sessionId;
+    private final ServletContext servletContext;
+    private final long creationTime;
+    private int maxInactiveInterval;
+
+    private final ConcurrentHashMap<String, Object> attributes = new ConcurrentHashMap<>();
+    private final AtomicBoolean valid = new AtomicBoolean(true);
+
+    /**
+     * Creates a session with the given id and settings.
+     *
+     * @param sessionId
+     *            the session id
+     * @param servletContext
+     *            the context this session belongs to
+     * @param creationTime
+     *            the creation timestamp reported by {@link #getCreationTime()}
+     * @param maxInactiveInterval
+     *            the inactive interval, in seconds; stored and reported, never
+     *            acted on
+     */
+    public MockHttpSession(String sessionId, ServletContext servletContext,
+            long creationTime, int maxInactiveInterval) {
+        this.sessionId = sessionId;
+        this.servletContext = servletContext;
+        this.creationTime = creationTime;
+        this.maxInactiveInterval = maxInactiveInterval;
+    }
+
+    /**
+     * Creates a copy of the given session, carrying over its id, context,
+     * settings and all of its attributes.
+     *
+     * @param session
+     *            the session to copy
+     */
+    public MockHttpSession(HttpSession session) {
+        this(session.getId(), session.getServletContext(),
+                session.getLastAccessedTime(),
+                session.getMaxInactiveInterval());
+        copyAttributes(session);
+    }
+
+    /**
+     * Tells whether this session is still usable, i.e. has not been
+     * {@link #invalidate() invalidated}.
+     *
+     * @return {@code true} while the session is valid
+     */
+    public boolean isValid() {
+        return valid.get();
+    }
+
+    /**
+     * Drops all attributes, leaving the session itself valid.
+     */
+    public void destroy() {
+        attributes.clear();
+    }
+
+    @Override
+    public long getCreationTime() {
+        checkValid();
+        return creationTime;
+    }
+
+    @Override
+    public String getId() {
+        return sessionId;
+    }
+
+    @Override
+    public long getLastAccessedTime() {
+        checkValid();
+        return 0;
+    }
+
+    @Override
+    public ServletContext getServletContext() {
+        return servletContext;
+    }
+
+    @Override
+    public void setMaxInactiveInterval(int interval) {
+        this.maxInactiveInterval = interval;
+    }
+
+    @Override
+    public int getMaxInactiveInterval() {
+        return maxInactiveInterval;
+    }
+
+    @Override
+    public Object getAttribute(String name) {
+        checkValid();
+        return attributes.get(name);
+    }
+
+    @Override
+    public Enumeration<String> getAttributeNames() {
+        checkValid();
+        return attributes.keys();
+    }
+
+    @Override
+    public void setAttribute(String name, Object value) {
+        checkValid();
+        putOrRemove(attributes, name, value);
+    }
+
+    @Override
+    public void removeAttribute(String name) {
+        checkValid();
+        attributes.remove(name);
+    }
+
+    /**
+     * Copies all attributes of the given session into this one, keeping the
+     * attributes already present.
+     *
+     * @param httpSession
+     *            the session to copy the attributes from
+     * @return this session
+     */
+    public MockHttpSession copyAttributes(HttpSession httpSession) {
+        for (String name : Collections.list(httpSession.getAttributeNames())) {
+            attributes.put(name, httpSession.getAttribute(name));
+        }
+        return this;
+    }
+
+    @Override
+    public void invalidate() {
+        checkValid();
+        valid.set(false);
+    }
+
+    @Override
+    public boolean isNew() {
+        checkValid();
+        return false;
+    }
+
+    private void checkValid() {
+        if (!isValid()) {
+            throw new IllegalStateException("invalidated: " + this);
+        }
+    }
+
+    /**
+     * Assigns a new ID to this session, keeping its identity and all of its
+     * attributes intact, and returns the new ID.
+     * <p>
+     * This mirrors what a servlet container does for
+     * {@link jakarta.servlet.http.HttpServletRequest#changeSessionId()}: apps
+     * which implement session-fixation protection themselves (vanilla and Java
+     * EE apps, i.e. those not relying on Spring Security) call it after a
+     * successful login.
+     *
+     * @return the new session id
+     * @throws IllegalStateException
+     *             if the session has been invalidated
+     */
+    public String changeSessionId() {
+        checkValid();
+        sessionId = newSessionId();
+        return sessionId;
+    }
+
+    @Override
+    public String toString() {
+        return "MockHttpSession(sessionId='" + sessionId + "', creationTime="
+                + creationTime + ", maxInactiveInterval=" + maxInactiveInterval
+                + ", attributes=" + attributes + ", isValid=" + isValid() + ")";
+    }
+
+    private static final AtomicInteger sessionIdGenerator = new AtomicInteger();
+
+    private static String newSessionId() {
+        return Integer.toString(sessionIdGenerator.incrementAndGet());
+    }
+
+    /**
+     * Creates a session in the given context, with a fresh sequential id and a
+     * 30 second inactive interval.
+     *
+     * @param ctx
+     *            the context the session belongs to
+     * @return the new session
+     */
+    public static MockHttpSession create(ServletContext ctx) {
+        return new MockHttpSession(newSessionId(), ctx,
+                System.currentTimeMillis(), 30);
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java
new file mode 100644
index 00000000..cd645fae
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import java.util.stream.Stream;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.HasElement;
+import com.vaadin.flow.di.Instantiator;
+import com.vaadin.flow.i18n.I18NProvider;
+import com.vaadin.flow.router.NavigationEvent;
+import com.vaadin.flow.router.PageTitleGenerator;
+import com.vaadin.flow.server.DependencyFilter;
+import com.vaadin.flow.server.VaadinServiceInitListener;
+import com.vaadin.flow.server.auth.MenuAccessControl;
+import com.vaadin.flow.server.communication.IndexHtmlRequestListener;
+
+/**
+ * An {@link Instantiator} wrapping the one the mocked environment provides.
+ * <p>
+ * The wrapper does not mock anything any more: the {@link #getOrCreate} special
+ * cases it was written for are long gone, so every member simply forwards to
+ * {@link #delegate}. The mocked services therefore use the environment's own
+ * instantiator directly, and this class is kept for source compatibility only.
+ * <p>
+ * The forwarding is spelled out by hand on purpose. A wrapper that leaves a
+ * method out inherits Flow's {@code default} implementation instead of reaching
+ * the delegate, which is how a Spring {@code PageTitleGenerator} bean used to
+ * be dropped in browserless tests. Since a wrapper can always fall behind a
+ * method added to {@link Instantiator} later, {@link #create(Instantiator)}
+ * hands back the delegate itself instead of wrapping it.
+ * <p>
+ * The list of forwarders below is deliberately not guarded by a test: pinning
+ * it would fail the build whenever Flow adds a method to {@link Instantiator},
+ * which is not worth it for a class scheduled for removal and used by nothing
+ * here. A method missing from the list is therefore silently dropped for
+ * callers who construct this class themselves — one more reason not to.
+ *
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ *
+ * @deprecated Wrapping the instantiator of the mocked environment has no
+ *             effect; use that instantiator directly. Scheduled for removal.
+ */
+@Deprecated(forRemoval = true)
+public class MockInstantiator implements Instantiator {
+
+    private final Instantiator delegate;
+
+    /**
+     * Returns the instantiator every member of this class forwards to.
+     *
+     * @return the delegate
+     */
+    public Instantiator getDelegate() {
+        return delegate;
+    }
+
+    /**
+     * Creates a wrapper forwarding to the given instantiator.
+     *
+     * @param delegate
+     *            the instantiator to forward to
+     */
+    public MockInstantiator(Instantiator delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public <T> T getOrCreate(Class<T> type) {
+        return delegate.getOrCreate(type);
+    }
+
+    @Override
+    public Stream<VaadinServiceInitListener> getServiceInitListeners() {
+        return delegate.getServiceInitListeners();
+    }
+
+    @Override
+    public Stream<IndexHtmlRequestListener> getIndexHtmlRequestListeners(
+            Stream<IndexHtmlRequestListener> indexHtmlRequestListeners) {
+        return delegate.getIndexHtmlRequestListeners(indexHtmlRequestListeners);
+    }
+
+    @Override
+    public Stream<DependencyFilter> getDependencyFilters(
+            Stream<DependencyFilter> serviceInitFilters) {
+        return delegate.getDependencyFilters(serviceInitFilters);
+    }
+
+    @Override
+    public Class<?> getApplicationClass(Object instance) {
+        return delegate.getApplicationClass(instance);
+    }
+
+    @Override
+    public Class<?> getApplicationClass(Class<?> clazz) {
+        return delegate.getApplicationClass(clazz);
+    }
+
+    @Override
+    public <T extends HasElement> T createRouteTarget(Class<T> routeTargetType,
+            NavigationEvent event) {
+        return delegate.createRouteTarget(routeTargetType, event);
+    }
+
+    @Override
+    public <T extends Component> T createComponent(Class<T> componentClass) {
+        return delegate.createComponent(componentClass);
+    }
+
+    @Override
+    public I18NProvider getI18NProvider() {
+        return delegate.getI18NProvider();
+    }
+
+    @Override
+    public MenuAccessControl getMenuAccessControl() {
+        return delegate.getMenuAccessControl();
+    }
+
+    @Override
+    public PageTitleGenerator getPageTitleGenerator() {
+        return delegate.getPageTitleGenerator();
+    }
+
+    /**
+     * Returns {@code delegate} as is: wrapping it changes nothing, and a
+     * wrapper risks dropping methods added to {@link Instantiator} in the
+     * future.
+     *
+     * @param delegate
+     *            the instantiator to return
+     * @return the given instantiator, unwrapped
+     */
+    public static Instantiator create(Instantiator delegate) {
+        return delegate;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java
new file mode 100644
index 00000000..2b9220f9
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java
@@ -0,0 +1,744 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.AsyncContext;
+import jakarta.servlet.DispatcherType;
+import jakarta.servlet.RequestDispatcher;
+import jakarta.servlet.ServletConnection;
+import jakarta.servlet.ServletContext;
+import jakarta.servlet.ServletInputStream;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpSession;
+import jakarta.servlet.http.HttpUpgradeHandler;
+import jakarta.servlet.http.Part;
+
+import java.io.BufferedReader;
+import java.security.Principal;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiPredicate;
+import java.util.function.Supplier;
+
+import static com.vaadin.browserless.mocks.MockUtils.putOrRemove;
+
+/**
+ * A standalone {@link HttpServletRequest}, backed by the mocked session.
+ * <p>
+ * Only the parts of a request a Vaadin service reads are modeled: headers,
+ * parameters, cookies, attributes, locale, the session and the security
+ * principal. The rest throws {@link UnsupportedOperationException} rather than
+ * returning a plausible-looking value, so a test that depends on it fails
+ * loudly instead of asserting on a fiction. Ports, the auth type and the secure
+ * flag come from {@link MockHttpEnvironment} and can be changed there.
+ * <p>
+ * Container failure modes are reproduced where application code depends on
+ * them: {@link #getSession(boolean)} reports no session once it has been
+ * invalidated, and {@link #changeSessionId()} refuses to run without one.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockRequest implements HttpServletRequest {
+
+    private HttpSession session;
+
+    /**
+     * The ID of the session the client asked for. Just like in a servlet
+     * container it stays the same for the lifetime of the request, even if the
+     * session ID is rotated via {@link #changeSessionId()} or a new session is
+     * created after invalidation.
+     */
+    private final String initiallyRequestedSessionId;
+
+    /**
+     * Creates a request bound to the given session.
+     *
+     * @param session
+     *            the session this request belongs to
+     */
+    public MockRequest(HttpSession session) {
+        this.session = session;
+        this.initiallyRequestedSessionId = session.getId();
+        headers.put("user-agent",
+                Collections.singletonList("IntelliJ IDEA/182.4892.20"));
+    }
+
+    @Override
+    public ServletInputStream getInputStream() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public AsyncContext startAsync() {
+        throw new UnsupportedOperationException("Unsupported");
+    }
+
+    @Override
+    public AsyncContext startAsync(ServletRequest servletRequest,
+            ServletResponse servletResponse) {
+        throw new UnsupportedOperationException("Unsupported");
+    }
+
+    @Override
+    public String getProtocol() {
+        return "HTTP/1.1";
+    }
+
+    @Override
+    public StringBuffer getRequestURL() {
+        return new StringBuffer("http://localhost:8080/");
+    }
+
+    private String characterEncodingInt = null;
+
+    /**
+     * Returns the encoding set through {@link #setCharacterEncoding(String)},
+     * or {@code null} if none was.
+     *
+     * @return the character encoding, or {@code null}
+     */
+    public String getCharacterEncodingInt() {
+        return characterEncodingInt;
+    }
+
+    /**
+     * Sets the encoding {@link #getCharacterEncoding()} reports.
+     *
+     * @param characterEncodingInt
+     *            the character encoding, or {@code null}
+     */
+    public void setCharacterEncodingInt(String characterEncodingInt) {
+        this.characterEncodingInt = characterEncodingInt;
+    }
+
+    @Override
+    public void setCharacterEncoding(String env) {
+        characterEncodingInt = env;
+    }
+
+    private final Map<String, String[]> parameters = new HashMap<>();
+
+    /**
+     * Returns the request parameters, live and directly modifiable. Prefer
+     * {@link #setParameter(String, String...)} for a single parameter.
+     *
+     * @return the parameters, keyed by name
+     */
+    public Map<String, String[]> getParameters() {
+        return parameters;
+    }
+
+    @Override
+    public String[] getParameterValues(String name) {
+        return parameters.get(name);
+    }
+
+    @Override
+    public boolean isAsyncStarted() {
+        return false;
+    }
+
+    @Override
+    public long getContentLengthLong() {
+        return -1;
+    }
+
+    @Override
+    public void login(String username, String password) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public boolean isRequestedSessionIdValid() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    /**
+     * Returns {@link MockHttpEnvironment#getServerPort()}.
+     */
+    @Override
+    public int getServerPort() {
+        return MockHttpEnvironment.getServerPort();
+    }
+
+    @Override
+    public String getRequestedSessionId() {
+        return initiallyRequestedSessionId;
+    }
+
+    @Override
+    public String getServletPath() {
+        return "";
+    }
+
+    @Override
+    public HttpSession getSession(boolean create) {
+        boolean isValid = !(session instanceof MockHttpSession mockSession)
+                || mockSession.isValid();
+        if (!isValid) {
+            // Mirror the servlet container contract: once the session has been
+            // invalidated there is no current session, so getSession(false)
+            // must return null (and getSession(true) must create a fresh one).
+            // Returning the stale, invalidated session instead made code that
+            // legitimately touches it after logout (e.g. Spring Security's
+            // HttpSessionSecurityContextRepository.saveContext) throw
+            // IllegalStateException. See issue #115.
+            if (!create) {
+                return null;
+            }
+            session = MockHttpSession.create(session.getServletContext());
+        }
+        return session;
+    }
+
+    @Override
+    public HttpSession getSession() {
+        return getSession(true);
+    }
+
+    @Override
+    public String getServerName() {
+        return "127.0.0.1";
+    }
+
+    @Override
+    public String getLocalAddr() {
+        return "127.0.0.1";
+    }
+
+    @Override
+    public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public boolean isRequestedSessionIdFromCookie() {
+        return false;
+    }
+
+    private List<Part> partsInt = null;
+
+    /**
+     * Returns the multipart parts of this request, or {@code null} when no
+     * multipart configuration has been provided.
+     *
+     * @return the parts, or {@code null}
+     */
+    public List<Part> getPartsInt() {
+        return partsInt;
+    }
+
+    /**
+     * Sets the multipart parts of this request. Leave {@code null} to have
+     * {@link #getPart(String)} and {@link #getParts()} fail the way a servlet
+     * container does without a multipart configuration.
+     *
+     * @param partsInt
+     *            the parts, or {@code null}
+     */
+    public void setPartsInt(List<Part> partsInt) {
+        this.partsInt = partsInt;
+    }
+
+    @Override
+    public Part getPart(String name) {
+        if (partsInt == null) {
+            throw new IllegalStateException(
+                    "Unable to process parts as no multi-part configuration has been provided");
+        }
+        for (Part p : partsInt) {
+            if (name.equals(p.getName())) {
+                return p;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public boolean isRequestedSessionIdFromURL() {
+        return false;
+    }
+
+    /**
+     * Returns {@link MockHttpEnvironment#getLocalPort()}.
+     */
+    @Override
+    public int getLocalPort() {
+        return MockHttpEnvironment.getLocalPort();
+    }
+
+    @Override
+    public ServletContext getServletContext() {
+        return session.getServletContext();
+    }
+
+    @Override
+    public String getQueryString() {
+        return null;
+    }
+
+    @Override
+    public DispatcherType getDispatcherType() {
+        return DispatcherType.REQUEST;
+    }
+
+    @Override
+    public String getRequestId() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public String getProtocolRequestId() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public ServletConnection getServletConnection() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public Collection<Part> getParts() {
+        if (partsInt == null) {
+            throw new IllegalStateException(
+                    "Unable to process parts as no multi-part configuration has been provided");
+        }
+        return partsInt;
+    }
+
+    @Override
+    public String getScheme() {
+        return "http";
+    }
+
+    @Override
+    public void logout() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public String getLocalName() {
+        return "localhost";
+    }
+
+    @Override
+    public boolean isAsyncSupported() {
+        return false;
+    }
+
+    @Override
+    public Enumeration<String> getParameterNames() {
+        return Collections.enumeration(parameters.keySet());
+    }
+
+    @Override
+    public boolean authenticate(HttpServletResponse response) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public String getPathTranslated() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public int getIntHeader(String name) {
+        String h = getHeader(name);
+        return h == null ? -1 : Integer.parseInt(h);
+    }
+
+    @Override
+    public String changeSessionId() {
+        // Mirrors the servlet container contract: the session keeps its
+        // identity and its attributes (in particular the VaadinSession), only
+        // the ID changes, and there has to be a session to begin with. Apps
+        // which are not backed by Spring Security implement session-fixation
+        // protection by calling this after a successful login.
+        HttpSession current = getSession(false);
+        if (current == null) {
+            throw new IllegalStateException(
+                    "no session is associated with this request");
+        }
+        if (!(current instanceof MockHttpSession mockSession)) {
+            throw new UnsupportedOperationException(
+                    "changeSessionId() is only supported for MockHttpSession but got "
+                            + current.getClass());
+        }
+        return mockSession.changeSessionId();
+    }
+
+    @Override
+    public AsyncContext getAsyncContext() {
+        throw new IllegalStateException(
+                "async not supported in mock environment");
+    }
+
+    @Override
+    public String getRequestURI() {
+        return "/";
+    }
+
+    @Override
+    public RequestDispatcher getRequestDispatcher(String path) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    /**
+     * Decides whether the request's principal holds a given role. Defaults to
+     * granting nothing.
+     */
+    private BiPredicate<Principal, String> isUserInRole = (p, r) -> false;
+
+    /**
+     * Returns the user-in-role checker.
+     *
+     * @return the checker deciding whether a principal holds a role
+     */
+    public BiPredicate<Principal, String> isUserInRole() {
+        return isUserInRole;
+    }
+
+    /**
+     * Sets the user-in-role checker.
+     *
+     * @param checker
+     *            decides whether a principal holds a role
+     */
+    public void setUserInRole(BiPredicate<Principal, String> checker) {
+        this.isUserInRole = checker;
+    }
+
+    /**
+     * Sets the user-in-role checker using a
+     * {@link java.util.function.BiPredicate}. Java-friendly alternative to
+     * {@link #setUserInRole(BiPredicate)}.
+     *
+     * @param checker
+     *            decides whether a principal holds a role
+     * @since 1.1
+     */
+    public void roleChecker(BiPredicate<Principal, String> checker) {
+        this.isUserInRole = checker;
+    }
+
+    /**
+     * Set {@link #setUserInRole(BiPredicate)} to modify the outcome of this
+     * function.
+     */
+    @Override
+    public boolean isUserInRole(String role) {
+        Principal p = getUserPrincipal();
+        if (p == null) {
+            return false;
+        }
+        return isUserInRole.test(p, role);
+    }
+
+    @Override
+    public String getPathInfo() {
+        return null;
+    }
+
+    @Override
+    public String getRemoteUser() {
+        return null;
+    }
+
+    private Cookie[] cookiesInt = null;
+
+    /**
+     * Returns the cookies {@link #getCookies()} reports, or {@code null} if
+     * none were added.
+     *
+     * @return the cookies, or {@code null}
+     */
+    public Cookie[] getCookiesInt() {
+        return cookiesInt;
+    }
+
+    /**
+     * Replaces the cookies {@link #getCookies()} reports.
+     *
+     * @param cookiesInt
+     *            the cookies, or {@code null} for none
+     */
+    public void setCookiesInt(Cookie[] cookiesInt) {
+        this.cookiesInt = cookiesInt;
+    }
+
+    public void addCookie(Cookie cookie) {
+        if (cookiesInt == null) {
+            cookiesInt = new Cookie[] { cookie };
+        } else {
+            Cookie[] next = Arrays.copyOf(cookiesInt, cookiesInt.length + 1);
+            next[cookiesInt.length] = cookie;
+            cookiesInt = next;
+        }
+    }
+
+    @Override
+    public Cookie[] getCookies() {
+        return cookiesInt;
+    }
+
+    private Locale localeInt = Locale.US;
+
+    /**
+     * Returns the locale {@link #getLocale()} reports. Defaults to
+     * {@link Locale#US}.
+     *
+     * @return the locale
+     */
+    public Locale getLocaleInt() {
+        return localeInt;
+    }
+
+    /**
+     * Sets the locale {@link #getLocale()} reports.
+     *
+     * @param localeInt
+     *            the locale
+     */
+    public void setLocaleInt(Locale localeInt) {
+        this.localeInt = localeInt;
+    }
+
+    @Override
+    public Locale getLocale() {
+        return localeInt;
+    }
+
+    @Override
+    public String getMethod() {
+        return "GET";
+    }
+
+    @Override
+    public Map<String, String[]> getParameterMap() {
+        return parameters;
+    }
+
+    @Override
+    public Enumeration<String> getAttributeNames() {
+        return attributes.keys();
+    }
+
+    @Override
+    public String getRemoteAddr() {
+        return "127.0.0.1";
+    }
+
+    @Override
+    public Enumeration<String> getHeaders(String name) {
+        List<String> h = headers.get(name);
+        return h == null ? Collections.emptyEnumeration()
+                : Collections.enumeration(h);
+    }
+
+    private Principal userPrincipalInt = null;
+
+    /**
+     * Returns the principal reported unless
+     * {@link #principalProvider(java.util.function.Supplier)} has been set.
+     *
+     * @return the principal, or {@code null}
+     */
+    public Principal getUserPrincipalInt() {
+        return userPrincipalInt;
+    }
+
+    /**
+     * Sets the principal to report, unless
+     * {@link #principalProvider(java.util.function.Supplier)} has been set.
+     *
+     * @param userPrincipalInt
+     *            the principal, or {@code null} for an anonymous request
+     */
+    public void setUserPrincipalInt(Principal userPrincipalInt) {
+        this.userPrincipalInt = userPrincipalInt;
+    }
+
+    /**
+     * Optional provider for {@link #getUserPrincipal()}. When set, takes
+     * precedence over {@link #userPrincipalInt}, allowing the principal to be
+     * resolved lazily at call time (e.g. from a security context that is
+     * populated after setup). Set via
+     * {@link #principalProvider(java.util.function.Supplier)}.
+     *
+     * @since 1.1
+     */
+    private Supplier<Principal> userPrincipalProvider;
+
+    /**
+     * Returns the principal provider, if one has been set.
+     *
+     * @return the provider, or {@code null} if the principal comes from
+     *         {@link #userPrincipalInt}
+     * @since 1.1
+     */
+    public Supplier<Principal> getUserPrincipalProvider() {
+        return userPrincipalProvider;
+    }
+
+    /**
+     * Sets the user principal provider. Accepts a
+     * {@link java.util.function.Supplier} so Java callers can pass a lambda
+     * directly; Kotlin callers can do the same via SAM conversion.
+     *
+     * @param supplier
+     *            resolves the principal at call time
+     * @since 1.1
+     */
+    public void principalProvider(Supplier<Principal> supplier) {
+        this.userPrincipalProvider = supplier;
+    }
+
+    /**
+     * Returns the principal from {@link #userPrincipalProvider} if set,
+     * otherwise falls back to {@link #userPrincipalInt}.
+     */
+    @Override
+    public Principal getUserPrincipal() {
+        if (userPrincipalProvider != null) {
+            return userPrincipalProvider.get();
+        }
+        return userPrincipalInt;
+    }
+
+    @Override
+    public BufferedReader getReader() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public Enumeration<Locale> getLocales() {
+        return Collections.enumeration(Collections.singletonList(getLocale()));
+    }
+
+    /**
+     * Returns {@link MockHttpEnvironment#getAuthType()}
+     */
+    @Override
+    public String getAuthType() {
+        return MockHttpEnvironment.getAuthType();
+    }
+
+    @Override
+    public String getCharacterEncoding() {
+        return null;
+    }
+
+    @Override
+    public void removeAttribute(String name) {
+        attributes.remove(name);
+    }
+
+    @Override
+    public int getContentLength() {
+        return -1;
+    }
+
+    private final ConcurrentHashMap<String, List<String>> headers = new ConcurrentHashMap<>();
+
+    /**
+     * Returns the request headers, live and directly modifiable.
+     *
+     * @return the headers, keyed by name
+     */
+    public ConcurrentHashMap<String, List<String>> getHeaders() {
+        return headers;
+    }
+
+    @Override
+    public String getHeader(String headerName) {
+        List<String> h = headers.get(headerName);
+        return h == null ? null : h.get(0);
+    }
+
+    @Override
+    public String getContextPath() {
+        return "";
+    }
+
+    @Override
+    public String getContentType() {
+        return null;
+    }
+
+    @Override
+    public Enumeration<String> getHeaderNames() {
+        return headers.keys();
+    }
+
+    private final ConcurrentHashMap<String, Object> attributes = new ConcurrentHashMap<>();
+
+    @Override
+    public Object getAttribute(String name) {
+        return attributes.get(name);
+    }
+
+    @Override
+    public void setAttribute(String name, Object value) {
+        putOrRemove(attributes, name, value);
+    }
+
+    @Override
+    public String getParameter(String parameter) {
+        String[] v = parameters.get(parameter);
+        return v == null ? null : v[0];
+    }
+
+    /**
+     * Returns {@link MockHttpEnvironment#getRemotePort()}.
+     */
+    @Override
+    public int getRemotePort() {
+        return MockHttpEnvironment.getRemotePort();
+    }
+
+    @Override
+    public long getDateHeader(String name) {
+        return -1;
+    }
+
+    @Override
+    public String getRemoteHost() {
+        return "127.0.0.1";
+    }
+
+    /**
+     * Returns {@link MockHttpEnvironment#isSecure()}
+     */
+    @Override
+    public boolean isSecure() {
+        return MockHttpEnvironment.isSecure();
+    }
+
+    public void setParameter(String name, String... values) {
+        parameters.put(name, Arrays.copyOf(values, values.length));
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java
new file mode 100644
index 00000000..3c828587
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.ServletOutputStream;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletResponse;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Locale;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.stream.Collectors;
+
+/**
+ * A standalone {@link HttpServletResponse} that records what was written to it
+ * instead of sending anything.
+ * <p>
+ * Headers, cookies, the status and the content type are kept in fields a test
+ * can read back, which is how an assertion about a response is made without a
+ * browser — {@code currentResponse.getCookie("foo").getValue()}, for example.
+ * URL encoding is the identity function, since there is no session to encode
+ * into a URL.
+ * <p>
+ * There is no body: the response writes nowhere, so {@link #getOutputStream()},
+ * {@link #getWriter()} and {@link #sendRedirect(String)} throw
+ * {@link UnsupportedOperationException} rather than swallowing output a test
+ * might expect to find later.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockResponse implements HttpServletResponse {
+
+    @Override
+    public String encodeURL(String url) {
+        return url;
+    }
+
+    private final ConcurrentHashMap<String, String[]> headers = new ConcurrentHashMap<>();
+
+    /**
+     * Returns the headers set on this response, keyed by name. Live and
+     * directly readable.
+     *
+     * @return the headers
+     */
+    public ConcurrentHashMap<String, String[]> getHeaders() {
+        return headers;
+    }
+
+    @Override
+    public void addIntHeader(String name, int value) {
+        addHeader(name, Integer.toString(value));
+    }
+
+    private final CopyOnWriteArrayList<Cookie> cookies = new CopyOnWriteArrayList<>();
+
+    /**
+     * Returns the cookies added to this response, in the order they were added.
+     *
+     * @return the cookies
+     */
+    public CopyOnWriteArrayList<Cookie> getCookies() {
+        return cookies;
+    }
+
+    @Override
+    public void addCookie(Cookie cookie) {
+        cookies.add(cookie);
+    }
+
+    /**
+     * Returns the cookie with the given name, failing if there is none.
+     *
+     * @param name
+     *            the cookie name
+     * @return the cookie, never {@code null}
+     * @throws IllegalStateException
+     *             if no cookie of that name was added; the message lists the
+     *             cookies that were
+     */
+    public Cookie getCookie(String name) {
+        Cookie c = findCookie(name);
+        if (c == null) {
+            String avail = cookies.stream()
+                    .map(it -> it.getName() + "=" + it.getValue())
+                    .collect(Collectors.joining(", "));
+            throw new IllegalStateException("no such cookie with name " + name
+                    + ". Available cookies: " + avail);
+        }
+        return c;
+    }
+
+    /**
+     * Returns the cookie with the given name, or {@code null} if there is none.
+     *
+     * @param name
+     *            the cookie name
+     * @return the cookie, or {@code null}
+     */
+    public Cookie findCookie(String name) {
+        for (Cookie c : cookies) {
+            if (c.getName().equals(name)) {
+                return c;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public void flushBuffer() {
+        // not needed at the moment
+    }
+
+    @Override
+    public String encodeRedirectURL(String url) {
+        return url;
+    }
+
+    @Override
+    public void sendRedirect(String location) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void sendRedirect(String location, int sc, boolean clearBuffer) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    private int bufferSize = 4096;
+
+    @Override
+    public void setBufferSize(int size) {
+        this.bufferSize = size;
+    }
+
+    private Locale locale = Locale.US;
+
+    @Override
+    public Locale getLocale() {
+        return locale;
+    }
+
+    @Override
+    public void sendError(int sc, String msg) throws IOException {
+        throw new IOException("The app requests a failure: " + sc + " " + msg);
+    }
+
+    @Override
+    public void sendError(int sc) throws IOException {
+        throw new IOException("The app requests a failure: " + sc);
+    }
+
+    @Override
+    public void setContentLengthLong(long len) {
+        // not needed at the moment
+    }
+
+    private String characterEncoding = "ISO-8859-1";
+
+    @Override
+    public void setCharacterEncoding(String charset) {
+        this.characterEncoding = charset;
+    }
+
+    @Override
+    public void addDateHeader(String name, long date) {
+        addHeader(name, Long.toString(date));
+    }
+
+    @Override
+    public void setLocale(Locale loc) {
+        this.locale = loc;
+    }
+
+    @Override
+    public Collection<String> getHeaders(String name) {
+        String[] h = headers.get(name);
+        return h == null ? Collections.emptyList() : Arrays.asList(h);
+    }
+
+    @Override
+    public void addHeader(String name, String value) {
+        headers.compute(name, (k, v) -> {
+            if (v == null) {
+                return new String[] { value };
+            }
+            String[] copy = Arrays.copyOf(v, v.length + 1);
+            copy[v.length] = value;
+            return copy;
+        });
+    }
+
+    @Override
+    public void setContentLength(int len) {
+        // not needed at the moment
+    }
+
+    @Override
+    public int getBufferSize() {
+        return bufferSize;
+    }
+
+    @Override
+    public void resetBuffer() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void reset() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void setDateHeader(String name, long date) {
+        setHeader(name, Long.toString(date));
+    }
+
+    private int status = 200;
+
+    @Override
+    public int getStatus() {
+        return status;
+    }
+
+    @Override
+    public String getCharacterEncoding() {
+        return characterEncoding;
+    }
+
+    @Override
+    public boolean isCommitted() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void setStatus(int sc) {
+        this.status = sc;
+    }
+
+    @Override
+    public String getHeader(String name) {
+        String[] h = headers.get(name);
+        return h == null ? null : h[0];
+    }
+
+    private String contentType = null;
+
+    @Override
+    public String getContentType() {
+        return contentType;
+    }
+
+    @Override
+    public PrintWriter getWriter() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public boolean containsHeader(String name) {
+        return headers.containsKey(name);
+    }
+
+    @Override
+    public void setIntHeader(String name, int value) {
+        setHeader(name, Integer.toString(value));
+    }
+
+    @Override
+    public Collection<String> getHeaderNames() {
+        return new LinkedHashSet<>(headers.keySet());
+    }
+
+    @Override
+    public void setHeader(String name, String value) {
+        headers.put(name, new String[] { value });
+    }
+
+    @Override
+    public ServletOutputStream getOutputStream() {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public void setContentType(String type) {
+        this.contentType = type;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java
new file mode 100644
index 00000000..4c641ef8
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import com.vaadin.browserless.internal.UIFactory;
+import com.vaadin.flow.function.DeploymentConfiguration;
+import com.vaadin.flow.server.VaadinRequest;
+import com.vaadin.flow.server.VaadinServlet;
+import com.vaadin.flow.server.VaadinServletService;
+import com.vaadin.flow.server.VaadinSession;
+
+/**
+ * The {@link VaadinServletService} of the mocked environment.
+ * <p>
+ * It stands in for a deployed service in the three places a browserless test
+ * has nothing to offer:
+ * <ul>
+ * <li>{@link #isAtmosphereAvailable()} reports that Atmosphere is absent, which
+ * it is. Vaadin initializes push during {@code VaadinService.init()} and
+ * crashes otherwise.</li>
+ * <li>{@link #getMainDivId(VaadinSession, VaadinRequest)} returns a fixed root
+ * id, since there is no bootstrap page to read one from.</li>
+ * <li>{@link #createVaadinSession(VaadinRequest)} returns a
+ * {@link MockVaadinSession}, which recreates the session after it is closed,
+ * the way a servlet container does when the browser reloads after a
+ * logout.</li>
+ * </ul>
+ * Object creation is <em>not</em> mocked. The service uses whatever
+ * {@link com.vaadin.flow.di.Instantiator} the environment's
+ * {@link com.vaadin.flow.di.Lookup} provides, which is how views and beans
+ * still come from the real container.
+ * <p>
+ * The class is not final, so a custom service can be registered by overriding
+ * {@link MockVaadinServlet#createServletService(DeploymentConfiguration)}, but
+ * the shape of what it overrides is not part of the published API.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockService extends VaadinServletService {
+
+    private final UIFactory uiFactory;
+
+    /**
+     * Returns the factory producing the {@link com.vaadin.flow.component.UI} of
+     * every session this service creates.
+     *
+     * @return the UI factory
+     */
+    public UIFactory getUiFactory() {
+        return uiFactory;
+    }
+
+    /**
+     * Creates a service whose sessions produce {@link MockedUI} instances.
+     *
+     * @param servlet
+     *            the servlet owning this service
+     * @param deploymentConfiguration
+     *            the configuration to run with
+     */
+    public MockService(VaadinServlet servlet,
+            DeploymentConfiguration deploymentConfiguration) {
+        this(servlet, deploymentConfiguration, MockedUI::new);
+    }
+
+    /**
+     * Creates a service whose sessions produce UIs from the given factory.
+     *
+     * @param servlet
+     *            the servlet owning this service
+     * @param deploymentConfiguration
+     *            the configuration to run with
+     * @param uiFactory
+     *            produces a fresh UI per session; it must return a new instance
+     *            every time, or a test inherits the previous test's state
+     */
+    public MockService(VaadinServlet servlet,
+            DeploymentConfiguration deploymentConfiguration,
+            UIFactory uiFactory) {
+        super(servlet, deploymentConfiguration);
+        this.uiFactory = uiFactory;
+    }
+
+    // Has to be an override: clearing VaadinService.atmosphereAvailable
+    // reflectively once the servlet is initialized is too late, since
+    // Atmosphere is set up in VaadinService.init().
+    @Override
+    protected boolean isAtmosphereAvailable() {
+        return false;
+    }
+
+    @Override
+    public String getMainDivId(VaadinSession session, VaadinRequest request) {
+        return "ROOT-1";
+    }
+
+    @Override
+    protected VaadinSession createVaadinSession(VaadinRequest request) {
+        return new MockVaadinSession(this, uiFactory);
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockServletConfig.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockServletConfig.java
new file mode 100644
index 00000000..ffb4fc75
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockServletConfig.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.ServletConfig;
+import jakarta.servlet.ServletContext;
+
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The {@link ServletConfig} the mocked servlet is initialized with.
+ * <p>
+ * It carries the per-servlet init parameters and the {@link ServletContext},
+ * which is the whole of what a Vaadin servlet reads from its config. The
+ * servlet name is fixed at {@code "Vaadin Servlet"}.
+ * <p>
+ * Init parameters are read while the servlet initializes, so they have to be in
+ * {@link #getServletInitParams()} before {@code Servlet.init(ServletConfig)} is
+ * called; setting one afterwards has no effect.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockServletConfig implements ServletConfig {
+
+    private final ServletContext context;
+
+    /**
+     * Creates a config for a servlet in the given context, with no init
+     * parameters.
+     *
+     * @param context
+     *            the context the servlet belongs to
+     */
+    public MockServletConfig(ServletContext context) {
+        this.context = context;
+    }
+
+    /**
+     * Returns the context the configured servlet belongs to. Same value as
+     * {@link #getServletContext()}.
+     *
+     * @return the servlet context
+     */
+    public ServletContext getContext() {
+        return context;
+    }
+
+    private Map<String, String> servletInitParams = new HashMap<>();
+
+    /**
+     * Returns the per-servlet init parameters, live and directly modifiable.
+     * Populate before the servlet is initialized.
+     *
+     * @return the init parameters
+     */
+    public Map<String, String> getServletInitParams() {
+        return servletInitParams;
+    }
+
+    /**
+     * Replaces the per-servlet init parameters.
+     *
+     * @param servletInitParams
+     *            the init parameters
+     */
+    public void setServletInitParams(Map<String, String> servletInitParams) {
+        this.servletInitParams = servletInitParams;
+    }
+
+    @Override
+    public String getInitParameter(String name) {
+        return servletInitParams.get(name);
+    }
+
+    @Override
+    public Enumeration<String> getInitParameterNames() {
+        return Collections.enumeration(servletInitParams.keySet());
+    }
+
+    @Override
+    public String getServletName() {
+        return "Vaadin Servlet";
+    }
+
+    @Override
+    public ServletContext getServletContext() {
+        return context;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockUtils.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockUtils.java
new file mode 100644
index 00000000..148da80f
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockUtils.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import java.util.Map;
+
+/**
+ * Helpers shared by the mocks in this package.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class MockUtils {
+
+    private MockUtils() {
+    }
+
+    /**
+     * Stores the value under the key, or removes the key when the value is
+     * {@code null}.
+     * <p>
+     * This is what the servlet API asks for: setting an attribute to
+     * {@code null} removes it. It also keeps the mocks usable with a map that
+     * rejects null values, such as
+     * {@link java.util.concurrent.ConcurrentHashMap}.
+     *
+     * @param map
+     *            the map to modify
+     * @param key
+     *            the key to store under or remove
+     * @param value
+     *            the value to store, or {@code null} to remove the key
+     * @param <K>
+     *            the key type
+     * @param <V>
+     *            the value type
+     */
+    public static <K, V> void putOrRemove(Map<K, V> map, K key, V value) {
+        if (value == null) {
+            map.remove(key);
+        } else {
+            map.put(key, value);
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java
new file mode 100644
index 00000000..f49f5404
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java
@@ -0,0 +1,372 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.ServletContext;
+import jakarta.servlet.annotation.HandlesTypes;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import tools.jackson.databind.ObjectMapper;
+import tools.jackson.databind.node.ObjectNode;
+
+import com.vaadin.browserless.internal.UtilsKt;
+import com.vaadin.flow.component.geolocation.BrowserlessGeolocationClientFactory;
+import com.vaadin.flow.component.geolocation.GeolocationClientFactory;
+import com.vaadin.flow.di.Lookup;
+import com.vaadin.flow.di.LookupInitializer;
+import com.vaadin.flow.server.VaadinContext;
+import com.vaadin.flow.server.VaadinServlet;
+import com.vaadin.flow.server.VaadinServletContext;
+import com.vaadin.flow.server.startup.LookupServletContainerInitializer;
+
+/**
+ * Builds the {@link ServletContext} the mocked environment runs in.
+ * <p>
+ * A deployed application gets its context from the servlet container, which
+ * runs Vaadin's {@code ServletContainerInitializer}s to install the
+ * {@link Lookup}. There is no container here, so
+ * {@link #createMockContext(Set)} creates a {@link MockContext} and runs the
+ * lookup initializer over it by hand, seeding it with Vaadin's own services
+ * plus whatever the test asked for. Everything downstream — the instantiator,
+ * the application configuration, the route registry — is then resolved through
+ * that {@link Lookup}, exactly as in a real deployment.
+ * <p>
+ * It also papers over the one thing a component module cannot provide:
+ * {@link #mockFlowBuildInfo(VaadinServlet)} writes a dummy token file when
+ * there is no {@code flow-build-info.json} on the classpath, which Vaadin's
+ * mode detection would otherwise reject.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class MockVaadinHelper {
+
+    private MockVaadinHelper() {
+    }
+
+    private static volatile boolean flowBuildInfoInitialized = false;
+    private static volatile ObjectNode flowBuildInfoValue = null;
+
+    private static ObjectNode flowBuildInfo() {
+        if (!flowBuildInfoInitialized) {
+            synchronized (MockVaadinHelper.class) {
+                if (!flowBuildInfoInitialized) {
+                    flowBuildInfoValue = getTokenFileFromClassloader();
+                    flowBuildInfoInitialized = true;
+                }
+            }
+        }
+        return flowBuildInfoValue;
+    }
+
+    /**
+     * Makes sure the servlet can read a {@code flow-build-info.json}, writing a
+     * dummy one when the classpath has none.
+     *
+     * <p>
+     * Without it {@code DeploymentConfigurationFactory.verifyMode()} rejects
+     * the environment, which is what happens when the tests run inside a Vaadin
+     * component module rather than an application.
+     *
+     * @param servlet
+     *            the servlet whose context to configure
+     */
+    public static void mockFlowBuildInfo(VaadinServlet servlet) {
+        // we need to skip the test at DeploymentConfigurationFactory.verifyMode
+        // otherwise
+        // testing a Vaadin 15 component module in npm mode without
+        // webpack.config.js nor flow-build-info.json would fail.
+        if (flowBuildInfo() == null) {
+            // probably inside a Vaadin 15 component module. create a dummy
+            // token file so that
+            // DeploymentConfigurationFactory.verifyMode() is happy.
+            try {
+                File tokenFile = File.createTempFile("flow-build-info", "json");
+                Files.write(tokenFile.toPath(),
+                        "{}".getBytes(StandardCharsets.UTF_8));
+                servlet.getServletContext().setInitParameter(
+                        "vaadin.frontend.token.file",
+                        tokenFile.getAbsolutePath());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        servlet.getServletContext().setInitParameter("compatibilityMode",
+                "false");
+    }
+
+    /**
+     * Creates a context holding a {@link Lookup} with Vaadin's own services.
+     *
+     * @return the new context
+     */
+    public static ServletContext createMockContext() {
+        return createMockContext(Collections.emptySet());
+    }
+
+    /**
+     * Creates a context holding a {@link Lookup} with Vaadin's own services
+     * plus the given ones.
+     *
+     * @param lookupServices
+     *            extra service implementations to register; one supplied here
+     *            wins over the default for the same service interface
+     * @return the new context
+     */
+    public static ServletContext createMockContext(
+            Set<Class<?>> lookupServices) {
+        MockContext ctx = new MockContext();
+        init(ctx, lookupServices);
+        return ctx;
+    }
+
+    /**
+     * Creates a {@link VaadinContext} wrapping a fresh
+     * {@link #createMockContext()}.
+     *
+     * @return the new context
+     */
+    public static VaadinContext createMockVaadinContext() {
+        return new VaadinServletContext(createMockContext());
+    }
+
+    /**
+     * Reads {@code flow-build-info.json} from the classpath the same way Vaadin
+     * does, through {@code DefaultApplicationConfigurationFactory}.
+     *
+     * @return the parsed token file, or {@code null} if the classpath has none
+     */
+    public static ObjectNode getTokenFileFromClassloader() {
+
+        // Use
+        // DefaultApplicationConfigurationFactory.getTokenFileFromClassloader()
+        // to make sure to read
+        // the same flow-build-info.json that Vaadin reads.
+
+        VaadinContext ctx = createMockVaadinContext();
+        Object acf;
+        Class<?> dacfClass;
+        try {
+            acf = lookup(ctx, UtilsKt.findClassOrThrow(
+                    "com.vaadin.flow.server.startup.ApplicationConfigurationFactory"));
+            dacfClass = UtilsKt.findClassOrThrow(
+                    "com.vaadin.flow.server.startup.DefaultApplicationConfigurationFactory");
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+        if (acf == null) {
+            throw new IllegalStateException(
+                    "ApplicationConfigurationFactory is null");
+        }
+        if (dacfClass.isInstance(acf)) {
+            try {
+                Method m = dacfClass.getDeclaredMethod(
+                        "getTokenFileFromClassloader", VaadinContext.class);
+                m.setAccessible(true);
+                String json = (String) m.invoke(acf, ctx);
+                if (json == null) {
+                    return null;
+                }
+                return (ObjectNode) new ObjectMapper().readTree(json);
+            } catch (ReflectiveOperationException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Looks a service up in the context's {@link Lookup}.
+     *
+     * @param ctx
+     *            the context to look in; it must already hold a {@link Lookup}
+     * @param clazz
+     *            the service interface to resolve
+     * @return the service, or {@code null} if none is registered
+     * @throws IllegalStateException
+     *             if the context holds no {@link Lookup}
+     */
+    public static Object lookup(VaadinContext ctx, Class<?> clazz) {
+        Lookup lookup = verifyHasLookup(ctx);
+        return lookup.lookup(clazz);
+    }
+
+    /**
+     * Verifies that the ctx has an instance of `com.vaadin.flow.di.Lookup` set,
+     * and returns it.
+     * 
+     * @return the instance of `com.vaadin.flow.di.Lookup`.
+     */
+    private static Lookup verifyHasLookup(ServletContext ctx) {
+        Object lookup = ctx.getAttribute("com.vaadin.flow.di.Lookup");
+        if (lookup == null) {
+            throw new IllegalStateException(
+                    "The context doesn't contain the Vaadin 19 Lookup class. Available attributes: "
+                            + Collections.list(ctx.getAttributeNames()));
+        }
+        return (Lookup) lookup;
+    }
+
+    private static Lookup verifyHasLookup(VaadinContext ctx) {
+        return verifyHasLookup(((VaadinServletContext) ctx).getContext());
+    }
+
+    private static void init(ServletContext ctx, Set<Class<?>> lookupServices) {
+
+        Set<Class<?>> loaders = new LinkedHashSet<>();
+        loaders.addAll(lookupServices);
+        loaders.add(LookupInitializer.class);
+        try {
+            loaders.add(UtilsKt.findClassOrThrow(
+                    "com.vaadin.flow.di.LookupInitializer$ResourceProviderImpl"));
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+
+        tryLoad(loaders,
+                "com.vaadin.flow.component.polymertemplate.rpc.PolymerPublishedEventRpcHandler");
+        tryLoad(loaders,
+                "com.vaadin.fusion.frontend.EndpointGeneratorTaskFactoryImpl");
+
+        LookupServletContainerInitializer loaderInitializer = setupLookupInitializer(
+                loaders);
+
+        try {
+            loaderInitializer.onStartup(loaders, ctx);
+        } catch (jakarta.servlet.ServletException e) {
+            throw new RuntimeException(e);
+        }
+
+        // verify that the Lookup has been set
+        verifyHasLookup(ctx);
+    }
+
+    private static void tryLoad(Set<Class<?>> loaders, String className) {
+        // sometimes customers don't include entire vaadin-core and exclude
+        // stuff like fusion on purpose.
+        // load the class only if it exists.
+        Class<?> clazz = UtilsKt.findClass(className);
+        if (clazz != null) {
+            loaders.add(clazz);
+        }
+    }
+
+    private static LookupServletContainerInitializer setupLookupInitializer(
+            Set<Class<?>> services) {
+        BrowserlessLookupInitializer initializer = new BrowserlessLookupInitializer();
+        initializer.updateServices(services);
+        return initializer;
+    }
+
+    /**
+     * The lookup initializer of the mocked environment.
+     * <p>
+     * It extends Vaadin's own with the services a browserless test needs on top
+     * of the ones {@code LookupServletContainerInitializer} declares in its
+     * {@link HandlesTypes} annotation — the browserless geolocation client, for
+     * one. Subclass it and replace {@link #additionalServices} to add more.
+     * <p>
+     * For internal use only. May be renamed or removed in a future release.
+     */
+    public static class BrowserlessLookupInitializer
+            extends LookupServletContainerInitializer {
+
+        /**
+         * Services the testing environment wires through the {@link Lookup},
+         * mapping a service interface to its default implementation.
+         * <p>
+         * An entry is skipped when the caller already supplied an
+         * implementation of that interface. Map an interface to {@link Object}
+         * to declare a service that has no default but can be hooked in by a
+         * test, e.g. {@code Map.of(Service.class, Object.class)}.
+         */
+        protected Map<Class<?>, Class<?>> additionalServices;
+
+        /**
+         * Creates an initializer registering the browserless environment's own
+         * services.
+         */
+        public BrowserlessLookupInitializer() {
+            Map<Class<?>, Class<?>> map = new LinkedHashMap<>();
+            map.put(GeolocationClientFactory.class,
+                    BrowserlessGeolocationClientFactory.class);
+            this.additionalServices = map;
+        }
+
+        /**
+         * Adds the default implementation of every {@link #additionalServices}
+         * entry the caller has not already covered.
+         *
+         * @param services
+         *            the service implementations to register, modified in place
+         */
+        public void updateServices(Set<Class<?>> services) {
+            for (Map.Entry<Class<?>, Class<?>> entry : additionalServices
+                    .entrySet()) {
+                // skip if the caller already supplied an implementation of the
+                // service interface
+                boolean alreadySupplied = false;
+                for (Class<?> s : services) {
+                    if (entry.getKey().isAssignableFrom(s)) {
+                        alreadySupplied = true;
+                        break;
+                    }
+                }
+                if (alreadySupplied) {
+                    continue;
+                }
+                // ignore additional services without default implementation
+                if (entry.getValue() == Object.class) {
+                    continue;
+                }
+                services.add(entry.getValue());
+            }
+        }
+
+        @Override
+        protected Collection<Class<?>> getServiceTypes() {
+            HandlesTypes annotation = LookupServletContainerInitializer.class
+                    .getAnnotation(HandlesTypes.class);
+            if (annotation == null) {
+                throw new IllegalStateException(
+                        "Cannot collect service types based on "
+                                + HandlesTypes.class.getSimpleName()
+                                + " annotation. The default 'getServiceTypes' method implementation can't be used.");
+            }
+            Set<Class<?>> result = new LinkedHashSet<>();
+            Collections.addAll(result, annotation.value());
+            result.addAll(additionalServices.keySet());
+            Set<Class<?>> filtered = new LinkedHashSet<>();
+            for (Class<?> c : result) {
+                if (c != LookupInitializer.class) {
+                    filtered.add(c);
+                }
+            }
+            return filtered;
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java
new file mode 100644
index 00000000..c4434b3a
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java
@@ -0,0 +1,254 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+import com.vaadin.browserless.internal.Routes;
+import com.vaadin.browserless.internal.UIFactory;
+import com.vaadin.flow.function.DeploymentConfiguration;
+import com.vaadin.flow.server.ServiceException;
+import com.vaadin.flow.server.VaadinRequest;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinServlet;
+import com.vaadin.flow.server.VaadinServletContext;
+import com.vaadin.flow.server.VaadinServletRequest;
+import com.vaadin.flow.server.VaadinServletResponse;
+import com.vaadin.flow.server.VaadinServletService;
+import com.vaadin.flow.server.VaadinSession;
+import com.vaadin.flow.server.WebBrowser;
+
+/**
+ * The {@link VaadinServlet} of the mocked environment.
+ * <p>
+ * It registers the routes it was given into the route registry, which a
+ * deployment would otherwise populate by classpath scanning at startup, and it
+ * creates a {@link MockService} in place of a vanilla
+ * {@link VaadinServletService}.
+ * <p>
+ * It also carries the static helpers that reach into Flow for things a test
+ * cannot construct directly — a {@link VaadinServletRequest}, a
+ * {@link VaadinServletResponse}, a {@link WebBrowser} or a
+ * {@link VaadinSession}.
+ * <p>
+ * To use a custom servlet instead of this one, pass it to
+ * {@link com.vaadin.browserless.internal.MockVaadin#setup}.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockVaadinServlet extends VaadinServlet {
+
+    private final Routes routes;
+
+    private final UIFactory uiFactory;
+
+    /**
+     * Creates a servlet with no routes, producing {@link MockedUI} instances.
+     */
+    public MockVaadinServlet() {
+        this(new Routes(), MockedUI::new);
+    }
+
+    /**
+     * Creates a servlet serving the given routes, producing {@link MockedUI}
+     * instances.
+     *
+     * @param routes
+     *            the routes to register
+     */
+    public MockVaadinServlet(Routes routes) {
+        this(routes, MockedUI::new);
+    }
+
+    /**
+     * Creates a servlet serving the given routes, producing UIs from the given
+     * factory.
+     *
+     * @param routes
+     *            the routes to register
+     * @param uiFactory
+     *            produces a fresh UI per session
+     */
+    public MockVaadinServlet(Routes routes, UIFactory uiFactory) {
+        this.routes = routes;
+        this.uiFactory = uiFactory;
+    }
+
+    /**
+     * Returns the routes this servlet registers.
+     *
+     * @return the routes
+     */
+    public Routes getRoutes() {
+        return routes;
+    }
+
+    /**
+     * Returns the factory producing the {@link com.vaadin.flow.component.UI} of
+     * every session this servlet's service creates.
+     *
+     * @return the UI factory
+     */
+    public UIFactory getUiFactory() {
+        return uiFactory;
+    }
+
+    @Override
+    protected DeploymentConfiguration createDeploymentConfiguration()
+            throws ServletException {
+        MockVaadinHelper.mockFlowBuildInfo(this);
+        return super.createDeploymentConfiguration();
+    }
+
+    @Override
+    protected VaadinServletService createServletService(
+            DeploymentConfiguration deploymentConfiguration)
+            throws ServiceException {
+        VaadinServletService service = new MockService(this,
+                deploymentConfiguration, uiFactory);
+        service.init();
+        routes.register((VaadinServletContext) service.getContext());
+        return service;
+    }
+
+    private static final Method _VaadinServlet_getService;
+    private static final Constructor<?> _VaadinServletRequest_constructor;
+    private static final Constructor<?> _VaadinServletResponse_constructor;
+    private static final Constructor<WebBrowser> _WebBrowser_constructor;
+    private static final Method _VaadinService_createVaadinSession;
+
+    static {
+        try {
+            _VaadinServlet_getService = VaadinServlet.class
+                    .getDeclaredMethod("getService");
+        } catch (NoSuchMethodException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+        _VaadinServletRequest_constructor = findTwoArgConstructor(
+                VaadinServletRequest.class);
+        _VaadinServletResponse_constructor = findTwoArgConstructor(
+                VaadinServletResponse.class);
+        try {
+            _WebBrowser_constructor = WebBrowser.class
+                    .getDeclaredConstructor(VaadinRequest.class);
+            _WebBrowser_constructor.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+        try {
+            _VaadinService_createVaadinSession = VaadinService.class
+                    .getDeclaredMethod("createVaadinSession",
+                            VaadinRequest.class);
+            _VaadinService_createVaadinSession.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    private static Constructor<?> findTwoArgConstructor(Class<?> cls) {
+        for (Constructor<?> c : cls.getDeclaredConstructors()) {
+            if (c.getParameterCount() == 2) {
+                return c;
+            }
+        }
+        throw new ExceptionInInitializerError("No 2-arg constructor in " + cls);
+    }
+
+    /**
+     * Workaround for https://github.com/mvysny/karibu-testing/issues/66
+     */
+    public static VaadinServletService serviceSafe(VaadinServlet servlet) {
+        // we need to use the reflection. The problem is that the signature
+        // of the method differs between Vaadin versions:
+        //
+        // Vaadin 14.6: getService() returns VaadinService
+        // Vaadin 20+: getService() returns VaadinServletService
+        //
+        // calling the method directly will cause MethodNotFoundError on Vaadin
+        // 20+
+        try {
+            return (VaadinServletService) _VaadinServlet_getService
+                    .invoke(servlet);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Workaround for https://github.com/mvysny/karibu-testing/issues/66
+     */
+    public static VaadinServletRequest createVaadinServletRequest(
+            HttpServletRequest request, VaadinService service) {
+        // we need to use the reflection. The problem is that the signature
+        // of the constructor differs between Vaadin versions:
+        //
+        // Vaadin 14.6: VaadinServletRequest(HttpServletRequest,
+        // VaadinServletService)
+        // Vaadin 20+: VaadinServletRequest(HttpServletRequest, VaadinService)
+        //
+        // calling the constructor directly will cause MethodNotFoundError.
+        try {
+            return (VaadinServletRequest) _VaadinServletRequest_constructor
+                    .newInstance(request, service);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Workaround for https://github.com/mvysny/karibu-testing/issues/66
+     */
+    public static VaadinServletResponse createVaadinServletResponse(
+            HttpServletResponse response, VaadinService service) {
+        // we need to use the reflection. The problem is that the signature
+        // of the constructor differs between Vaadin versions:
+        //
+        // Vaadin 14.6: VaadinServletResponse(HttpServletResponse,
+        // VaadinServletService)
+        // Vaadin 20+: VaadinServletResponse(HttpServletResponse, VaadinService)
+        //
+        // calling the constructor directly will cause MethodNotFoundError.
+        try {
+            return (VaadinServletResponse) _VaadinServletResponse_constructor
+                    .newInstance(response, service);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static WebBrowser createWebBrowser(VaadinRequest request) {
+        try {
+            return _WebBrowser_constructor.newInstance(request);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static VaadinSession createVaadinSession(VaadinService service,
+            VaadinRequest request) {
+        try {
+            return (VaadinSession) _VaadinService_createVaadinSession
+                    .invoke(service, request);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java
new file mode 100644
index 00000000..a1b238f1
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import com.vaadin.browserless.internal.MockVaadin;
+import com.vaadin.browserless.internal.UIFactory;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinSession;
+
+/**
+ * A {@link VaadinSession} that is replaced by a fresh one when it is closed.
+ * <p>
+ * Closing the session is how an application logs a user out: it then tells the
+ * browser to reload, and the servlet container hands the reloaded page a brand
+ * new session. There is no browser here, so {@link #close()} does that itself
+ * and the test can go on to assert that a login view is shown.
+ * <p>
+ * A subclass that overrides {@link #close()} has to keep both halves: call
+ * {@code super.close()}, then
+ * {@link MockVaadin#afterSessionClose(VaadinSession, UIFactory)}.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockVaadinSession extends VaadinSession {
+
+    private final UIFactory uiFactory;
+
+    /**
+     * Returns the factory producing the {@link com.vaadin.flow.component.UI} of
+     * the session that replaces this one once it is closed.
+     *
+     * @return the UI factory
+     */
+    public UIFactory getUiFactory() {
+        return uiFactory;
+    }
+
+    /**
+     * Creates a session for the given service.
+     *
+     * @param service
+     *            the service owning this session
+     * @param uiFactory
+     *            produces the UI of the replacement session; it must return a
+     *            fresh instance, not one already attached to a session
+     */
+    public MockVaadinSession(VaadinService service, UIFactory uiFactory) {
+        super(service);
+        this.uiFactory = uiFactory;
+    }
+
+    @Override
+    public void close() {
+        super.close();
+        MockVaadin.afterSessionClose(this, uiFactory);
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
new file mode 100644
index 00000000..5512aaae
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.concurrent.atomic.AtomicReference;
+
+import com.vaadin.browserless.internal.ComponentUtilsKt;
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.ModalityMode;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.router.Location;
+import com.vaadin.flow.router.NavigationTrigger;
+import com.vaadin.flow.router.QueryParameters;
+import com.vaadin.flow.shared.Registration;
+
+/**
+ * The {@link UI} the mocked environment creates by default.
+ * <p>
+ * It stands in for the browser in the two places the browser would normally
+ * act: it renders a navigation server-side, since there is no client router to
+ * hand the location to, and it flushes the state tree after a modality change,
+ * since there is no client response to trigger it.
+ * <p>
+ * The class is not final, so a test that needs a different UI can pass a
+ * factory producing a subclass, but the shape of what it overrides is not part
+ * of the published API.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class MockedUI extends UI {
+
+    /** {@link Location} keeps its own copies of these package private. */
+    private static final String QUERY_SEPARATOR = "?";
+
+    private static final String FRAGMENT_SEPARATOR = "#";
+
+    @Override
+    public void setChildComponentModal(Component childComponent,
+            ModalityMode mode) {
+        super.setChildComponentModal(childComponent, mode);
+        if (mode != ModalityMode.MODELESS) {
+            AtomicReference<Registration> registrationCombination = new AtomicReference<>();
+            if (childComponent != null) {
+                registrationCombination
+                        .set(childComponent.addDetachListener(event -> {
+                            roundTrip();
+                            Registration r = registrationCombination
+                                    .getAndSet(null);
+                            if (r != null) {
+                                r.remove();
+                            }
+                        }));
+            }
+        }
+        roundTrip();
+    }
+
+    @Override
+    public void addToModalComponent(Component component) {
+        super.addToModalComponent(component);
+        if (component != null) {
+            ComponentUtilsKt.simulateClosedEvent(component);
+        }
+    }
+
+    /**
+     * Renders the route server side, as a test has no client router to hand the
+     * navigation to.
+     * <p>
+     * This replaces {@link UI#navigate(String, QueryParameters)} rather than
+     * extending it — {@code super} is never called — so nothing the real
+     * {@code navigate} does with a location reaches a browserless test. How a
+     * location string becomes a {@link Location}, and how a fragment-only
+     * location is treated, therefore has to be mirrored here to be observable
+     * in a test.
+     *
+     * @param locationString
+     *            the location to navigate to
+     * @param queryParameters
+     *            query parameters given separately from the location
+     * @throws IllegalArgumentException
+     *             if query parameters are given separately and the location
+     *             carries a query string or a fragment of its own
+     */
+    @Override
+    public void navigate(String locationString,
+            QueryParameters queryParameters) {
+        Location location = toLocation(locationString, queryParameters);
+
+        // A location that consists only of a fragment does not identify a
+        // route: a running application leaves it to the client router rather
+        // than resolving the "" route and replacing the current view. A test
+        // has no client router, so there is simply nothing to render.
+        if (location.getPath().isEmpty()
+                && location.getQueryParameters().getParameters().isEmpty()
+                && locationString.contains(FRAGMENT_SEPARATOR)) {
+            return;
+        }
+
+        try {
+            Method renderViewForRoute = UI.class.getDeclaredMethod(
+                    "renderViewForRoute", Location.class,
+                    NavigationTrigger.class);
+            renderViewForRoute.setAccessible(true);
+            renderViewForRoute.invoke(this, location,
+                    NavigationTrigger.UI_NAVIGATE);
+        } catch (InvocationTargetException ex) {
+            // Reflection is an implementation detail of the mocked routing:
+            // report what the router threw, not an InvocationTargetException
+            // whose own message says nothing.
+            throw sneakyThrow(ex.getTargetException());
+        } catch (ReflectiveOperationException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    /**
+     * Builds the {@link Location} to render the way
+     * {@link UI#navigate(String, QueryParameters)} does in a running
+     * application.
+     * <p>
+     * Without separate query parameters the location string is the only source
+     * of them, so it is free to carry a query string and a fragment. Given
+     * both, its own query string or fragment would be lost, which is a mistake
+     * worth reporting rather than dropping silently.
+     * <p>
+     * This mirrors {@code UI.navigate(String, QueryParameters)} as of
+     * <a href="https://github.com/vaadin/flow/pull/25591">flow#25591</a>,
+     * backported to 25.3 in
+     * <a href="https://github.com/vaadin/flow/pull/25618">flow#25618</a>.
+     * Compare against that method rather than against a locally resolved
+     * snapshot, which may predate it.
+     */
+    private Location toLocation(String locationString,
+            QueryParameters queryParameters) {
+        boolean separateParameters = !queryParameters.getParameters().isEmpty();
+        if (separateParameters && (locationString.contains(QUERY_SEPARATOR)
+                || locationString.contains(FRAGMENT_SEPARATOR))) {
+            throw new IllegalArgumentException("The location '" + locationString
+                    + "' must be a plain path when query parameters are given separately, "
+                    + "since its own query string or fragment would be lost. Pass the whole URL to "
+                    + "navigate(String) instead.");
+        }
+        return separateParameters
+                ? new Location(locationString, queryParameters)
+                : new Location(locationString);
+    }
+
+    private void roundTrip() {
+        getInternals().getStateTree().collectChanges(change -> {
+        });
+        getInternals().getStateTree().runExecutionsBeforeClientResponse();
+    }
+
+    /**
+     * Rethrows the given throwable as-is, the way Kotlin and the router itself
+     * do, without wrapping a checked exception the caller is not expecting.
+     */
+    @SuppressWarnings("unchecked")
+    private static <T extends Throwable> RuntimeException sneakyThrow(
+            Throwable throwable) throws T {
+        throw (T) throwable;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java b/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java
new file mode 100644
index 00000000..9b5c7f34
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.http.HttpSession;
+
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * A live map of all attributes in this session. Modifications to the map will
+ * be reflected to the session and vice versa.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class SessionAttributeMap extends AbstractMap<String, Object> {
+
+    private final HttpSession session;
+    private final Set<Entry<String, Object>> entries;
+
+    public SessionAttributeMap(HttpSession session) {
+        this.session = session;
+        this.entries = new SessionAttributeEntrySet(session);
+    }
+
+    @Override
+    public Set<Entry<String, Object>> entrySet() {
+        return entries;
+    }
+
+    @Override
+    public Object get(Object key) {
+        if (!(key instanceof String)) {
+            return null;
+        }
+        return session.getAttribute((String) key);
+    }
+
+    @Override
+    public Object put(String key, Object value) {
+        Object old = session.getAttribute(key);
+        session.setAttribute(key, value);
+        return old;
+    }
+
+    @Override
+    public Object remove(Object key) {
+        if (!(key instanceof String)) {
+            return null;
+        }
+        Object old = session.getAttribute((String) key);
+        session.removeAttribute((String) key);
+        return old;
+    }
+
+    @Override
+    public boolean remove(Object key, Object value) {
+        Object current = get(key);
+        if (Objects.equals(current, value)) {
+            remove(key);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return !session.getAttributeNames().hasMoreElements();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        if (!(key instanceof String)) {
+            return false;
+        }
+        return session.getAttribute((String) key) != null;
+    }
+
+    private static class SessionAttributeEntrySet
+            extends AbstractSet<Entry<String, Object>> {
+        private final HttpSession session;
+
+        SessionAttributeEntrySet(HttpSession session) {
+            this.session = session;
+        }
+
+        @Override
+        public int size() {
+            int count = 0;
+            for (Iterator<String> it = listAttrNames(session).iterator(); it
+                    .hasNext();) {
+                it.next();
+                count++;
+            }
+            return count;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return !session.getAttributeNames().hasMoreElements();
+        }
+
+        @Override
+        public boolean add(Entry<String, Object> element) {
+            boolean modified = !Objects.equals(
+                    session.getAttribute(element.getKey()), element.getValue());
+            if (modified) {
+                session.setAttribute(element.getKey(), element.getValue());
+            }
+            return modified;
+        }
+
+        @Override
+        public Iterator<Entry<String, Object>> iterator() {
+            return new SessionAttributeEntrySetIterator(session);
+        }
+
+        @Override
+        public boolean remove(Object element) {
+            if (!(element instanceof Entry)) {
+                return false;
+            }
+            Entry<?, ?> e = (Entry<?, ?>) element;
+            if (contains(e)) {
+                session.removeAttribute((String) e.getKey());
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        public boolean contains(Object element) {
+            if (!(element instanceof Entry)) {
+                return false;
+            }
+            Entry<?, ?> e = (Entry<?, ?>) element;
+            return Objects.equals(session.getAttribute((String) e.getKey()),
+                    e.getValue());
+        }
+    }
+
+    private static class SessionAttributeEntrySetIterator
+            implements Iterator<Entry<String, Object>> {
+        private final HttpSession session;
+        /**
+         * Copy the attribute names, otherwise {@link #remove()} would throw
+         * {@link java.util.ConcurrentModificationException}.
+         */
+        private final Iterator<String> attrNames;
+        private String lastAttributeName;
+
+        SessionAttributeEntrySetIterator(HttpSession session) {
+            this.session = session;
+            this.attrNames = listAttrNames(session).iterator();
+        }
+
+        @Override
+        public boolean hasNext() {
+            return attrNames.hasNext();
+        }
+
+        @Override
+        public Entry<String, Object> next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            lastAttributeName = attrNames.next();
+            return new SimpleEntry<>(lastAttributeName,
+                    session.getAttribute(lastAttributeName));
+        }
+
+        @Override
+        public void remove() {
+            if (lastAttributeName == null) {
+                throw new IllegalStateException();
+            }
+            session.removeAttribute(lastAttributeName);
+            lastAttributeName = null;
+        }
+    }
+
+    private static List<String> listAttrNames(HttpSession session) {
+        return new ArrayList<>(Collections.list(session.getAttributeNames()));
+    }
+}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
index 89fb0774..e7c5f02c 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
@@ -58,11 +58,6 @@ import com.vaadin.browserless.mocks.MockServletConfig
 import com.vaadin.browserless.mocks.MockVaadinHelper
 import com.vaadin.browserless.mocks.MockVaadinServlet
 import com.vaadin.browserless.mocks.MockedUI
-import com.vaadin.browserless.mocks.WebBrowser
-import com.vaadin.browserless.mocks._createVaadinSession
-import com.vaadin.browserless.mocks.createVaadinServletRequest
-import com.vaadin.browserless.mocks.createVaadinServletResponse
-import com.vaadin.browserless.mocks.serviceSafe
 
 /**
  * Holds the objects created during session initialization, before they are
@@ -217,7 +212,7 @@ object MockVaadin {
                             "uninitialized servlet instance, or move the configuration to the setup " +
                             "that initializes it. Discarded configuration: $configuration")
         }
-        val service: VaadinServletService = checkNotNull(servlet.serviceSafe)
+        val service: VaadinServletService = checkNotNull(MockVaadinServlet.serviceSafe(servlet))
         check(service.router != null) { "$servlet failed to call VaadinServletService.init() in createServletService()" }
         return service
     }
@@ -364,21 +359,21 @@ object MockVaadin {
         mockRequest.headers["User-Agent"] = listOf(userAgent)
         service.context.getAttribute(Lookup::class.java)
                 .lookup(MockRequestCustomizer::class.java)?.apply(mockRequest)
-        val request = createVaadinServletRequest(mockRequest, service)
+        val request = MockVaadinServlet.createVaadinServletRequest(mockRequest, service)
 
         // init Session.
-        val session: VaadinSession = service._createVaadinSession(request)
+        val session: VaadinSession = MockVaadinServlet.createVaadinSession(service, request)
         httpSession.setAttribute(service.serviceName + ".lock", ReentrantLock().apply { lock() })
         httpSession.setAttribute(VaadinSession::class.java.name + "." + service.serviceName, session)
         session.refreshTransients(WrappedHttpSession(httpSession), service)
         check(session.lockInstance != null) { "$session created from $service has null lock. See the MockSession class on how to mock locks properly" }
         check((session.lockInstance as ReentrantLock).isLocked) { "$session created from $service: lock must be locked!" }
 
-        session.browser = WebBrowser(request)
+        session.browser = MockVaadinServlet.createWebBrowser(request)
         checkNotNull(session.browser.browserApplication) { "The WebBrowser has not been mocked properly" }
 
         // init Vaadin Response
-        val response = createVaadinServletResponse(MockResponse(), service)
+        val response = MockVaadinServlet.createVaadinServletResponse(MockResponse(), service)
 
         return SessionObjects(session, request, response, httpSession)
     }
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockContext.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockContext.kt
deleted file mode 100644
index a100ee90..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockContext.kt
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import java.io.File
-import java.io.InputStream
-import java.io.Serializable
-import java.net.URL
-import java.net.URLConnection
-import java.nio.file.Paths
-import java.util.Collections
-import java.util.Enumeration
-import java.util.EventListener
-import java.util.concurrent.ConcurrentHashMap
-import jakarta.servlet.Filter
-import jakarta.servlet.FilterRegistration
-import jakarta.servlet.RequestDispatcher
-import jakarta.servlet.Servlet
-import jakarta.servlet.ServletContext
-import jakarta.servlet.ServletRegistration
-import jakarta.servlet.SessionCookieConfig
-import jakarta.servlet.SessionTrackingMode
-import jakarta.servlet.descriptor.JspConfigDescriptor
-import org.slf4j.LoggerFactory
-
-open class MockContext : ServletContext, Serializable {
-
-    override fun <T : Servlet?> createServlet(clazz: Class<T>?): T {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getEffectiveMajorVersion(): Int = 3
-
-    override fun getResource(path: String): URL? {
-        // for example @HtmlImport("frontend://reviews-list.html") will expect the resource to be present in the war file,
-        // which is typically located in $CWD/src/main/webapp/frontend, so let's search for that first
-        val realPath = getRealPath(path)
-        if (realPath != null) {
-            return File(realPath).toURI().toURL()
-        }
-
-        // nope, fall back to class loading.
-        //
-        // for example @HtmlImport("frontend://bower_components/vaadin-button/src/vaadin-button.html") will try to look up
-        // the following resources:
-        //
-        // 1. /frontend/bower_components/vaadin-button/src/vaadin-button.html
-        // 2. /webjars/vaadin-button/src/vaadin-button.html
-        //
-        // we need to match the latter one to a resource on classpath
-
-        if (path.startsWith("/")) {
-            val resource: URL? = Thread.currentThread().contextClassLoader.getResource("META-INF/resources$path")
-            if (resource != null) {
-                return resource
-            }
-        }
-
-        if (path.startsWith("/VAADIN/")) {
-            // Vaadin 8 exposed directory
-            @Suppress("NAME_SHADOWING")
-            var path = path
-            if (path.contains("..")) {
-                // to be able to resolve ThemeResource("../othertheme/img/foo.png") which work from the browser.
-                path = Paths.get(path).normalize().toString()
-                // convert Windows path separators to Linux ones, so that the follow-up code works
-                path = path.replace('\\', '/')
-            }
-            // reject to serve "/VAADIN/../" resources
-            if (path.startsWith("/VAADIN/")) {
-                val resource: URL? = Thread.currentThread().contextClassLoader.getResource(path.trimStart('/'))
-                if (resource != null) {
-                    return resource
-                }
-            }
-        }
-        return null
-    }
-
-    override fun addListener(className: String) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun <T : EventListener?> addListener(t: T) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addListener(listenerClass: Class<out EventListener>) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getClassLoader(): ClassLoader = Thread.currentThread().contextClassLoader
-
-    override fun getAttributeNames(): Enumeration<String> = attributes.keys()
-
-    override fun getMajorVersion(): Int = 3
-
-    override fun log(msg: String) {
-        log.error(msg)
-    }
-
-    override fun log(message: String, throwable: Throwable) {
-        log.error(message, throwable)
-    }
-
-    override fun getFilterRegistration(filterName: String?): FilterRegistration {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun setSessionTrackingModes(sessionTrackingModes: MutableSet<SessionTrackingMode>) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun setInitParameter(name: String, value: String): Boolean = initParameters.putIfAbsent(name, value) == null
-
-    override fun getResourceAsStream(path: String): InputStream? = getResource(path)?.openStream()
-
-    override fun getNamedDispatcher(name: String?): RequestDispatcher {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getFilterRegistrations(): MutableMap<String, out FilterRegistration> {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getDefaultSessionTrackingModes(): Set<SessionTrackingMode> = setOf(SessionTrackingMode.COOKIE, SessionTrackingMode.URL)
-
-    override fun getMimeType(file: String): String = URLConnection.guessContentTypeFromName(file) ?: "application/octet-stream"
-
-    override fun declareRoles(vararg roleNames: String) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun <T : Filter?> createFilter(clazz: Class<T>): T {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    /**
-     * [getRealPath] will only resolve `path` in these folders.
-     */
-    var realPathRoots: List<String> = listOf("src/main/webapp/frontend", "src/main/webapp")
-
-    override fun getRealPath(path: String): String? {
-        for (realPathRoot in realPathRoots) {
-            val realPath: File = File(moduleDir, "$realPathRoot/$path").canonicalFile.absoluteFile
-            if (realPath.absolutePath.startsWith(File(realPathRoot).absolutePath) && realPath.exists()) {
-                return realPath.absolutePath
-            }
-        }
-        return null
-    }
-
-    val initParameters: MutableMap<String, String> = mutableMapOf()
-
-    override fun getInitParameter(name: String): String? = initParameters[name]
-
-    override fun getMinorVersion(): Int = 0
-
-    override fun getJspConfigDescriptor(): JspConfigDescriptor {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun removeAttribute(name: String) {
-        attributes.remove(name)
-    }
-
-    override fun getServletContextName(): String {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addFilter(filterName: String?, className: String?): FilterRegistration.Dynamic {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addFilter(filterName: String?, filter: Filter?): FilterRegistration.Dynamic {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addFilter(filterName: String?, filterClass: Class<out Filter>?): FilterRegistration.Dynamic {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getContextPath(): String = ""
-
-    override fun getSessionCookieConfig(): SessionCookieConfig {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getVirtualServerName(): String = "mock/localhost" // Tomcat returns "Catalina/localhost"
-
-    private var sessionTimeout: Int = 30
-
-    override fun getSessionTimeout(): Int = sessionTimeout
-
-    override fun setSessionTimeout(sessionTimeout: Int) {
-        this.sessionTimeout = sessionTimeout
-    }
-
-    private var requestCharacterEncoding: String? = null
-
-    override fun getRequestCharacterEncoding(): String? = requestCharacterEncoding
-
-    override fun setRequestCharacterEncoding(encoding: String?) {
-        requestCharacterEncoding = encoding
-    }
-
-    private var responseCharacterEncoding: String? = null
-
-    override fun getResponseCharacterEncoding(): String? = responseCharacterEncoding
-
-    override fun setResponseCharacterEncoding(encoding: String?) {
-        responseCharacterEncoding = encoding
-    }
-
-    override fun getContext(uripath: String): ServletContext {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getRequestDispatcher(path: String?): RequestDispatcher {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    private val attributes = ConcurrentHashMap<String, Any>()
-
-    override fun getAttribute(name: String): Any? = attributes[name]
-
-    override fun setAttribute(name: String, value: Any?) {
-        attributes.putOrRemove(name, value)
-    }
-
-    override fun getServletRegistration(servletName: String): ServletRegistration? = null
-
-    override fun <T : EventListener?> createListener(clazz: Class<T>?): T {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addServlet(servletName: String?, className: String?): ServletRegistration.Dynamic {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addServlet(servletName: String?, servlet: Servlet?): ServletRegistration.Dynamic {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addServlet(servletName: String?, servletClass: Class<out Servlet>?): ServletRegistration.Dynamic {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun addJspFile(servletName: String, jspFile: String): ServletRegistration.Dynamic {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getEffectiveMinorVersion(): Int = 0
-
-    override fun getServletRegistrations(): MutableMap<String, out ServletRegistration> = HashMap()
-
-    override fun getResourcePaths(path: String?): MutableSet<String> = mutableSetOf()
-
-    override fun getInitParameterNames(): Enumeration<String> = Collections.enumeration(initParameters.keys)
-
-    override fun getServerInfo(): String = "Mock"
-
-    override fun getEffectiveSessionTrackingModes(): Set<SessionTrackingMode> =
-        setOf(SessionTrackingMode.COOKIE, SessionTrackingMode.URL)
-
-    companion object {
-        @JvmStatic
-        private val log = LoggerFactory.getLogger(MockContext::class.java)
-    }
-}
-
-internal val moduleDir: File get() {
-    var dir = File("").absoluteFile
-    // Workaround for https://youtrack.jetbrains.com/issue/IDEA-188466
-    // When using $MODULE_DIR$, IDEA will set CWD to, say, ui-testing/.idea/modules/ui-testing-module
-    // We need to revert that back to ui-testing/ui-testing-module
-    if (dir.absolutePath.contains("/.idea/modules")) {
-        dir = File(dir.absolutePath.replace("/.idea/modules", ""))
-    }
-    return dir
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpEnvironment.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpEnvironment.kt
deleted file mode 100644
index 0b0de6ae..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpEnvironment.kt
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import java.util.Collections
-import java.util.Enumeration
-import jakarta.servlet.ServletConfig
-import jakarta.servlet.ServletContext
-
-
-open class MockServletConfig(val context: ServletContext) : ServletConfig {
-
-    /**
-     * Per-servlet init parameters.
-     */
-    var servletInitParams: MutableMap<String, String> = mutableMapOf()
-
-    override fun getInitParameter(name: String): String? = servletInitParams[name]
-
-    override fun getInitParameterNames(): Enumeration<String> = Collections.enumeration(servletInitParams.keys)
-
-    override fun getServletName(): String = "Vaadin Servlet"
-
-    override fun getServletContext(): ServletContext = context
-}
-
-internal fun <K, V> MutableMap<K, V>.putOrRemove(key: K, value: V?) {
-    if (value == null) remove(key) else set(key, value)
-}
-
-object MockHttpEnvironment {
-    /**
-     * [MockRequest.getLocalPort]
-     */
-    var localPort: Int = 8080
-
-    /**
-     * [MockRequest.getServerPort]
-     */
-    var serverPort: Int = 8080
-
-    /**
-     * [MockRequest.getRemotePort]
-     */
-    var remotePort: Int = 8080
-
-    /**
-     * [MockRequest.getAuthType]
-     */
-    var authType: String? = null
-
-    /**
-     * [MockRequest.isSecure]
-     */
-    var isSecure: Boolean = false
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpSession.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpSession.kt
deleted file mode 100644
index 03a06d14..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockHttpSession.kt
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-@file:Suppress("OverridingDeprecatedMember", "DEPRECATION")
-
-package com.vaadin.browserless.mocks
-
-import java.io.Serializable
-import java.util.Enumeration
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicInteger
-
-import jakarta.servlet.ServletContext
-import jakarta.servlet.http.HttpSession
-
-/**
- * A standalone implementation of the [HttpSession] interface.
- */
-open class MockHttpSession(
-        @Volatile private var sessionId: String,
-        private val servletContext: ServletContext,
-        private val creationTime: Long,
-        private var maxInactiveInterval: Int
-) : HttpSession, Serializable {
-    private val attributes = ConcurrentHashMap<String, Any>()
-    private val valid = AtomicBoolean(true)
-
-    val isValid: Boolean get() = valid.get()
-
-    constructor(session: HttpSession) : this(session.id, session.servletContext, session.lastAccessedTime, session.maxInactiveInterval) {
-        copyAttributes(session)
-    }
-
-    fun destroy() {
-        attributes.clear()
-    }
-
-    override fun getCreationTime(): Long {
-        checkValid()
-        return creationTime
-    }
-
-    override fun getId(): String = sessionId
-
-    override fun getLastAccessedTime(): Long {
-        checkValid()
-        return 0
-    }
-
-    override fun getServletContext(): ServletContext = servletContext
-
-    override fun setMaxInactiveInterval(interval: Int) {
-        this.maxInactiveInterval = interval
-    }
-
-    override fun getMaxInactiveInterval(): Int = maxInactiveInterval
-
-    override fun getAttribute(name: String): Any? {
-        checkValid()
-        return attributes[name]
-    }
-
-    override fun getAttributeNames(): Enumeration<String> {
-        checkValid()
-        return attributes.keys()
-    }
-
-    override fun setAttribute(name: String, value: Any?) {
-        checkValid()
-        attributes.putOrRemove(name, value)
-    }
-
-    override fun removeAttribute(name: String) {
-        checkValid()
-        attributes.remove(name)
-    }
-
-    fun copyAttributes(httpSession: HttpSession): MockHttpSession {
-        httpSession.attributeNames.toList().forEach {
-            attributes[it] = httpSession.getAttribute(it)
-        }
-        return this
-    }
-
-    override fun invalidate() {
-        checkValid()
-        valid.set(false)
-    }
-
-    override fun isNew(): Boolean {
-        checkValid()
-        return false
-    }
-
-    private fun checkValid() {
-        if (!isValid) {
-            throw IllegalStateException("invalidated: $this")
-        }
-    }
-
-    /**
-     * Assigns a new ID to this session, keeping its identity and all of its
-     * attributes intact, and returns the new ID.
-     *
-     * This mirrors what a servlet container does for
-     * [jakarta.servlet.http.HttpServletRequest.changeSessionId]: apps which
-     * implement session-fixation protection themselves (vanilla and Java EE
-     * apps, i.e. those not relying on Spring Security) call it after a
-     * successful login.
-     */
-    fun changeSessionId(): String {
-        checkValid()
-        sessionId = newSessionId()
-        return sessionId
-    }
-
-    override fun toString(): String =
-        "MockHttpSession(sessionId='$sessionId', creationTime=$creationTime, maxInactiveInterval=$maxInactiveInterval, attributes=$attributes, isValid=$isValid)"
-
-    companion object {
-        private val sessionIdGenerator = AtomicInteger()
-
-        private fun newSessionId(): String = sessionIdGenerator.incrementAndGet().toString()
-
-        fun create(ctx: ServletContext): MockHttpSession =
-            MockHttpSession(
-                newSessionId(),
-                ctx,
-                System.currentTimeMillis(),
-                30
-            )
-    }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockInstantiator.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockInstantiator.kt
deleted file mode 100644
index 8737471b..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockInstantiator.kt
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.vaadin.flow.component.HasElement
-import com.vaadin.flow.di.Instantiator
-import com.vaadin.flow.i18n.I18NProvider
-import com.vaadin.flow.router.NavigationEvent
-import com.vaadin.flow.router.PageTitleGenerator
-import com.vaadin.flow.server.DependencyFilter
-import com.vaadin.flow.server.auth.MenuAccessControl
-import com.vaadin.flow.server.communication.IndexHtmlRequestListener
-import java.util.stream.Stream
-
-/**
- * An [Instantiator] wrapping the one the mocked environment provides.
- *
- * The wrapper does not mock anything any more: the [getOrCreate] special cases
- * it was written for are long gone, so every member simply forwards to
- * [delegate]. The mocked services therefore use the environment's own
- * instantiator directly, and this class is kept for source compatibility only.
- *
- * The forwarding is spelled out by hand on purpose: Kotlin interface delegation
- * only generates forwarders for the abstract members of [Instantiator], so a
- * method Flow declares as a Java `default` would otherwise resolve to that
- * default implementation and never reach the delegate — which is how a Spring
- * `PageTitleGenerator` bean used to be dropped in browserless tests. Since a
- * wrapper can always fall behind a method added to [Instantiator] later,
- * [create] hands back the delegate itself instead of wrapping it.
- *
- * The list of forwarders below is deliberately not guarded by a test: pinning
- * it would fail the build whenever Flow adds a method to [Instantiator], which
- * is not worth it for a class scheduled for removal and used by nothing here.
- * A method missing from the list is therefore silently dropped for callers who
- * construct this class themselves — one more reason not to.
- */
-@Deprecated(
-    "Wrapping the instantiator of the mocked environment has no effect; use that instantiator directly. Scheduled for removal."
-)
-open class MockInstantiator(val delegate: Instantiator) : Instantiator by delegate {
-
-    override fun <T : Any?> getOrCreate(type: Class<T>): T = delegate.getOrCreate(type)
-
-    override fun getMenuAccessControl(): MenuAccessControl = delegate.menuAccessControl
-
-    override fun getI18NProvider(): I18NProvider? = delegate.i18NProvider
-
-    override fun getPageTitleGenerator(): PageTitleGenerator? = delegate.pageTitleGenerator
-
-    override fun getIndexHtmlRequestListeners(
-        indexHtmlRequestListeners: Stream<IndexHtmlRequestListener>
-    ): Stream<IndexHtmlRequestListener> =
-        delegate.getIndexHtmlRequestListeners(indexHtmlRequestListeners)
-
-    override fun getDependencyFilters(
-        serviceInitFilters: Stream<DependencyFilter>
-    ): Stream<DependencyFilter> = delegate.getDependencyFilters(serviceInitFilters)
-
-    override fun getApplicationClass(instance: Any): Class<*> =
-        delegate.getApplicationClass(instance)
-
-    override fun getApplicationClass(clazz: Class<*>): Class<*> =
-        delegate.getApplicationClass(clazz)
-
-    override fun <T : HasElement> createRouteTarget(
-        routeTargetType: Class<T>,
-        event: NavigationEvent
-    ): T = delegate.createRouteTarget(routeTargetType, event)
-
-    companion object {
-        /**
-         * Returns [delegate] as is: wrapping it changes nothing, and a wrapper
-         * risks dropping methods added to [Instantiator] in the future.
-         */
-        @JvmStatic
-        fun create(delegate: Instantiator): Instantiator = delegate
-    }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockRequest.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockRequest.kt
deleted file mode 100644
index 672ddd64..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockRequest.kt
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import jakarta.servlet.AsyncContext
-import jakarta.servlet.DispatcherType
-import jakarta.servlet.RequestDispatcher
-import jakarta.servlet.ServletConnection
-import jakarta.servlet.ServletContext
-import jakarta.servlet.ServletInputStream
-import jakarta.servlet.ServletRequest
-import jakarta.servlet.ServletResponse
-import jakarta.servlet.http.Cookie
-import jakarta.servlet.http.HttpServletRequest
-import jakarta.servlet.http.HttpServletResponse
-import jakarta.servlet.http.HttpSession
-import jakarta.servlet.http.HttpUpgradeHandler
-import jakarta.servlet.http.Part
-import java.io.BufferedReader
-import java.security.Principal
-import java.util.Collections
-import java.util.Enumeration
-import java.util.Locale
-import java.util.concurrent.ConcurrentHashMap
-
-open class MockRequest(private var session: HttpSession) : HttpServletRequest {
-
-    /**
-     * The ID of the session the client asked for. Just like in a servlet
-     * container it stays the same for the lifetime of the request, even if the
-     * session ID is rotated via [changeSessionId] or a new session is created
-     * after invalidation.
-     */
-    private val initiallyRequestedSessionId: String = session.id
-
-    override fun getInputStream(): ServletInputStream {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun startAsync(): AsyncContext {
-        throw UnsupportedOperationException("Unsupported")
-    }
-
-    override fun startAsync(servletRequest: ServletRequest?, servletResponse: ServletResponse?): AsyncContext {
-        throw UnsupportedOperationException("Unsupported")
-    }
-
-    override fun getProtocol(): String = "HTTP/1.1"
-
-    override fun getRequestURL(): StringBuffer = StringBuffer("http://localhost:8080/")
-
-    var characterEncodingInt: String? = null
-
-    override fun setCharacterEncoding(env: String) {
-        characterEncodingInt = env
-    }
-
-    val parameters: MutableMap<String, Array<String>> = mutableMapOf()
-
-    override fun getParameterValues(name: String): Array<String>? = parameters[name]
-
-    override fun isAsyncStarted(): Boolean = false
-
-    override fun getContentLengthLong(): Long = -1
-
-    override fun login(username: String?, password: String?) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun isRequestedSessionIdValid(): Boolean {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    /**
-     * Returns [MockHttpEnvironment.serverPort].
-     */
-    override fun getServerPort(): Int = MockHttpEnvironment.serverPort
-
-    override fun getRequestedSessionId(): String = initiallyRequestedSessionId
-
-    override fun getServletPath(): String = ""
-
-    override fun getSession(create: Boolean): HttpSession? {
-        val isValid = (session as? MockHttpSession)?.isValid ?: true
-        if (!isValid) {
-            // Mirror the servlet container contract: once the session has been
-            // invalidated there is no current session, so getSession(false)
-            // must return null (and getSession(true) must create a fresh one).
-            // Returning the stale, invalidated session instead made code that
-            // legitimately touches it after logout (e.g. Spring Security's
-            // HttpSessionSecurityContextRepository.saveContext) throw
-            // IllegalStateException. See issue #115.
-            if (!create) {
-                return null
-            }
-            session = MockHttpSession.create(session.servletContext)
-        }
-        return session
-    }
-
-    override fun getSession(): HttpSession = getSession(true)!!
-
-    override fun getServerName(): String = "127.0.0.1"
-
-    override fun getLocalAddr(): String = "127.0.0.1"
-
-    override fun <T : HttpUpgradeHandler?> upgrade(handlerClass: Class<T>?): T {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun isRequestedSessionIdFromCookie(): Boolean = false
-
-    var partsInt: MutableList<Part>? = null
-
-    override fun getPart(name: String): Part? {
-        if (partsInt == null) throw IllegalStateException("Unable to process parts as no multi-part configuration has been provided")
-        return partsInt!!.firstOrNull { it.name == name }
-    }
-
-    override fun isRequestedSessionIdFromURL(): Boolean = false
-
-    /**
-     * Returns [MockHttpEnvironment.localPort].
-     */
-    override fun getLocalPort(): Int = MockHttpEnvironment.localPort
-
-    override fun getServletContext(): ServletContext = session.servletContext
-
-    override fun getQueryString(): String? = null
-
-    override fun getDispatcherType(): DispatcherType = DispatcherType.REQUEST
-    override fun getRequestId(): String {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getProtocolRequestId(): String {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getServletConnection(): ServletConnection {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getParts(): MutableCollection<Part> {
-        return partsInt
-                ?: throw IllegalStateException("Unable to process parts as no multi-part configuration has been provided")
-    }
-
-    override fun getScheme(): String = "http"
-
-    override fun logout() {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getLocalName(): String = "localhost"
-
-    override fun isAsyncSupported(): Boolean = false
-
-    override fun getParameterNames(): Enumeration<String> = Collections.enumeration(parameters.keys)
-
-    override fun authenticate(response: HttpServletResponse?): Boolean {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getPathTranslated(): String {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getIntHeader(name: String): Int = getHeader(name)?.toInt()
-            ?: -1
-
-    override fun changeSessionId(): String {
-        // Mirrors the servlet container contract: the session keeps its
-        // identity and its attributes (in particular the VaadinSession), only
-        // the ID changes, and there has to be a session to begin with. Apps
-        // which are not backed by Spring Security implement session-fixation
-        // protection by calling this after a successful login.
-        val current: HttpSession = getSession(false)
-                ?: throw IllegalStateException("no session is associated with this request")
-        if (current !is MockHttpSession) {
-            throw UnsupportedOperationException("changeSessionId() is only supported for MockHttpSession but got ${current.javaClass}")
-        }
-        return current.changeSessionId()
-    }
-
-    override fun getAsyncContext(): AsyncContext {
-        throw IllegalStateException("async not supported in mock environment")
-    }
-
-    override fun getRequestURI(): String = "/"
-
-    override fun getRequestDispatcher(path: String?): RequestDispatcher {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    var isUserInRole: (Principal, role: String) -> Boolean = { _, _ -> false }
-
-    /**
-     * Sets the user-in-role checker using a [java.util.function.BiPredicate].
-     * Java-friendly alternative to setting [isUserInRole] directly.
-     *
-     * @since 1.1
-     */
-    fun roleChecker(checker: java.util.function.BiPredicate<Principal, String>) {
-        isUserInRole = { principal, role -> checker.test(principal, role) }
-    }
-
-    /**
-     * Set [isUserInRole] to modify the outcome of this function.
-     */
-    override fun isUserInRole(role: String): Boolean {
-        val p = userPrincipal ?: return false
-        return isUserInRole(p, role)
-    }
-
-    override fun getPathInfo(): String? = null
-
-    override fun getRemoteUser(): String? = null
-
-    var cookiesInt: Array<Cookie>? = null
-
-    fun addCookie(cookie: Cookie) {
-        if (cookiesInt == null) {
-            cookiesInt = arrayOf()
-        }
-        cookiesInt = cookiesInt!! + cookie
-    }
-
-    override fun getCookies(): Array<Cookie>? = cookiesInt
-
-    var localeInt: Locale = Locale.US
-
-    override fun getLocale(): Locale = localeInt
-
-    override fun getMethod(): String = "GET"
-
-    override fun getParameterMap(): Map<String, Array<String>> = parameters
-
-    override fun getAttributeNames(): Enumeration<String> = attributes.keys()
-
-    override fun getRemoteAddr(): String = "127.0.0.1"
-
-    override fun getHeaders(name: String): Enumeration<String> {
-        val h = headers.get(name)
-        return if (h == null) Collections.emptyEnumeration() else Collections.enumeration(h)
-    }
-
-    var userPrincipalInt: Principal? = null
-
-    /**
-     * Optional provider for [getUserPrincipal]. When set, takes precedence over
-     * [userPrincipalInt], allowing the principal to be resolved lazily at
-     * call time (e.g. from a security context that is populated after setup).
-     * Set via [principalProvider].
-     *
-     * @since 1.1
-     */
-    var userPrincipalProvider: (() -> Principal?)? = null
-        private set
-
-    /**
-     * Sets the user principal provider. Accepts a [java.util.function.Supplier]
-     * so Java callers can pass a lambda directly; Kotlin callers can do the
-     * same via SAM conversion.
-     *
-     * @since 1.1
-     */
-    fun principalProvider(supplier: java.util.function.Supplier<Principal?>) {
-        userPrincipalProvider = { supplier.get() }
-    }
-
-    /**
-     * Returns the principal from [userPrincipalProvider] if set, otherwise
-     * falls back to [userPrincipalInt].
-     */
-    override fun getUserPrincipal(): Principal? = userPrincipalProvider?.invoke() ?: userPrincipalInt
-
-    override fun getReader(): BufferedReader {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun getLocales(): Enumeration<Locale> = Collections.enumeration(listOf(locale))
-
-    /**
-     * Returns [MockHttpEnvironment.authType]
-     */
-    override fun getAuthType(): String? = MockHttpEnvironment.authType
-
-    override fun getCharacterEncoding(): String? = null
-
-    override fun removeAttribute(name: String) {
-        attributes.remove(name)
-    }
-
-    override fun getContentLength(): Int = -1
-
-    val headers: ConcurrentHashMap<String, List<String>> = ConcurrentHashMap<String, List<String>>()
-
-    init {
-        headers["user-agent"] = listOf("IntelliJ IDEA/182.4892.20")
-    }
-
-    override fun getHeader(headerName: String): String? = headers[headerName]?.get(0)
-
-    override fun getContextPath(): String = ""
-
-    override fun getContentType(): String? = null
-
-    override fun getHeaderNames(): Enumeration<String> = headers.keys()
-
-    private val attributes = ConcurrentHashMap<String, Any>()
-
-    override fun getAttribute(name: String): Any? = attributes[name]
-
-    override fun setAttribute(name: String, value: Any?) {
-        attributes.putOrRemove(name, value)
-    }
-
-    override fun getParameter(parameter: String): String? = parameters[parameter]?.get(0)
-
-    /**
-     * Returns [MockHttpEnvironment.remotePort].
-     */
-    override fun getRemotePort(): Int = MockHttpEnvironment.remotePort
-
-    override fun getDateHeader(name: String?): Long = -1
-
-    override fun getRemoteHost(): String = "127.0.0.1"
-
-    /**
-     * Returns [MockHttpEnvironment.isSecure]
-     */
-    override fun isSecure(): Boolean = MockHttpEnvironment.isSecure
-
-    fun setParameter(name: String, vararg values: String) {
-        parameters[name] = arrayOf(*values)
-    }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockResponse.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockResponse.kt
deleted file mode 100644
index 2c7b11d0..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockResponse.kt
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import java.io.IOException
-import java.io.PrintWriter
-import java.util.Locale
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.CopyOnWriteArrayList
-import jakarta.servlet.ServletOutputStream
-import jakarta.servlet.http.Cookie
-import jakarta.servlet.http.HttpServletResponse
-
-open class MockResponse : HttpServletResponse {
-    override fun encodeURL(url: String): String = url
-
-    val headers: ConcurrentHashMap<String, Array<String>> = ConcurrentHashMap<String, Array<String>>()
-
-    override fun addIntHeader(name: String, value: Int) {
-        addHeader(name, value.toString())
-    }
-
-    val cookies: CopyOnWriteArrayList<Cookie> = CopyOnWriteArrayList<Cookie>()
-
-    override fun addCookie(cookie: Cookie) {
-        cookies.add(cookie)
-    }
-
-    fun getCookie(name: String): Cookie = checkNotNull(findCookie(name)) {
-        "no such cookie with name $name. Available cookies: ${cookies.joinToString { "${it.name}=${it.value}" }}"
-    }
-
-    fun findCookie(name: String): Cookie? = cookies.firstOrNull { it.name == name }
-
-    override fun flushBuffer() {
-        // not needed at the moment
-    }
-
-    override fun encodeRedirectURL(url: String): String = url
-
-    override fun sendRedirect(location: String) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun sendRedirect(location: String?, sc: Int, clearBuffer: Boolean) {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    var _bufferSize: Int = 4096
-
-    override fun setBufferSize(size: Int) {
-        _bufferSize = size
-    }
-
-    var _locale: Locale = Locale.US
-
-    override fun getLocale(): Locale = _locale
-
-    override fun sendError(sc: Int, msg: String?) {
-        throw IOException("The app requests a failure: $sc $msg")
-    }
-
-    override fun sendError(sc: Int) {
-        throw IOException("The app requests a failure: $sc")
-    }
-
-    override fun setContentLengthLong(len: Long) {
-        // not needed at the moment
-    }
-
-    var _characterEncoding: String = "ISO-8859-1"
-
-    override fun setCharacterEncoding(charset: String) {
-        _characterEncoding = charset
-    }
-
-    override fun addDateHeader(name: String, date: Long) {
-        addHeader(name, date.toString())
-    }
-
-    override fun setLocale(loc: Locale) {
-        _locale = loc
-    }
-
-    override fun getHeaders(name: String): Collection<String> = headers[name]?.toList()
-            ?: listOf()
-
-    override fun addHeader(name: String, value: String) {
-        headers.compute(name) { _, v -> (v ?: arrayOf()) + value }
-    }
-
-    override fun setContentLength(len: Int) {
-        // not needed at the moment
-    }
-
-    override fun getBufferSize(): Int = _bufferSize
-
-    override fun resetBuffer() {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun reset() {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun setDateHeader(name: String, date: Long) {
-        setHeader(name, date.toString())
-    }
-
-    var _status: Int = 200
-
-    override fun getStatus(): Int = _status
-
-    override fun getCharacterEncoding(): String = _characterEncoding
-
-    override fun isCommitted(): Boolean {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun setStatus(sc: Int) {
-        _status = sc
-    }
-
-    override fun getHeader(name: String): String? = headers[name]?.get(0)
-
-    var _contentType: String? = null
-
-    override fun getContentType(): String? = _contentType
-
-    override fun getWriter(): PrintWriter {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun containsHeader(name: String): Boolean = headers.containsKey(name)
-
-    override fun setIntHeader(name: String, value: Int) {
-        setHeader(name, value.toString())
-    }
-
-    override fun getHeaderNames(): Collection<String> = headers.keys.toSet()
-
-    override fun setHeader(name: String, value: String) {
-        headers[name] = arrayOf(value)
-    }
-
-    override fun getOutputStream(): ServletOutputStream {
-        throw UnsupportedOperationException("not implemented")
-    }
-
-    override fun setContentType(type: String?) {
-        _contentType = type
-    }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockService.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockService.kt
deleted file mode 100644
index dfc5f836..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockService.kt
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import java.io.Serializable
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.function.DeploymentConfiguration
-import com.vaadin.flow.server.VaadinRequest
-import com.vaadin.flow.server.VaadinServlet
-import com.vaadin.flow.server.VaadinServletService
-import com.vaadin.flow.server.VaadinSession
-
-import com.vaadin.browserless.internal.UIFactory
-
-/**
- * A mocking service that performs three very important tasks:
- * * Overrides [isAtmosphereAvailable] to tell Vaadin that we don't have Atmosphere (otherwise Vaadin will crash)
- * * Provides some dummy value as a root ID via [getMainDivId] (otherwise the mocked servlet env will crash).
- * * Provides a [MockVaadinSession].
- * The class is intentionally opened, to be extensible in user's library.
- *
- * To register your custom `MockService` instance, override [MockVaadinServlet.createServletService].
- */
-open class MockService(servlet: VaadinServlet,
-                              deploymentConfiguration: DeploymentConfiguration,
-                              val uiFactory: UIFactory = UIFactory { MockedUI() }
-) : VaadinServletService(servlet, deploymentConfiguration) {
-    // need to have this override. Setting `VaadinService.atmosphereAvailable` to false via
-    // reflection after the servlet has been initialized is too late, since Atmo is initialized
-    // in VaadinService.init().
-    override fun isAtmosphereAvailable(): Boolean = false
-    override fun getMainDivId(session: VaadinSession?, request: VaadinRequest?): String = "ROOT-1"
-    override fun createVaadinSession(request: VaadinRequest): VaadinSession = MockVaadinSession(this, uiFactory)
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinHelper.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinHelper.kt
deleted file mode 100644
index 84bef2ae..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinHelper.kt
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.vaadin.browserless.internal.findClass
-import com.vaadin.browserless.internal.findClassOrThrow
-import com.vaadin.flow.component.geolocation.BrowserlessGeolocationClientFactory
-import com.vaadin.flow.component.geolocation.GeolocationClientFactory
-import com.vaadin.flow.di.Lookup
-import com.vaadin.flow.di.LookupInitializer
-import com.vaadin.flow.server.VaadinContext
-import com.vaadin.flow.server.VaadinServlet
-import com.vaadin.flow.server.VaadinServletContext
-import com.vaadin.flow.server.startup.LookupServletContainerInitializer
-import jakarta.servlet.ServletContext
-import jakarta.servlet.annotation.HandlesTypes
-import tools.jackson.databind.ObjectMapper
-import tools.jackson.databind.node.ObjectNode
-import java.io.File
-import kotlin.reflect.KClass
-
-object MockVaadinHelper {
-
-    private val flowBuildInfo: ObjectNode? by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        getTokenFileFromClassloader()
-    }
-
-    @JvmStatic
-    fun mockFlowBuildInfo(servlet: VaadinServlet) {
-        // we need to skip the test at DeploymentConfigurationFactory.verifyMode otherwise
-        // testing a Vaadin 15 component module in npm mode without webpack.config.js nor flow-build-info.json would fail.
-        if (flowBuildInfo == null) {
-            // probably inside a Vaadin 15 component module. create a dummy token file so that
-            // DeploymentConfigurationFactory.verifyMode() is happy.
-            val tokenFile: File = File.createTempFile("flow-build-info", "json")
-            tokenFile.writeText("{}")
-            servlet.servletContext.setInitParameter("vaadin.frontend.token.file", tokenFile.absolutePath)
-        }
-
-        servlet.servletContext.setInitParameter("compatibilityMode", "false")
-    }
-
-    fun createMockContext(lookupServices: Set<Class<*>> = emptySet()): ServletContext {
-        val ctx = MockContext()
-        init(ctx, lookupServices)
-        return ctx
-    }
-
-    fun createMockVaadinContext(): VaadinContext =
-            VaadinServletContext(createMockContext())
-
-    fun getTokenFileFromClassloader(): ObjectNode? {
-
-        // Use DefaultApplicationConfigurationFactory.getTokenFileFromClassloader() to make sure to read
-        // the same flow-build-info.json that Vaadin reads.
-
-        val ctx: VaadinContext = MockVaadinHelper.createMockVaadinContext()
-        val acf = lookup(ctx, findClassOrThrow("com.vaadin.flow.server.startup.ApplicationConfigurationFactory"))
-        checkNotNull(acf) { "ApplicationConfigurationFactory is null" }
-        val dacfClass = findClassOrThrow("com.vaadin.flow.server.startup.DefaultApplicationConfigurationFactory")
-        if (dacfClass.isInstance(acf)) {
-            val m = dacfClass.getDeclaredMethod("getTokenFileFromClassloader", VaadinContext::class.java)
-            m.isAccessible = true
-            val json = m.invoke(acf, ctx) as String? ?: return null
-            return ObjectMapper().readTree(json) as ObjectNode
-        }
-        return null
-    }
-
-    /**
-     * Calls `Lookup.lookup(Class)`.
-     */
-    fun lookup(ctx: VaadinContext, clazz: Class<*>): Any? {
-        val lookup = verifyHasLookup(ctx)
-        return lookup.lookup(clazz)
-    }
-
-    /**
-     * Verifies that the ctx has an instance of `com.vaadin.flow.di.Lookup` set, and returns it.
-     * @return the instance of `com.vaadin.flow.di.Lookup`.
-     */
-    private fun verifyHasLookup(ctx: ServletContext): Lookup {
-        val lookup: Any? = ctx.getAttribute("com.vaadin.flow.di.Lookup")
-        checkNotNull(lookup) {
-            "The context doesn't contain the Vaadin 19 Lookup class. Available attributes: " + ctx.attributeNames.toList()
-        }
-        return lookup as Lookup
-    }
-    private fun verifyHasLookup(ctx: VaadinContext): Lookup =
-            verifyHasLookup((ctx as VaadinServletContext).context)
-
-    private fun init(ctx: ServletContext, lookupServices: Set<Class<*>> = emptySet()) {
-
-        val loaders = mutableSetOf(
-                *lookupServices.toTypedArray(),
-                LookupInitializer::class.java,
-                findClassOrThrow("com.vaadin.flow.di.LookupInitializer${'$'}ResourceProviderImpl")
-        )
-        fun tryLoad(className: String) {
-            // sometimes customers don't include entire vaadin-core and exclude stuff like fusion on purpose.
-            // load the class only if it exists.
-            findClass(className)?.let { clazz -> loaders.add(clazz) }
-        }
-
-        tryLoad("com.vaadin.flow.component.polymertemplate.rpc.PolymerPublishedEventRpcHandler")
-        tryLoad("com.vaadin.fusion.frontend.EndpointGeneratorTaskFactoryImpl")
-
-        val loaderInitializer = setupLookupInitializer(loaders)
-
-        loaderInitializer.onStartup(loaders, ctx)
-
-        // verify that the Lookup has been set
-        verifyHasLookup(ctx)
-    }
-
-    private fun setupLookupInitializer(services: MutableSet<Class<*>>) : LookupServletContainerInitializer{
-        val initializer = BrowserlessLookupInitializer()
-        initializer.updateServices(services)
-        return initializer
-    }
-
-    internal open class BrowserlessLookupInitializer() : LookupServletContainerInitializer() {
-
-        // Additional services wired through lookup that the testing environment can hook in,
-        // supplementing ones defined in LookupServletContainerInitializer HandlesTypes annotations.
-        //
-        // Use Object class as a value placeholder for a service without default implementation,
-        // but that can be hooked in by the test class in the services' set
-        // mapOf(Service::class to Object::class)
-        protected open val additionalServices: Map<KClass<*>, KClass<*>> = mapOf(
-                GeolocationClientFactory::class to BrowserlessGeolocationClientFactory::class
-        )
-
-        fun updateServices(services: MutableSet<Class<*>>) {
-            additionalServices
-                // skip if the caller already supplied an implementation of the service interface
-                .filterNot { entry -> services.any { entry.key.java.isAssignableFrom(it) } }
-                // ignore additional services without default implementation
-                .filter { it.value != Object::class }
-                .forEach { services.add(it.value.java) }
-        }
-
-        override fun getServiceTypes(): Collection<Class<*>?> {
-            val annotation = LookupServletContainerInitializer::class.java.getAnnotation(HandlesTypes::class.java)
-            checkNotNull(annotation) {
-                ("Cannot collect service types based on "
-                        + HandlesTypes::class.java.getSimpleName()
-                        + " annotation. The default 'getServiceTypes' method implementation can't be used.")
-            }
-            val allServices = annotation.value + additionalServices.keys
-            return setOf(*allServices.map { it.java }.toTypedArray())
-                .filter { clazz: Class<*>? -> clazz != LookupInitializer::class.java }
-                .toSet()
-
-        }
-    }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinServlet.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinServlet.kt
deleted file mode 100644
index 2b9ba1f7..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinServlet.kt
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import java.lang.reflect.Constructor
-import java.lang.reflect.Method
-import com.vaadin.flow.function.DeploymentConfiguration
-import com.vaadin.flow.server.*
-import com.vaadin.browserless.internal.Routes
-import com.vaadin.browserless.internal.UIFactory
-import jakarta.servlet.http.HttpServletRequest
-import jakarta.servlet.http.HttpServletResponse
-
-/**
- * Makes sure that [routes] are properly registered, and that [MockService]
- * is used instead of vanilla [VaadinServletService].
- *
- * To use a custom servlet instead of this one, just pass it to [MockVaadin.setup].
- */
-open class MockVaadinServlet @JvmOverloads constructor(
-        val routes: Routes = Routes(),
-        val uiFactory: UIFactory = UIFactory{ MockedUI() }
-) : VaadinServlet() {
-
-    override fun createDeploymentConfiguration(): DeploymentConfiguration {
-        MockVaadinHelper.mockFlowBuildInfo(this)
-        return super.createDeploymentConfiguration()
-    }
-
-    override fun createServletService(deploymentConfiguration: DeploymentConfiguration): VaadinServletService {
-        val service: VaadinServletService = MockService(this, deploymentConfiguration, uiFactory)
-        service.init()
-        routes.register(service.context as VaadinServletContext)
-        return service
-    }
-}
-
-private val _VaadinServlet_getService: Method =
-    VaadinServlet::class.java.getDeclaredMethod("getService")
-
-/**
- * Workaround for https://github.com/mvysny/karibu-testing/issues/66
- */
-internal val VaadinServlet.serviceSafe: VaadinServletService? get() {
-    // we need to use the reflection. The problem is that the signature
-    // of the method differs between Vaadin versions:
-    //
-    // Vaadin 14.6: getService() returns VaadinService
-    // Vaadin 20+: getService() returns VaadinServletService
-    //
-    // calling the method directly will cause MethodNotFoundError on Vaadin 20+
-    return _VaadinServlet_getService.invoke(this) as VaadinServletService?
-}
-
-/**
- * Workaround for https://github.com/mvysny/karibu-testing/issues/66
- */
-internal fun createVaadinServletRequest(request: HttpServletRequest, service: VaadinService): VaadinServletRequest {
-    // we need to use the reflection. The problem is that the signature
-    // of the constructor differs between Vaadin versions:
-    //
-    // Vaadin 14.6: VaadinServletRequest(HttpServletRequest, VaadinServletService)
-    // Vaadin 20+: VaadinServletRequest(HttpServletRequest, VaadinService)
-    //
-    // calling the constructor directly will cause MethodNotFoundError.
-    val constructor: Constructor<*> =
-        VaadinServletRequest::class.java.declaredConstructors.first { it.parameterCount == 2 }
-    return constructor.newInstance(request, service) as VaadinServletRequest
-}
-
-private val _VaadinServletResponse_constructor: Constructor<*> =
-    VaadinServletResponse::class.java.declaredConstructors.first { it.parameterCount == 2 }
-
-/**
- * Workaround for https://github.com/mvysny/karibu-testing/issues/66
- */
-internal fun createVaadinServletResponse(response: HttpServletResponse, service: VaadinService): VaadinServletResponse {
-    // we need to use the reflection. The problem is that the signature
-    // of the constructor differs between Vaadin versions:
-    //
-    // Vaadin 14.6: VaadinServletResponse(HttpServletResponse, VaadinServletService)
-    // Vaadin 20+: VaadinServletResponse(HttpServletResponse, VaadinService)
-    //
-    // calling the constructor directly will cause MethodNotFoundError.
-    return _VaadinServletResponse_constructor.newInstance(response, service) as VaadinServletResponse
-}
-
-private val _WebBrowser_constructor: Constructor<WebBrowser> =
-    WebBrowser::class.java.getDeclaredConstructor(VaadinRequest::class.java).apply {
-        isAccessible = true
-    }
-
-internal fun WebBrowser(request: VaadinRequest): WebBrowser =
-    _WebBrowser_constructor.newInstance(request)
-
-private val _VaadinService_createVaadinSession: Method =
-    VaadinService::class.java.getDeclaredMethod("createVaadinSession", VaadinRequest::class.java).apply {
-        isAccessible = true
-    }
-
-internal fun VaadinService._createVaadinSession(request: VaadinRequest): VaadinSession {
-    return _VaadinService_createVaadinSession.invoke(this, request) as VaadinSession
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinSession.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinSession.kt
deleted file mode 100644
index 3c30073f..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockVaadinSession.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.vaadin.flow.server.VaadinService
-import com.vaadin.flow.server.VaadinSession
-import com.vaadin.browserless.internal.MockVaadin
-import com.vaadin.browserless.internal.UIFactory
-
-/**
- * A Vaadin Session with one important difference:
- *
- * * Creates a new session when this one is closed. This is used to simulate a logout
- *   which closes the session - we need to have a new fresh session to be able to continue testing.
- *   In order to do that, simply override [close], call `super.close()` then call
- *   [MockVaadin.afterSessionClose].
- */
-open class MockVaadinSession(service: VaadinService,
-                             val uiFactory: UIFactory
-) : VaadinSession(service) {
-    override fun close() {
-        super.close()
-        MockVaadin.afterSessionClose(this, uiFactory)
-    }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockedUI.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockedUI.kt
deleted file mode 100644
index cc759cc8..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/MockedUI.kt
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.ComponentEventListener
-import com.vaadin.flow.component.ModalityMode
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.shared.Registration
-import java.util.concurrent.atomic.AtomicReference
-import com.vaadin.flow.router.NavigationTrigger
-import com.vaadin.flow.router.QueryParameters
-import com.vaadin.flow.router.Location
-import com.vaadin.browserless.internal.simulateClosedEvent
-import java.lang.reflect.InvocationTargetException
-
-
-/**
- * A simple no-op UI used by default by [com.vaadin.browserless.MockVaadin.setup].
- * The class is open, in order to be extensible in user's library
- */
-open class MockedUI : UI() {
-
-    override fun setChildComponentModal(childComponent: Component?, mode: ModalityMode) {
-        super.setChildComponentModal(childComponent, mode)
-        if (mode != ModalityMode.MODELESS) {
-            val registrationCombination: AtomicReference<Registration?> = AtomicReference<Registration?>()
-            registrationCombination.set(childComponent?.addDetachListener(ComponentEventListener {
-                roundTrip()
-                registrationCombination.getAndSet(null)?.remove()
-            }))
-        }
-        roundTrip();
-    }
-
-    override fun addToModalComponent(component: Component?) {
-        super.addToModalComponent(component)
-        component?.simulateClosedEvent()
-    }
-
-    /**
-     * Renders the route server side, as a test has no client router to hand
-     * the navigation to.
-     *
-     * This replaces [UI.navigate] rather than extending it — `super` is never
-     * called — so nothing the real [UI.navigate] does with a location reaches a
-     * browserless test. How a location string becomes a [Location], and how a
-     * fragment-only location is treated, therefore has to be mirrored here to
-     * be observable in a test.
-     */
-    override fun navigate(locationString: String, queryParameters: QueryParameters) {
-        val location = toLocation(locationString, queryParameters)
-
-        // A location that consists only of a fragment does not identify a
-        // route: a running application leaves it to the client router rather
-        // than resolving the "" route and replacing the current view. A test
-        // has no client router, so there is simply nothing to render.
-        if (location.path.isEmpty() && location.queryParameters.parameters.isEmpty() &&
-                locationString.contains(FRAGMENT_SEPARATOR)) {
-            return
-        }
-
-        try {
-            UI::class.java.getDeclaredMethod("renderViewForRoute", Location::class.java, NavigationTrigger::class.java)
-                    .apply { isAccessible = true }
-                    .invoke(this, location, NavigationTrigger.UI_NAVIGATE)
-        } catch (ex: InvocationTargetException) {
-            // Reflection is an implementation detail of the mocked routing:
-            // report what the router threw, not an InvocationTargetException
-            // whose own message says nothing.
-            throw ex.targetException
-        }
-        return
-    }
-
-    /**
-     * Builds the [Location] to render the way [UI.navigate] does in a running
-     * application.
-     *
-     * Without separate query parameters the location string is the only source
-     * of them, so it is free to carry a query string and a fragment. Given
-     * both, its own query string or fragment would be lost, which is a mistake
-     * worth reporting rather than dropping silently.
-     *
-     * This mirrors `UI.navigate(String, QueryParameters)` as of
-     * https://github.com/vaadin/flow/pull/25591, backported to 25.3 in
-     * https://github.com/vaadin/flow/pull/25618. Compare against that method
-     * rather than against a locally resolved snapshot, which may predate it.
-     */
-    private fun toLocation(locationString: String, queryParameters: QueryParameters): Location {
-        val separateParameters = queryParameters.parameters.isNotEmpty()
-        require(!separateParameters ||
-                (!locationString.contains(QUERY_SEPARATOR) && !locationString.contains(FRAGMENT_SEPARATOR))) {
-            "The location '$locationString' must be a plain path when query parameters are given separately, " +
-                    "since its own query string or fragment would be lost. Pass the whole URL to " +
-                    "navigate(String) instead."
-        }
-        return if (separateParameters) Location(locationString, queryParameters) else Location(locationString)
-    }
-
-    private fun roundTrip() {
-        internals.stateTree.collectChanges { }
-        internals.stateTree.runExecutionsBeforeClientResponse()
-    }
-
-    private companion object {
-        /** [Location] keeps its own copies of these package private. */
-        private const val QUERY_SEPARATOR = "?"
-        private const val FRAGMENT_SEPARATOR = "#"
-    }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/mocks/SessionAttributeMap.kt b/shared/src/main/kotlin/com/vaadin/browserless/mocks/SessionAttributeMap.kt
deleted file mode 100644
index df152d31..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/mocks/SessionAttributeMap.kt
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import java.util.AbstractMap
-import jakarta.servlet.http.HttpSession
-
-/**
- * A live map of all attributes in this session. Modifications to the map will be
- * reflected to the session and vice versa.
- */
-val HttpSession.attributes: MutableMap<String, Any>
-    get() = SessionAttributeMap(this)
-
-private class SessionAttributeEntrySetIterator(val session: HttpSession) : MutableIterator<MutableMap.MutableEntry<String, Any>> {
-    /**
-     * Copy the attribute names, otherwise [remove] would throw [ConcurrentModificationException].
-     */
-    private val attrNames: Iterator<String> = session.attributeNames.toList().iterator()
-    private var lastAttributeName: String? = null
-
-    override fun hasNext(): Boolean = attrNames.hasNext()
-
-    override fun next(): MutableMap.MutableEntry<String, Any> {
-        if (!hasNext()) {
-            throw NoSuchElementException()
-        }
-        lastAttributeName = attrNames.next()
-        return AbstractMap.SimpleEntry<String, Any>(lastAttributeName!!, session.getAttribute(lastAttributeName!!))
-    }
-
-    override fun remove() {
-        check(lastAttributeName != null)
-        session.removeAttribute(lastAttributeName!!)
-        lastAttributeName = null
-    }
-}
-
-private class SessionAttributeEntrySet(val session: HttpSession) : AbstractMutableSet<MutableMap.MutableEntry<String, Any>>() {
-    override val size: Int
-        get() = session.attributeNames.asSequence().count()
-
-    override fun isEmpty(): Boolean = !session.attributeNames.hasMoreElements()
-
-    override fun add(element: MutableMap.MutableEntry<String, Any>): Boolean {
-        val modified: Boolean = session.getAttribute(element.key) != element.value
-        if (modified) {
-            session.setAttribute(element.key, element.value)
-        }
-        return modified
-    }
-
-    override fun iterator(): MutableIterator<MutableMap.MutableEntry<String, Any>> =
-            SessionAttributeEntrySetIterator(session)
-
-    override fun remove(element: MutableMap.MutableEntry<String, Any>): Boolean {
-        val contains: Boolean = contains(element)
-        if (contains) {
-            session.removeAttribute(element.key)
-        }
-        return contains
-    }
-
-    override fun contains(element: MutableMap.MutableEntry<String, Any>): Boolean =
-            session.getAttribute(element.key) == element.value
-}
-
-private class SessionAttributeMap(val session: HttpSession) : AbstractMutableMap<String, Any>() {
-    override val entries: MutableSet<MutableMap.MutableEntry<String, Any>> =
-            SessionAttributeEntrySet(session)
-
-    override fun get(key: String): Any? = session.getAttribute(key)
-
-    override fun put(key: String, value: Any): Any? {
-        val old: Any? = session.getAttribute(key)
-        session.setAttribute(key, value)
-        return old
-    }
-
-    override fun remove(key: String): Any? {
-        val old: Any? = session.getAttribute(key)
-        session.removeAttribute(key)
-        return old
-    }
-
-    override fun remove(key: String, value: Any): Boolean = if (get(key) == value) {
-        remove(key)
-        true
-    } else {
-        false
-    }
-
-    override fun isEmpty(): Boolean = entries.isEmpty()
-
-    override fun containsKey(key: String): Boolean = session.getAttribute(key) != null
-}
diff --git a/shared/src/test/java/com/vaadin/browserless/BuilderVaadinConfigurationTest.java b/shared/src/test/java/com/vaadin/browserless/BuilderVaadinConfigurationTest.java
index 060c5838..1dbfe260 100644
--- a/shared/src/test/java/com/vaadin/browserless/BuilderVaadinConfigurationTest.java
+++ b/shared/src/test/java/com/vaadin/browserless/BuilderVaadinConfigurationTest.java
@@ -28,6 +28,7 @@
 import com.vaadin.experimental.Feature;
 import com.vaadin.experimental.FeatureFlags;
 import com.vaadin.flow.function.DeploymentConfiguration;
+import com.vaadin.flow.server.ServiceException;
 import com.vaadin.flow.server.VaadinServlet;
 import com.vaadin.flow.server.VaadinServletContext;
 import com.vaadin.flow.server.VaadinServletService;
@@ -82,7 +83,8 @@ void featureFlags_areVisibleWhileTheServiceIsInitialized() {
                         uiFactory) -> new MockVaadinServlet(routes, uiFactory) {
                             @Override
                             protected VaadinServletService createServletService(
-                                    DeploymentConfiguration deploymentConfiguration) {
+                                    DeploymentConfiguration deploymentConfiguration)
+                                    throws ServiceException {
                                 enabledDuringServiceInit.set(FeatureFlags
                                         .get(new VaadinServletContext(
                                                 getServletContext()))
diff --git a/shared/src/test/java/com/vaadin/browserless/mocks/MockInstantiatorTest.java b/shared/src/test/java/com/vaadin/browserless/mocks/MockInstantiatorTest.java
index 7cf7bc36..678dfec2 100644
--- a/shared/src/test/java/com/vaadin/browserless/mocks/MockInstantiatorTest.java
+++ b/shared/src/test/java/com/vaadin/browserless/mocks/MockInstantiatorTest.java
@@ -22,7 +22,7 @@
 
 import com.vaadin.flow.di.Instantiator;
 
-@SuppressWarnings("deprecation")
+@SuppressWarnings({ "deprecation", "removal" })
 class MockInstantiatorTest {
 
     @Test
diff --git a/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt b/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt
index ece89657..6cb6200f 100644
--- a/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt
+++ b/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt
@@ -18,14 +18,13 @@ package com.vaadin.browserless.mocks
 import com.github.mvysny.dynatest.DynaTest
 import com.vaadin.flow.di.InstantiatorFactory
 import com.vaadin.flow.di.LookupInitializer
-import kotlin.reflect.KClass
 import kotlin.test.expect
 
 class BrowserlessLookupInitializerTest : DynaTest({
 
     test("updateServices adds default impl when interface is absent") {
         val initializer = TestInitializer(
-                mapOf(FakeService::class to FakeServiceImpl::class))
+                mapOf(FakeService::class.java to FakeServiceImpl::class.java))
         val services = mutableSetOf<Class<*>>()
 
         initializer.updateServices(services)
@@ -35,7 +34,7 @@ class BrowserlessLookupInitializerTest : DynaTest({
 
     test("updateServices skips entry when caller already supplied an implementation") {
         val initializer = TestInitializer(
-                mapOf(FakeService::class to FakeServiceImpl::class))
+                mapOf(FakeService::class.java to FakeServiceImpl::class.java))
         val services = mutableSetOf<Class<*>>(OtherFakeServiceImpl::class.java)
 
         initializer.updateServices(services)
@@ -46,7 +45,7 @@ class BrowserlessLookupInitializerTest : DynaTest({
 
     test("updateServices skips entries whose default is the Object placeholder") {
         val initializer = TestInitializer(
-                mapOf(NoDefaultService::class to Object::class))
+                mapOf(NoDefaultService::class.java to Object::class.java))
         val services = mutableSetOf<Class<*>>()
 
         initializer.updateServices(services)
@@ -56,7 +55,7 @@ class BrowserlessLookupInitializerTest : DynaTest({
 
     test("getServiceTypes extends parent service types with additionalServices keys") {
         val initializer = TestInitializer(
-                mapOf(FakeService::class to FakeServiceImpl::class))
+                mapOf(FakeService::class.java to FakeServiceImpl::class.java))
 
         val types = initializer.serviceTypes
 
@@ -66,7 +65,7 @@ class BrowserlessLookupInitializerTest : DynaTest({
 
     test("getServiceTypes excludes LookupInitializer even when added as an additional service") {
         val initializer = TestInitializer(
-                mapOf(LookupInitializer::class to FakeServiceImpl::class))
+                mapOf(LookupInitializer::class.java to FakeServiceImpl::class.java))
 
         val types = initializer.serviceTypes
 
@@ -80,7 +79,10 @@ private class OtherFakeServiceImpl : FakeService
 private interface NoDefaultService
 
 private class TestInitializer(
-        override val additionalServices: Map<KClass<*>, KClass<*>>
+        services: Map<Class<*>, Class<*>>
 ) : MockVaadinHelper.BrowserlessLookupInitializer() {
+    init {
+        this.additionalServices = services
+    }
     public override fun getServiceTypes(): Collection<Class<*>?> = super.getServiceTypes()
 }

From 3952ecd5e3b9d4a75f5252be37835154e294a3f9 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 08:40:24 +0000
Subject: [PATCH 03/13] refactor!: port the internal utilities from Kotlin to
 Java
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The eight Kotlin utility files under
`shared/src/main/kotlin/com/vaadin/browserless/internal` become nine Java files.
Second phase of removing Kotlin from `shared`; `Locator`, `MockVaadin`,
`PrettyPrintTree`, `Routes` and `Grid` are still Kotlin. See
`de-kotlin-plan.md`.

Each file becomes one utility class whose static methods take the former
extension receiver as their first parameter. `TestingLifecycleHook` splits in
two, since a Java interface cannot hold the mutable global the Kotlin top-level
`var` provided: the interface keeps the hook methods and `TestingLifecycleHooks`
holds the global and `cleanupDialogs()`.

A 20-line `Matches.kt` stays behind for `Component.matches()` and
`IntRange.size`, which take Kotlin-only types and go away with `SearchSpec` and
`Grid`.

Breaking changes:

* The `*Kt` facade classes are gone: `BasicUtilsKt`, `ComponentUtilsKt`,
  `ElementUtilsKt`, `RenderersKt`, `ShortcutsKt`, `UtilsKt` and
  `DepthFirstTreeIteratorKt` become `BasicUtils`, `ComponentUtils`,
  `ElementUtils`, `Renderers`, `Shortcuts`, `Utils` and
  `DepthFirstTreeIterator`.
* Property accessors lose their prefix along with the class rename, so
  `UtilsKt.getCurrentUI()` becomes `Utils.currentUI()`,
  `BasicUtilsKt.get_saneFetchLimit()` becomes `BasicUtils._saneFetchLimit()`,
  and `getId_` / `setId_` become the `id_` pair.
* The global hook moves from a top-level property to
  `TestingLifecycleHooks.getCurrent()` and `setCurrent(…)`, and
  `cleanupDialogs()` to `TestingLifecycleHooks.cleanupDialogs()`.
* `Component.isTemplate` becomes
  `TestingLifecycleHook.isTemplate(Component)`.
* `findAncestor` and `findAncestorOrSelf` take a `Predicate` in place of the
  Kotlin function type.
* `Button.caption` is folded into `caption(Component)`, which Kotlin resolved
  by static extension dispatch and Java cannot.
* Helpers that were Kotlin `internal`, and so public only by accident of the
  bytecode, are package-private: `splitByWhitespaces`, `ellipsize`,
  `hasCustomToString`, `isRouteNotFound`, `getErrorParameterType`,
  `isEffectivelyVisible`, `isPolymerTemplate` and friends.
* `serializeToBytes`, `deserialize` and `serializeDeserialize` are dropped;
  nothing called them.
---
 de-kotlin-plan.md                             |  35 +-
 .../vaadin/browserless/internal/AllTests.kt   |   2 +-
 .../browserless/internal/BasicUtilsTest.kt    |  35 +-
 .../internal/ComponentUtilsTest.kt            | 170 +++--
 .../internal/DepthFirstTreeIteratorTest.kt    |   4 +-
 .../browserless/internal/ElementUtilsTest.kt  |  48 +-
 .../browserless/internal/LocatorTest.kt       |  28 +-
 .../browserless/internal/MockVaadinTest.kt    |  22 +-
 .../internal/PrettyPrintTreeTest.kt           |   6 +-
 .../vaadin/browserless/internal/RoutesTest.kt |   2 +-
 .../browserless/internal/SearchSpecTest.kt    |  12 +-
 .../browserless/internal/ShortcutsTest.kt     |  22 +-
 .../quarkus/QuarkusSecuritySupport.java       |   4 +-
 .../vaadin/browserless/BrowserlessDSL.java    |   9 +-
 .../vaadin/browserless/TesterRegistry.java    |   6 +-
 .../browserless/internal/BasicUtils.java      | 277 ++++++++
 .../browserless/internal/ComponentUtils.java  | 608 ++++++++++++++++++
 .../internal/DepthFirstTreeIterator.java      |  89 +++
 .../browserless/internal/ElementUtils.java    | 188 ++++++
 .../browserless/internal/Renderers.java       | 173 +++++
 .../browserless/internal/Shortcuts.java       | 196 ++++++
 .../internal/TestingLifecycleHook.java        | 196 ++++++
 .../internal/TestingLifecycleHooks.java       | 128 ++++
 .../vaadin/browserless/internal/Utils.java    | 237 +++++++
 .../browserless/mocks/MockVaadinHelper.java   |  10 +-
 .../vaadin/browserless/mocks/MockedUI.java    |   4 +-
 .../component/combobox/ComboBoxTester.java    |   6 +-
 .../combobox/MultiSelectComboBoxTester.java   |   6 +-
 .../com/vaadin/browserless/component/Grid.kt  |  36 +-
 .../vaadin/browserless/internal/BasicUtils.kt | 183 ------
 .../browserless/internal/ComponentUtils.kt    | 440 -------------
 .../internal/DepthFirstTreeIterator.kt        |  46 --
 .../browserless/internal/ElementUtils.kt      | 132 ----
 .../vaadin/browserless/internal/Locator.kt    |  48 +-
 .../vaadin/browserless/internal/Matches.kt    |  34 +
 .../vaadin/browserless/internal/MockVaadin.kt |  11 +-
 .../browserless/internal/PrettyPrintTree.kt   |  31 +-
 .../vaadin/browserless/internal/Renderers.kt  | 110 ----
 .../com/vaadin/browserless/internal/Routes.kt |   8 +-
 .../vaadin/browserless/internal/Shortcuts.kt  | 144 -----
 .../internal/TestingLifecycleHook.kt          | 194 ------
 .../com/vaadin/browserless/internal/Utils.kt  | 171 -----
 .../vaadin/browserless/internal/AllTests.kt   |   6 +-
 ...rowserlessTestSpringLookupInitializer.java |   4 +-
 .../browserless/SpringSecuritySupport.java    |   4 +-
 .../browserless/mocks/MockSpringServlet.java  |   6 +-
 46 files changed, 2453 insertions(+), 1678 deletions(-)
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHook.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHooks.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/Utils.java
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/BasicUtils.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/ComponentUtils.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIterator.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/ElementUtils.kt
 create mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/Matches.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/Renderers.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/Shortcuts.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/TestingLifecycleHook.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/Utils.kt

diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index 9fb1a0de..e9f3aec2 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -92,10 +92,12 @@ spring 41, quarkus 31.
   [`guidelines/documenting.md`](guidelines/documenting.md). Once Dokka is gone
   (Phase 5) this is what `maven-javadoc-plugin` publishes.
 
-### Phase 2 — `internal/` utilities
+### Phase 2 — `internal/` utilities — done
 
 `BasicUtils`, `ComponentUtils`, `ElementUtils`, `DepthFirstTreeIterator`,
-`Renderers`, `Shortcuts`, `TestingLifecycleHook`, `Utils`.
+`Renderers`, `Shortcuts`, `TestingLifecycleHook`, `Utils`, on
+`refactor/no-kotlin-internal-utils`. All five suites match the `main` baseline:
+shared 42, junit6 1406, junit6-cdi-tests 4, spring 41, quarkus 31.
 
 One Java utility class per Kotlin file: `public final`, private constructor,
 top-level and extension functions become `public static` methods with the
@@ -104,7 +106,19 @@ receiver as the first parameter. The leading-underscore convention
 
 `TestingLifecycleHook` splits into the interface plus a `TestingLifecycleHooks`
 holder, because a Java interface cannot hold the mutable global that the Kotlin
-top-level `var testingLifecycleHook` provided.
+top-level `var testingLifecycleHook` provided. The global is a
+`getCurrent()` / `setCurrent(…)` pair, not a public field — see the
+`MockHttpEnvironment` lesson from Phase 1.
+
+A 20-line `Matches.kt` shim stays behind, holding `Component.matches(…)` and
+`IntRange.size`. Both take Kotlin-only types and go away with `SearchSpec`
+(Phase 4) and `Grid` (Phase 5).
+
+Two things the drift check caught, both in `TestingLifecycleHook`: its
+`getAllChildren` had a `Grid` branch that was commented out when the prior port
+was written and is live on `main`, and its fallback moved from
+`_getVirtualChildren` to `ComponentUtil.getAllChildren`. Porting the old Java as
+written would have silently reverted both.
 
 ### Phase 3 — `PrettyPrintTree` + `Routes`
 
@@ -189,6 +203,21 @@ top of a Java method that declares checked exceptions.
 
 - **Every `*Kt` facade class.** 24 in-repo Java call sites get rewritten; any
   external caller breaks.
+
+  Because the class name changes anyway (`UtilsKt` → `Utils`), the accessor
+  names generated for Kotlin properties are renamed at the same time and at no
+  extra cost: `getCurrentUI()` → `currentUI()`, `get_saneFetchLimit()` →
+  `_saneFetchLimit()`, `getId_()` / `setId_()` → `id_()` / `id_(…)`, and so on
+  throughout Phase 2.
+- **Kotlin `internal` helpers stop being callable from outside the package.**
+  `internal` is public in bytecode, so `splitByWhitespaces`, `ellipsize`,
+  `hasCustomToString`, `isRouteNotFound`, `getErrorParameterType`,
+  `isEffectivelyVisible`, `isPolymerTemplate` and friends were reachable by
+  accident. They are package-private in Java, which is what `internal` meant.
+- **`Button.caption` folds into `caption(Component)`.** Kotlin dispatches
+  extensions on the static type, so a more specific `Button.caption` shadowed
+  the generic one; Java has no equivalent, so the generic method takes an
+  `instanceof Button` short-circuit and the two-overload API becomes one.
 - **`.Companion` accessors** — `PrettyPrintTree.Companion.ofVaadin` (live in
   `TreeOnFailureExtension`), `TestingLifecycleHook.Companion.getDefault`,
   `MockHttpSession.Companion.create`.
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
index 2dc6a545..f3dd4b82 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
@@ -83,7 +83,7 @@ class AllTests : DynaTest({
     }
 
     test("Component.isTemplate does not fail without polymer templates dependency") {
-        expect(false) { Button("foo").isTemplate }
+        expect(false) { TestingLifecycleHook.isTemplate(Button("foo")) }
     }
 
 
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt
index 5495c25f..0b3189ab 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt
@@ -18,6 +18,12 @@ package com.vaadin.browserless.internal
 import com.github.mvysny.dynatest.DynaNodeGroup
 import com.github.mvysny.dynatest.DynaTestDsl
 import com.github.mvysny.karibudsl.v10.textField
+import com.vaadin.browserless.expectThrows
+import com.vaadin.browserless.internal.BasicUtils._blur
+import com.vaadin.browserless.internal.BasicUtils._fireDomEvent
+import com.vaadin.browserless.internal.BasicUtils._focus
+import com.vaadin.browserless.internal.BasicUtils.checkEditableByUser
+import com.vaadin.browserless.internal.BasicUtils.expectNotEditableByUser
 import com.vaadin.flow.component.ClickEvent
 import com.vaadin.flow.component.html.Div
 import com.vaadin.flow.component.orderedlayout.VerticalLayout
@@ -25,7 +31,6 @@ import com.vaadin.flow.component.textfield.TextField
 import com.vaadin.flow.dom.DomEvent
 import com.vaadin.flow.internal.JacksonUtils
 import kotlin.test.expect
-import com.vaadin.browserless.expectThrows
 
 @DynaTestDsl
 internal fun DynaNodeGroup.basicUtilsTestbatch() {
@@ -33,7 +38,7 @@ internal fun DynaNodeGroup.basicUtilsTestbatch() {
     group("checkEditableByUser") {
         test("disabled textfield fails") {
             expectThrows(java.lang.IllegalStateException::class, "The AttachedTextField\\[DISABLED,.*] is not enabled".toRegex()) {
-                AttachedTextField().apply { isEnabled = false }.checkEditableByUser()
+                checkEditableByUser(AttachedTextField().apply { isEnabled = false })
             }
         }
         test("invisible textfield fails") {
@@ -41,7 +46,7 @@ internal fun DynaNodeGroup.basicUtilsTestbatch() {
                 java.lang.IllegalStateException::class,
                 "The AttachedTextField\\[INVIS,.*] is not effectively visible".toRegex()
             ) {
-                AttachedTextField().apply { isVisible = false }.checkEditableByUser()
+                checkEditableByUser(AttachedTextField().apply { isVisible = false })
             }
         }
         test("non attached textfield fails") {
@@ -49,58 +54,58 @@ internal fun DynaNodeGroup.basicUtilsTestbatch() {
                 java.lang.IllegalStateException::class,
                 "The TextField\\[.*] is not attached".toRegex()
             ) {
-                TextField().checkEditableByUser()
+                checkEditableByUser(TextField())
             }
         }
         test("textfield in invisible layout fails") {
             expectThrows(java.lang.IllegalStateException::class, "The TextField\\[.*] is not effectively visible".toRegex()) {
                 VerticalLayout().apply {
                     isVisible = false
-                    textField().also { it.checkEditableByUser() }
+                    textField().also { checkEditableByUser(it) }
                 }
             }
         }
         test("textfield succeeds") {
-            AttachedTextField().checkEditableByUser()
+            checkEditableByUser(AttachedTextField())
         }
     }
 
     group("expectNotEditableByUser") {
         test("disabled textfield fails") {
-            AttachedTextField().apply { isEnabled = false }.expectNotEditableByUser()
+            expectNotEditableByUser(AttachedTextField().apply { isEnabled = false })
         }
         test("invisible textfield fails") {
-            AttachedTextField().apply { isVisible = false }.expectNotEditableByUser()
+            expectNotEditableByUser(AttachedTextField().apply { isVisible = false })
         }
         test("textfield in invisible layout fails") {
             VerticalLayout().apply {
                 isVisible = false
-                textField().also { it.expectNotEditableByUser() }
+                textField().also { expectNotEditableByUser(it) }
             }
         }
         test("textfield succeeds") {
             expectThrows(AssertionError::class, "The AttachedTextField\\[.*] is editable".toRegex()) {
-                AttachedTextField().expectNotEditableByUser()
+                expectNotEditableByUser(AttachedTextField())
             }
         }
     }
 
     group("fireDomEvent()") {
         test("smoke") {
-            Div()._fireDomEvent("click")
+            _fireDomEvent(Div(), "click")
         }
         test("listeners are called") {
             val div = Div()
             lateinit var event: DomEvent
             div.element.addEventListener("click") { e -> event = e }
-            div._fireDomEvent("click")
+            _fireDomEvent(div, "click")
             expect("click") { event.type }
         }
         test("higher-level listeners are called") {
             val div = Div()
             lateinit var event: ClickEvent<Div>
             div.addClickListener { e -> event = e }
-            div._fireDomEvent("click", JacksonUtils.createObjectNode().apply { put("event.screenX", 20.0) })
+            _fireDomEvent(div, "click", JacksonUtils.createObjectNode().apply { put("event.screenX", 20.0) })
             expect(20) { event.screenX }
             expect(true) { event.isFromClient }
         }
@@ -110,7 +115,7 @@ internal fun DynaNodeGroup.basicUtilsTestbatch() {
         val f = AttachedTextField()
         var called = false
         f.addFocusListener { called = true }
-        f._focus()
+        _focus(f)
         expect(true) { called }
     }
 
@@ -118,7 +123,7 @@ internal fun DynaNodeGroup.basicUtilsTestbatch() {
         val f = AttachedTextField()
         var called = false
         f.addBlurListener { called = true }
-        f._blur()
+        _blur(f)
         expect(true) { called }
     }
 }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt
index 076e8a80..5168ff6b 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt
@@ -17,6 +17,22 @@ package com.vaadin.browserless.internal
 
 import com.github.mvysny.dynatest.DynaNodeGroup
 import com.github.mvysny.dynatest.expectThrows
+import com.vaadin.browserless.internal.BasicUtils._text
+import com.vaadin.browserless.internal.ComponentUtils.addClassNames2
+import com.vaadin.browserless.internal.ComponentUtils.addContextMenuListener
+import com.vaadin.browserless.internal.ComponentUtils.caption
+import com.vaadin.browserless.internal.ComponentUtils.findAncestor
+import com.vaadin.browserless.internal.ComponentUtils.findAncestorOrSelf
+import com.vaadin.browserless.internal.ComponentUtils.hasChildren
+import com.vaadin.browserless.internal.ComponentUtils.insertBefore
+import com.vaadin.browserless.internal.ComponentUtils.isAttached
+import com.vaadin.browserless.internal.ComponentUtils.isNestedIn
+import com.vaadin.browserless.internal.ComponentUtils.label
+import com.vaadin.browserless.internal.ComponentUtils.placeholder
+import com.vaadin.browserless.internal.ComponentUtils.removeClassNames2
+import com.vaadin.browserless.internal.ComponentUtils.removeFromParent
+import com.vaadin.browserless.internal.ComponentUtils.serverClick
+import com.vaadin.browserless.internal.ComponentUtils.setClassNames2
 import com.vaadin.flow.component.Component
 import com.vaadin.flow.component.Text
 import com.vaadin.flow.component.UI
@@ -38,21 +54,21 @@ fun DynaNodeGroup.componentUtilsTests() {
     group("removeFromParent()") {
         test("component with no parent") {
             val t = Text("foo")
-            t.removeFromParent()
+            removeFromParent(t)
             expect(null) { t.parent.orElse(null) }
         }
         test("nested component") {
             val fl = FlexLayout().apply { add(Span("foo")) }
             val label = fl.getComponentAt(0)
             expect(fl) { label.parent.get() }
-            label.removeFromParent()
+            removeFromParent(label)
             expect(null) { label.parent.orElse(null) }
             expect(0) { fl.componentCount }
         }
         test("reattach") {
             val fl = FlexLayout().apply { add(Span("foo")) }
             val label = fl.getComponentAt(0)
-            label.removeFromParent()
+            removeFromParent(label)
             fl.add(label)
             expect(fl) { label.parent.orElse(null) }
             expect(1) { fl.componentCount }
@@ -63,7 +79,7 @@ fun DynaNodeGroup.componentUtilsTests() {
         val b = Button()
         var clicked = 0
         b.addClickListener { clicked++ }
-        b.serverClick()
+        serverClick(b)
         expect(1) { clicked }
     }
 
@@ -79,63 +95,63 @@ fun DynaNodeGroup.componentUtilsTests() {
     }
 
     test("addContextMenuListener smoke") {
-        Button().addContextMenuListener({})
+        addContextMenuListener(Button(), {})
     }
 
     group("findAncestor") {
         test("null on no parent") {
-            expect(null) { Button().findAncestor { false } }
+            expect(null) { findAncestor(Button()) { false } }
         }
         test("null on no acceptance") {
             val button = Button()
             UI.getCurrent().add(button)
-            expect(null) { button.findAncestor { false } }
+            expect(null) { findAncestor(button) { false } }
         }
         test("finds UI") {
             val button = Button()
             UI.getCurrent().add(button)
-            expect(UI.getCurrent()) { button.findAncestor { it is UI } }
+            expect(UI.getCurrent()) { findAncestor(button) { it is UI } }
         }
         test("doesn't find self") {
             val button = Button()
             UI.getCurrent().add(button)
-            expect(UI.getCurrent()) { button.findAncestor { true } }
+            expect(UI.getCurrent()) { findAncestor(button) { true } }
         }
     }
 
     group("findAncestorOrSelf") {
         test("null on no parent") {
-            expect(null) { Button().findAncestorOrSelf { false } }
+            expect(null) { findAncestorOrSelf(Button()) { false } }
         }
         test("null on no acceptance") {
             val button = Button()
             UI.getCurrent().add(button)
-            expect(null) { button.findAncestorOrSelf { false } }
+            expect(null) { findAncestorOrSelf(button) { false } }
         }
         test("finds self") {
             val button = Button()
             UI.getCurrent().add(button)
-            expect(button) { button.findAncestorOrSelf { true } }
+            expect(button) { findAncestorOrSelf(button) { true } }
         }
     }
 
     test("isNestedIn") {
-        expect(false) { Button().isNestedIn(UI.getCurrent()) }
+        expect(false) { isNestedIn(Button(), UI.getCurrent()) }
         val button = Button()
         UI.getCurrent().add(button)
-        expect(true) { button.isNestedIn(UI.getCurrent()) }
+        expect(true) { isNestedIn(button, UI.getCurrent()) }
     }
 
     test("isAttached") {
-        expect(true) { UI.getCurrent().isAttached() }
-        expect(false) { Button("foo").isAttached() }
+        expect(true) { isAttached(UI.getCurrent()) }
+        expect(false) { isAttached(Button("foo")) }
         expect(true) {
             val button = Button()
             UI.getCurrent().add(button)
-            button.isAttached()
+            isAttached(button)
         }
         UI.getCurrent().close()
-        expect(true) { UI.getCurrent().isAttached() }
+        expect(true) { isAttached(UI.getCurrent()) }
     }
 
     test("insertBefore") {
@@ -143,78 +159,58 @@ fun DynaNodeGroup.componentUtilsTests() {
         val first = Span("first")
         l.addComponentAsFirst(first)
         val second = Span("second")
-        l.insertBefore(second, first)
-        expect("second, first") { l.children.toList().map { it._text } .joinToString() }
-        l.insertBefore(Span("third"), first)
-        expect("second, third, first") { l.children.toList().map { it._text } .joinToString() }
+        insertBefore(l, second, first)
+        expect("second, first") { l.children.toList().map { _text(it) } .joinToString() }
+        insertBefore(l, Span("third"), first)
+        expect("second, third, first") { l.children.toList().map { _text(it) } .joinToString() }
     }
 
     test("hasChildren") {
         val l = HorizontalLayout()
-        expect(false) { l.hasChildren }
+        expect(false) { hasChildren(l) }
         l.addComponentAsFirst(Span("first"))
-        expect(true) { l.hasChildren }
+        expect(true) { hasChildren(l) }
         l.removeAll()
-        expect(false) { l.hasChildren }
+        expect(false) { hasChildren(l) }
     }
 
-    /*
-    test("isNotEmpty") {
-        val l = HorizontalLayout()
-        expect(false) { l.isNotEmpty }
-        l.addComponentAsFirst(Span("first"))
-        expect(true) { l.isNotEmpty }
-        l.removeAll()
-        expect(false) { l.isNotEmpty }
-    }
-
-    test("isEmpty") {
-        val l = HorizontalLayout()
-        expect(true) { l.isEmpty }
-        l.addComponentAsFirst(Span("first"))
-        expect(false) { l.isEmpty }
-        l.removeAll()
-        expect(true) { l.isEmpty }
-    }
-     */
-
     group("classnames2") {
         test("addClassNames2") {
-            val div = Div().apply { addClassNames2("foo  bar    baz") }
+            val div = Div().apply { addClassNames2(this, "foo  bar    baz") }
             expect(true) {
                 div.classNames.containsAll(listOf("foo", "bar", "baz"))
             }
         }
         test("addClassNames2(vararg)") {
-            val div = Div().apply { addClassNames2("foo  bar    baz", "  one  two") }
+            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
             expect(true) {
                 div.classNames.containsAll(listOf("foo", "bar", "baz", "one", "two"))
             }
         }
         test("setClassNames2") {
-            val div = Div().apply { addClassNames2("foo  bar    baz", "  one  two") }
-            div.setClassNames2("  three four  ")
+            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
+            setClassNames2(div, "  three four  ")
             expect(true) {
                 div.classNames.containsAll(listOf("three", "four"))
             }
         }
         test("setClassNames2(vararg)") {
-            val div = Div().apply { addClassNames2("foo  bar    baz", "  one  two") }
-            div.setClassNames2("  three ", "four  ")
+            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
+            setClassNames2(div, "  three ", "four  ")
             expect(true) {
                 div.classNames.containsAll(listOf("three", "four"))
             }
         }
         test("removeClassNames2") {
-            val div = Div().apply { addClassNames2("foo  bar    baz", "  one  two") }
-            div.removeClassNames2("  bar baz  ")
+            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
+            removeClassNames2(div, "  bar baz  ")
             expect(true) {
                 div.classNames.containsAll(listOf("foo", "one", "two"))
             }
         }
         test("removeClassNames2(vararg)") {
-            val div = Div().apply { addClassNames2("foo  bar    baz", "  one  two") }
-            div.removeClassNames2("  bar ", "baz  ")
+            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
+            removeClassNames2(div, "  bar ", "baz  ")
             expect(true) {
                 div.classNames.containsAll(listOf("foo", "one", "two"))
             }
@@ -222,59 +218,59 @@ fun DynaNodeGroup.componentUtilsTests() {
     }
 
     test("placeholder") {
-        var c: Component = TextField().apply { placeholder = "foo" }
-        expect("foo") { c.placeholder }
-        c.placeholder = ""
-        expect("") { c.placeholder }
-        c = TextArea().apply { placeholder = "foo" }
-        expect("foo") { c.placeholder }
-        c.placeholder = ""
-        expect("") { c.placeholder }
+        var c: Component = TextField().apply { setPlaceholder("foo") }
+        expect("foo") { placeholder(c) }
+        placeholder(c, "")
+        expect("") { placeholder(c) }
+        c = TextArea().apply { setPlaceholder("foo") }
+        expect("foo") { placeholder(c) }
+        placeholder(c, "")
+        expect("") { placeholder(c) }
         c = Button() // doesn't support placeholder
-        expect(null) { c.placeholder }
+        expect(null) { placeholder(c) }
         expectThrows(IllegalStateException::class, "Button doesn't support setting placeholder") {
-            c.placeholder = "foo"
+            placeholder(c, "foo")
         }
     }
 
     group("label") {
         test("TextField") {
             val c: Component = TextField()
-            expect("") { c.label }
-            c.label = "foo"
-            expect("foo") { c.label }
-            c.label = ""
-            expect("") { c.label }
+            expect("") { label(c) }
+            label(c, "foo")
+            expect("foo") { label(c) }
+            label(c, "")
+            expect("") { label(c) }
         }
         test("Checkbox") {
             val c: Component = Checkbox()
-            expect("") { c.label }
-            c.label = "foo"
-            expect("foo") { c.label }
-            c.label = ""
-            expect("") { c.label }
+            expect("") { label(c) }
+            label(c, "foo")
+            expect("foo") { label(c) }
+            label(c, "")
+            expect("") { label(c) }
         }
     }
 
     test("caption") {
         var c: Component = Button("foo")
-        expect("foo") { c.caption }
-        c.caption = ""
-        expect("") { c.caption }
-        c = Checkbox().apply { caption = "foo" }
-        expect("foo") { c.caption }
-        c.caption = ""
-        expect("") { c.caption }
-        expect("") { FormLayout.FormItem().label }
+        expect("foo") { caption(c) }
+        caption(c, "")
+        expect("") { caption(c) }
+        c = Checkbox().also { caption(it, "foo") }
+        expect("foo") { caption(c) }
+        caption(c, "")
+        expect("") { caption(c) }
+        expect("") { label(FormLayout.FormItem()) }
         val fl = FormLayout()
         c = fl.addFormItem(Button(), "foo")
-        expect("foo") { c.caption }
+        expect("foo") { caption(c) }
     }
 
     test("Button.caption") {
         val c = Button("foo")
-        expect("foo") { c.caption }
-        c.caption = ""
-        expect("") { c.caption }
+        expect("foo") { caption(c) }
+        caption(c, "")
+        expect("") { caption(c) }
     }
 }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt
index 66a3cfc3..f2c05426 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt
@@ -48,7 +48,7 @@ fun DynaNodeGroup.depthFirstTreeIteratorTests() {
             })
             add(VerticalLayout().apply { expected.add(this) })
         }
-        expect(expected) { root.walk().toList() }
-        expect(root) { root.walk().toList()[0] }
+        expect(expected) { DepthFirstTreeIterator.walk(root).toList() }
+        expect(root) { DepthFirstTreeIterator.walk(root).toList()[0] }
     }
 }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt
index ec971faa..68b3b9bf 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt
@@ -16,6 +16,15 @@
 package com.vaadin.browserless.internal
 
 import com.github.mvysny.dynatest.DynaNodeGroup
+import com.vaadin.browserless.expectList
+import com.vaadin.browserless.internal.ElementUtils._fireDomEvent
+import com.vaadin.browserless.internal.ElementUtils.clearSlot
+import com.vaadin.browserless.internal.ElementUtils.getChildrenInSlot
+import com.vaadin.browserless.internal.ElementUtils.getVirtualChildren
+import com.vaadin.browserless.internal.ElementUtils.insertBefore
+import com.vaadin.browserless.internal.ElementUtils.setOrRemoveAttribute
+import com.vaadin.browserless.internal.ElementUtils.textRecursively2
+import com.vaadin.browserless.internal.ElementUtils.toggle
 import com.vaadin.flow.component.Text
 import com.vaadin.flow.component.UI
 import com.vaadin.flow.component.button.Button
@@ -26,7 +35,6 @@ import com.vaadin.flow.component.textfield.TextField
 import com.vaadin.flow.dom.DomEvent
 import com.vaadin.flow.dom.Element
 import com.vaadin.flow.internal.JacksonUtils
-import com.vaadin.browserless.expectList
 import kotlin.test.expect
 
 fun DynaNodeGroup.elementUtilsTests() {
@@ -36,22 +44,22 @@ fun DynaNodeGroup.elementUtilsTests() {
     test("setOrRemoveAttribute") {
         val t = Div().element
         expect(null) { t.getAttribute("foo") }
-        t.setOrRemoveAttribute("foo", "bar")
+        setOrRemoveAttribute(t, "foo", "bar")
         expect("bar") { t.getAttribute("foo") }
-        t.setOrRemoveAttribute("foo", null)
+        setOrRemoveAttribute(t, "foo", null)
         expect(null) { t.getAttribute("foo") }
     }
 
     group("toggle class name") {
         test("add") {
             val t = Div()
-            t.classNames.toggle("test")
+            toggle(t.classNames, "test")
             expect(setOf("test")) { t.classNames }
         }
         test("remove") {
             val t = Div()
             t.classNames.add("test")
-            t.classNames.toggle("test")
+            toggle(t.classNames, "test")
             expect(setOf<String>()) { t.classNames }
         }
     }
@@ -61,57 +69,57 @@ fun DynaNodeGroup.elementUtilsTests() {
         val first: Element = Span("first").element
         l.appendChild(first)
         val second: Element = Span("second").element
-        l.insertBefore(second, first)
+        insertBefore(l, second, first)
         expect("second, first") { l.children.toList().joinToString { it.text } }
-        l.insertBefore(Span("third").element, first)
+        insertBefore(l, Span("third").element, first)
         expect("second, third, first") { l.children.toList().joinToString { it.text } }
     }
 
     test("textRecursively2") {
-        expect("foo") { Span("foo").element.textRecursively2 }
+        expect("foo") { textRecursively2(Span("foo").element) }
         expect("foobarbaz") {
             val div = Div()
             div.add(Span("foo"), Text("bar"), Paragraph("baz"))
-            div.element.textRecursively2
+            textRecursively2(div.element)
         }
-        expect("foo") { Element("div").apply { setProperty("innerHTML", "foo") }.textRecursively2 }
+        expect("foo") { textRecursively2(Element("div").apply { setProperty("innerHTML", "foo") }) }
     }
 
     group("getVirtualChildren()") {
         test("initially empty") {
-            expectList() { Div().element.getVirtualChildren() }
-            expectList() { Span().element.getVirtualChildren() }
-            expectList() {
+            expectList<Element>() { getVirtualChildren(Div().element) }
+            expectList<Element>() { getVirtualChildren(Span().element) }
+            expectList<Element>() {
                 val b = Button()
                 UI.getCurrent().add(b)
-                b.element.getVirtualChildren()
+                getVirtualChildren(b.element)
             }
         }
         test("add virtual child") {
             val span = Span().element
             val parent = Div()
             parent.element.appendVirtualChild(span)
-            expectList(span) { parent.element.getVirtualChildren() }
+            expectList(span) { getVirtualChildren(parent.element) }
         }
     }
 
     test("getChildrenInSlot") {
-        expectList() { TextField().element.getChildrenInSlot("prefix") }
+        expectList<Element>() { getChildrenInSlot(TextField().element, "prefix") }
         val div = Div()
-        expectList(div.element) { TextField().apply { prefixComponent = div } .element.getChildrenInSlot("prefix") }
+        expectList(div.element) { getChildrenInSlot(TextField().apply { prefixComponent = div }.element, "prefix") }
     }
 
     test("clearSlot") {
         val tf = TextField()
         tf.prefixComponent = Div()
-        tf.element.clearSlot("prefix")
-        expectList() { tf.element.getChildrenInSlot("prefix") }
+        clearSlot(tf.element, "prefix")
+        expectList<Element>() { getChildrenInSlot(tf.element, "prefix") }
         expect(null) { tf.prefixComponent }
     }
 
     test("fireDomEvent() smoke") {
         val element = Div().element
-        element._fireDomEvent(DomEvent(element, "click", JacksonUtils.createObjectNode()))
+        _fireDomEvent(element, DomEvent(element, "click", JacksonUtils.createObjectNode()))
     }
 
 }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt
index 300958b1..b514d8cf 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt
@@ -18,6 +18,8 @@ package com.vaadin.browserless.internal
 import java.util.function.Predicate
 import kotlin.streams.asSequence
 import kotlin.test.expect
+import com.vaadin.browserless.internal.BasicUtils.id_
+import com.vaadin.browserless.internal.Utils.currentUI
 import com.vaadin.flow.component.Text
 import com.vaadin.flow.component.UI
 import com.vaadin.flow.component.button.Button
@@ -66,7 +68,7 @@ internal fun DynaNodeGroup.locatorTest2() {
         test("component lookup fails on navigation error") {
             // Vaadin shows InternalServerError when an exception occurs during the navigation phase.
             // the _expect*() functions should detect this and fail fast.
-            currentUI.addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
+            currentUI().addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
             UI.getCurrent().navigate("")
             expectThrows<AssertionError>("An internal server error occurred; please check log for the actual stack-trace. Error text: There was an exception while trying to navigate to") {
                 _expectOne<UI>()
@@ -80,12 +82,12 @@ internal fun DynaNodeGroup.locatorTest2() {
                 ) { _expectInternalServerError() }
             }
             test("succeeds on error") {
-                currentUI.addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
+                currentUI().addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
                 UI.getCurrent().navigate("")
                 _expectInternalServerError()
             }
             test("matches error message correctly") {
-                currentUI.addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
+                currentUI().addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
                 UI.getCurrent().navigate("")
                 _expectInternalServerError("Simulated")
             }
@@ -97,8 +99,8 @@ internal fun DynaNodeGroup.locatorTest2() {
 internal fun DynaNodeGroup.locatorTest() {
 
     beforeEach { MockVaadin.setup() }
-    beforeEach { testingLifecycleHook = MyLifecycleHook() }
-    afterEach { testingLifecycleHook = TestingLifecycleHook.default }
+    beforeEach { TestingLifecycleHooks.setCurrent(MyLifecycleHook()) }
+    afterEach { TestingLifecycleHooks.setCurrent(TestingLifecycleHook.DEFAULT) }
     afterEach { MockVaadin.tearDown() }
 
     group("_get") {
@@ -139,7 +141,7 @@ internal fun DynaNodeGroup.locatorTest() {
 
     group("_find") {
         test("findMatchingId") {
-            val button = Button().apply { id_ = "foo" }
+            val button = Button().also { id_(it, "foo") }
             expectList(button) { VerticalLayout(button, Button())._find<Button> { id = "foo" } }
             expectAfterLookupCalled()
         }
@@ -220,10 +222,10 @@ internal fun DynaNodeGroup.locatorTest() {
         test("id") {
             expect(true) { Button().matches { } }
             expect(false) { Button().matches { id = "a" } }
-            expect(true) { Button().apply { id_ = "a" } .matches { } }
-            expect(true) { Button().apply { id_ = "a" } .matches { id = "a" } }
-            expect(false) { Button().apply { id_ = "a b" } .matches { id = "a" } }
-            expect(false) { Button().apply { id_ = "a" } .matches { id = "a b" } }
+            expect(true) { Button().also { id_(it, "a") } .matches { } }
+            expect(true) { Button().also { id_(it, "a") } .matches { id = "a" } }
+            expect(false) { Button().also { id_(it, "a b") } .matches { id = "a" } }
+            expect(false) { Button().also { id_(it, "a") } .matches { id = "a b" } }
         }
         test("caption") {
             expect(true) { Button("click me").matches { caption = "click me" } }
@@ -299,7 +301,7 @@ internal fun DynaNodeGroup.locatorTest() {
     }
 
     group("unmocked env") {
-        beforeEach { MockVaadin.tearDown(); testingLifecycleHook = TestingLifecycleHook.default }
+        beforeEach { MockVaadin.tearDown(); TestingLifecycleHooks.setCurrent(TestingLifecycleHook.DEFAULT) }
         test("lookup functions should work in unmocked environment") {
             Button()._get(Button::class.java)
             expectThrows(AssertionError::class) {
@@ -423,6 +425,6 @@ data class MyLifecycleHook(var isBeforeLookupCalled: Boolean = false, var isAfte
 }
 
 fun expectAfterLookupCalled() {
-    expect(MyLifecycleHook(true, true)) { testingLifecycleHook }
-    testingLifecycleHook = MyLifecycleHook()
+    expect(MyLifecycleHook(true, true)) { TestingLifecycleHooks.getCurrent() }
+    TestingLifecycleHooks.setCurrent(MyLifecycleHook())
 }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
index ef1c3a91..44b70f91 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
@@ -17,6 +17,12 @@
 
 package com.vaadin.browserless.internal
 
+import com.vaadin.browserless.internal.BasicUtils._close
+import com.vaadin.browserless.internal.TestingLifecycleHooks.cleanupDialogs
+import com.vaadin.browserless.internal.Utils.currentRequest
+import com.vaadin.browserless.internal.Utils.currentResponse
+import com.vaadin.browserless.internal.Utils.mock
+
 import com.example.base.HelloWorldView
 import com.example.base.ParametrizedView
 import com.example.base.child.ChildView
@@ -210,7 +216,7 @@ internal fun DynaNodeGroup.mockVaadinTest() {
             expect(true) { UI.getCurrent().isAttached() }
 
             // Mock closing of UI after request handled
-            UI.getCurrent()._close()
+            _close(UI.getCurrent())
             expect(false) { vl.isAttached() }
             expect(1) { detachCalled }
             expect(false) { UI.getCurrent().isAttached() }
@@ -390,25 +396,25 @@ internal fun DynaNodeGroup.mockVaadinTest() {
 
     group("request") {
         test("cookies") {
-            currentRequest.mock.addCookie(Cookie("foo", "bar"))
-            expectList("bar") { currentRequest.cookies!!.map { it.value } }
+            mock(currentRequest()).addCookie(Cookie("foo", "bar"))
+            expectList("bar") { currentRequest().cookies!!.map { it.value } }
         }
     }
 
     group("response") {
         test("cookies") {
-            currentResponse.addCookie(Cookie("foo", "bar"))
-            expect("bar") { currentResponse.mock.getCookie("foo").value }
+            currentResponse().addCookie(Cookie("foo", "bar"))
+            expect("bar") { mock(currentResponse()).getCookie("foo").value }
         }
 
         test("cookies in UI.init()") {
             MockVaadin.tearDown()
             var initCalled = false
             MockVaadin.setup(uiFactory = {
-                currentRequest.mock.addCookie(Cookie("foo", "bar"))
+                mock(currentRequest()).addCookie(Cookie("foo", "bar"))
                 object : UI() {
                     override fun init(request: VaadinRequest) {
-                        expectList("bar") { currentRequest.cookies!!.map { it.value } }
+                        expectList("bar") { currentRequest().cookies!!.map { it.value } }
                         initCalled = true
                     }
                 }
@@ -420,7 +426,7 @@ internal fun DynaNodeGroup.mockVaadinTest() {
     group("session") {
         test("attributes") {
             VaadinSession.getCurrent().session.setAttribute("foo", "bar")
-            expect("bar") { VaadinSession.getCurrent().mock.getAttribute("foo") }
+            expect("bar") { mock(VaadinSession.getCurrent()).getAttribute("foo") }
         }
         test("changeSessionId() keeps the VaadinSession") {
             // How an app without Spring Security protects against session
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
index dc7149f6..dca54759 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
@@ -15,6 +15,8 @@
  */
 package com.vaadin.browserless.internal
 
+import com.vaadin.browserless.internal.BasicUtils.id_
+
 import com.example.base.HelloWorldView
 import com.github.mvysny.dynatest.DynaNodeGroup
 import com.github.mvysny.dynatest.DynaTestDsl
@@ -79,9 +81,9 @@ internal fun DynaNodeGroup.prettyPrintTreeTest() {
         }
     }
     test("toPrettyStringTextField()") {
-        assertContains(TextField().apply { id_ = "25" }.toPrettyString(),"TextField\\[#25, value=''.*]".toRegex())
+        assertContains(TextField().also { id_(it, "25") }.toPrettyString(),"TextField\\[#25, value=''.*]".toRegex())
         assertContains(TextArea("label").apply { value = "some text" }.toPrettyString(),"TextArea\\[label='label', value='some text'.*]".toRegex())
-        assertContains(TextField().apply { id_ = "25"; errorMessage = "failed validation" }.toPrettyString(),"TextField\\[#25, value='', errorMessage='failed validation'.*]".toRegex())
+        assertContains(TextField().also { id_(it, "25"); it.errorMessage = "failed validation" }.toPrettyString(),"TextField\\[#25, value='', errorMessage='failed validation'.*]".toRegex())
         assertContains(TextField("foobar").toPrettyString(), "TextField\\[label='foobar', value=''.*]".toRegex() )
     }
     test("toPrettyStringButton()") {
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
index 8be5b3a7..9528fa44 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
@@ -113,7 +113,7 @@ fun DynaNodeGroup.routesTestBatch() {
             throw (view as MockRouteNotFoundError).cause!!
         }
         expect(true) {
-            val errorMessage = view.element.textRecursively2
+            val errorMessage = ElementUtils.textRecursively2(view.element)
             errorMessage.contains("Could not navigate to 'A_VIEW_THAT_DOESNT_EXIST'")
         }
     }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
index ae6dc95a..7475e2a9 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
@@ -85,13 +85,13 @@ internal fun DynaNodeGroup.searchSpecTest() {
         }
         expect(false) { spec.toPredicate()(Select<Int>()) }
         expect(true) {
-            spec.toPredicate()(ListBox<Int>().apply {
-                label = "foo"
+            spec.toPredicate()(ListBox<Int>().also {
+                ComponentUtils.label(it, "foo")
             })
         }
         expect(false) {
-            spec.toPredicate()(ListBox<Int>().apply {
-                label = "bar"
+            spec.toPredicate()(ListBox<Int>().also {
+                ComponentUtils.label(it, "bar")
             })
         }
         expect(false) { spec.toPredicate()(ListBox<Int>()) }
@@ -119,8 +119,8 @@ internal fun DynaNodeGroup.searchSpecTest() {
         }
         expect(false) { spec.toPredicate()(DateRangePopup()) }
 
-        expect(true) { spec.toPredicate()(Input().apply { label = "foo" }) }
-        expect(false) { spec.toPredicate()(Input().apply { label = "bar" }) }
+        expect(true) { spec.toPredicate()(Input().also { ComponentUtils.label(it, "foo") }) }
+        expect(false) { spec.toPredicate()(Input().also { ComponentUtils.label(it, "bar") }) }
         expect(false) { spec.toPredicate()(Input()) }
         expect(true) { spec.toPredicate()(TextField("foo")) }
         expect(false) { spec.toPredicate()(TextField("bar")) }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt
index 721639e8..63a92048 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt
@@ -21,6 +21,8 @@ import com.github.mvysny.karibudsl.v10.ModifierKey.Alt
 import com.github.mvysny.karibudsl.v10.addClickShortcut
 import com.github.mvysny.karibudsl.v10.button
 import com.github.mvysny.karibudsl.v10.onLeftClick
+import com.vaadin.browserless.internal.Shortcuts.fireShortcut
+import com.vaadin.browserless.internal.Utils.currentUI
 import com.vaadin.flow.component.Key
 import com.vaadin.flow.component.KeyModifier
 import com.vaadin.flow.component.Shortcuts
@@ -39,7 +41,7 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
     group("Button.addClickShortcut()") {
         test("simple") {
             var clicked = false
-            currentUI.button {
+            currentUI().button {
                 onLeftClick { clicked = true }
                 addClickShortcut(Key.ENTER)
             }
@@ -49,7 +51,7 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
 
         test("button not triggered on different key press") {
             var clicked = false
-            currentUI.button {
+            currentUI().button {
                 onLeftClick { clicked = true }
                 addClickShortcut(Key.KEY_A)
             }
@@ -61,7 +63,7 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
 
         test("button not triggered on different modifiers") {
             var clicked = false
-            currentUI.button {
+            currentUI().button {
                 onLeftClick { clicked = true }
                 addClickShortcut(Alt + Key.KEY_A)
             }
@@ -78,7 +80,7 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
         test("space") {
             // Key.SPACE has multiple key bindings, test that out.
             var clicked = false
-            currentUI.button {
+            currentUI().button {
                 onLeftClick { clicked = true }
                 addClickShortcut(Key.SPACE)
             }
@@ -88,7 +90,7 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
 
         test("space not triggered on different modifiers") {
             var clicked = false
-            currentUI.button {
+            currentUI().button {
                 onLeftClick { clicked = true }
                 addClickShortcut(Alt + Key.SPACE)
             }
@@ -108,14 +110,14 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
     group("Shortcuts.addShortcutListener()") {
         test("simple") {
             var clicked = false
-            Shortcuts.addShortcutListener(currentUI, Command { clicked = true }, Key.ENTER)
+            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.ENTER)
             fireShortcut(Key.ENTER)
             expect(true) { clicked }
         }
 
         test("button not triggered on different key press") {
             var clicked = false
-            Shortcuts.addShortcutListener(currentUI, Command { clicked = true }, Key.KEY_A)
+            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.KEY_A)
             fireShortcut(Key.ENTER)
             expect(false) { clicked }
             fireShortcut(Key.SPACE)
@@ -124,7 +126,7 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
 
         test("button not triggered on different modifiers") {
             var clicked = false
-            Shortcuts.addShortcutListener(currentUI, Command { clicked = true }, Key.KEY_A, KeyModifier.values()[2] /*ALT*/)
+            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.KEY_A, KeyModifier.values()[2] /*ALT*/)
             fireShortcut(Key.KEY_A)
             expect(false) { clicked }
             fireShortcut(Key.KEY_A, KeyModifier.CONTROL)
@@ -138,14 +140,14 @@ internal fun DynaNodeGroup.shortcutsTestBatch() {
         test("space") {
             // Key.SPACE has multiple key bindings, test that out.
             var clicked = false
-            Shortcuts.addShortcutListener(currentUI, Command { clicked = true }, Key.SPACE)
+            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.SPACE)
             fireShortcut(Key.SPACE)
             expect(true) { clicked }
         }
 
         test("space not triggered on different modifiers") {
             var clicked = false
-            Shortcuts.addShortcutListener(currentUI, Command { clicked = true }, Key.SPACE, KeyModifier.values()[2] /*ALT*/)
+            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.SPACE, KeyModifier.values()[2] /*ALT*/)
             fireShortcut(Key.ENTER)
             expect(false) { clicked }
             fireShortcut(Key.SPACE)
diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecuritySupport.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecuritySupport.java
index ec4fbfb1..c9bd24b3 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecuritySupport.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecuritySupport.java
@@ -19,7 +19,7 @@
 
 import java.util.function.BooleanSupplier;
 
-import com.vaadin.browserless.internal.UtilsKt;
+import com.vaadin.browserless.internal.Utils;
 
 /**
  * Detects whether Quarkus Security is active in the running application.
@@ -45,7 +45,7 @@ final class QuarkusSecuritySupport {
     private static final String CURRENT_IDENTITY_ASSOCIATION_CLASS = "io.quarkus.security.identity.CurrentIdentityAssociation";
 
     private static final BooleanSupplier DEFAULT_DETECTOR = () -> {
-        Class<?> beanClass = UtilsKt
+        Class<?> beanClass = Utils
                 .findClass(CURRENT_IDENTITY_ASSOCIATION_CLASS);
         if (beanClass == null) {
             return false;
diff --git a/shared/src/main/java/com/vaadin/browserless/BrowserlessDSL.java b/shared/src/main/java/com/vaadin/browserless/BrowserlessDSL.java
index a7d36c41..dd530845 100644
--- a/shared/src/main/java/com/vaadin/browserless/BrowserlessDSL.java
+++ b/shared/src/main/java/com/vaadin/browserless/BrowserlessDSL.java
@@ -19,7 +19,7 @@
 import java.util.concurrent.TimeUnit;
 
 import com.vaadin.browserless.internal.MockInternalSeverError;
-import com.vaadin.browserless.internal.ShortcutsKt;
+import com.vaadin.browserless.internal.Shortcuts;
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.HasElement;
 import com.vaadin.flow.component.Key;
@@ -119,11 +119,10 @@ static <T extends Component> ComponentQuery<T> findView(UI ui,
 
     static void fireShortcut(UI ui, Key key, KeyModifier... modifiers) {
         if (ui.hasModalComponent()) {
-            ShortcutsKt._fireShortcut(
-                    ui.getInternals().getActiveModalComponent(), key,
-                    modifiers);
+            Shortcuts._fireShortcut(ui.getInternals().getActiveModalComponent(),
+                    key, modifiers);
         } else {
-            ShortcutsKt.fireShortcut(key, modifiers);
+            Shortcuts.fireShortcut(key, modifiers);
         }
     }
 
diff --git a/shared/src/main/java/com/vaadin/browserless/TesterRegistry.java b/shared/src/main/java/com/vaadin/browserless/TesterRegistry.java
index 101878aa..04309d10 100644
--- a/shared/src/main/java/com/vaadin/browserless/TesterRegistry.java
+++ b/shared/src/main/java/com/vaadin/browserless/TesterRegistry.java
@@ -34,7 +34,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.vaadin.browserless.internal.UtilsKt;
+import com.vaadin.browserless.internal.Utils;
 import com.vaadin.flow.component.Component;
 
 /**
@@ -116,7 +116,7 @@ private static Map<Class<?>, Class<? extends ComponentTester>> scanForTesters(
                             .extendsSuperclass(ComponentTester.class))
                     .forEach(classInfo -> {
                         try {
-                            final Class<?> tester = UtilsKt
+                            final Class<?> tester = Utils
                                     .findClassOrThrow(classInfo.getName());
                             final Class<? extends Component>[] annotation = tester
                                     .getAnnotation(Tests.class).value();
@@ -131,7 +131,7 @@ private static Map<Class<?>, Class<? extends ComponentTester>> scanForTesters(
                                     .getAnnotation(Tests.class).fqn();
                             Arrays.stream(classes).map(clazz -> {
                                 try {
-                                    return UtilsKt.findClassOrThrow(clazz);
+                                    return Utils.findClassOrThrow(clazz);
                                 } catch (ClassNotFoundException e) {
                                     logTypeLoadingIssue(e,
                                             "Tester '{}' cannot be loaded because of missing component class '{}' on classpath",
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
new file mode 100644
index 00000000..8d7acd2d
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
@@ -0,0 +1,277 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import tools.jackson.databind.node.ObjectNode;
+
+import com.vaadin.flow.component.BlurNotifier;
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.ComponentEvent;
+import com.vaadin.flow.component.ComponentUtil;
+import com.vaadin.flow.component.FocusNotifier;
+import com.vaadin.flow.component.Focusable;
+import com.vaadin.flow.component.HasText;
+import com.vaadin.flow.component.HasValue;
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.dom.DomEvent;
+import com.vaadin.flow.dom.Element;
+import com.vaadin.flow.internal.JacksonUtils;
+import com.vaadin.flow.router.InternalServerError;
+import com.vaadin.flow.server.VaadinSession;
+
+/**
+ * Helpers for driving a component the way a browser would: firing events on it,
+ * asking whether a user could actually interact with it, and reading the few
+ * properties Flow does not expose directly.
+ * <p>
+ * {@link #checkEditableByUser(Component)} is the one to reach for before any
+ * simulated interaction. A component that is invisible, disabled, read-only or
+ * detached cannot be touched by a user, and a test that pretends otherwise
+ * asserts on a state the application can never reach.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class BasicUtils {
+
+    private BasicUtils() {
+    }
+
+    /**
+     * Allows us to fire any Vaadin event on any Vaadin component.
+     * 
+     * @param component
+     *            the component, not null.
+     * @param event
+     *            the event, not null.
+     */
+    public static void _fireEvent(Component component,
+            ComponentEvent<?> event) {
+        ComponentUtil.fireEvent(component, event);
+    }
+
+    /**
+     * Fires a DOM event on this component.
+     * 
+     * @param eventType
+     *            the event type, e.g. "click"
+     */
+    public static void _fireDomEvent(Component component, String eventType) {
+        _fireDomEvent(component, eventType, JacksonUtils.createObjectNode());
+    }
+
+    /**
+     * Fires a DOM event on this component.
+     * 
+     * @param eventType
+     *            the event type, e.g. "click"
+     * @param eventData
+     *            optional event data, defaults to an empty object.
+     */
+    public static void _fireDomEvent(Component component, String eventType,
+            ObjectNode eventData) {
+        Element element = component.getElement();
+        ElementUtils._fireDomEvent(element,
+                new DomEvent(element, eventType, eventData));
+    }
+
+    /**
+     * The same as {@link Component#getId} but without Optional.
+     *
+     * Workaround for https://github.com/vaadin/flow/issues/664
+     */
+    public static String id_(Component component) {
+        return component.getId().orElse(null);
+    }
+
+    public static void id_(Component component, String value) {
+        component.setId(value);
+    }
+
+    /**
+     * Checks whether the component is visible (usually
+     * {@link Component#isVisible} but for {@link Text} the text must be
+     * non-empty).
+     */
+    public static boolean _isVisible(Component component) {
+        if (component instanceof Text) {
+            // workaround for https://github.com/vaadin/flow/issues/3201
+            String text = ((Text) component).getText();
+            return text != null && !text.isBlank();
+        }
+        return component.isVisible();
+    }
+
+    /**
+     * Returns direct text contents (it doesn't peek into the child elements).
+     */
+    public static String _text(Component component) {
+        if (component instanceof HasText) {
+            return ((HasText) component).getText();
+        }
+        return null;
+    }
+
+    /**
+     * Checks that a component is actually editable by the user: * The component
+     * must be effectively visible: it itself must be visible, its parent must
+     * be visible and all of its ascendants must be visible. For the purpose of
+     * testing individual components not attached to the {@link UI}, a component
+     * may be considered visible even though it's not currently nested in a
+     * {@link UI}. * The component must be effectively enabled: it itself must
+     * be enabled, its parent must be enabled and all of its ascendants must be
+     * enabled. * If the component is {@link HasValue}, it must not be
+     * {@link HasValue#isReadOnly}.
+     * 
+     * @throws IllegalStateException
+     *             if any of the above doesn't hold.
+     */
+    public static void checkEditableByUser(Component component) {
+        if (!isEffectivelyVisible(component)) {
+            throw new IllegalStateException("The "
+                    + PrettyPrintTreeKt.toPrettyString(component)
+                    + " is not effectively visible - either it is hidden, or its ascendant is hidden");
+        }
+        boolean parentNullOrEnabled = !component.getParent().isPresent()
+                || isEffectivelyEnabled(component.getParent().get());
+        if (parentNullOrEnabled) {
+            if (!component.getElement().isEnabled()) {
+                throw new IllegalStateException(
+                        "The " + PrettyPrintTreeKt.toPrettyString(component)
+                                + " is not enabled");
+            }
+        }
+        if (!isEffectivelyEnabled(component)) {
+            throw new IllegalStateException(
+                    "The " + PrettyPrintTreeKt.toPrettyString(component)
+                            + " is nested in a disabled component");
+        }
+        if (component instanceof HasValue) {
+            @SuppressWarnings({ "unchecked", "rawtypes" })
+            HasValue<HasValue.ValueChangeEvent<Object>, Object> hasValue = (HasValue) component;
+            if (hasValue.isReadOnly()) {
+                throw new IllegalStateException(
+                        "The " + PrettyPrintTreeKt.toPrettyString(component)
+                                + " is read-only");
+            }
+        }
+        if (!component.isAttached()) {
+            throw new IllegalStateException(
+                    " The " + PrettyPrintTreeKt.toPrettyString(component)
+                            + " is not attached");
+        }
+    }
+
+    /**
+     * Fails if the component is editable. See {@link #checkEditableByUser} for
+     * more details.
+     * 
+     * @throws AssertionError
+     *             if the component is editable.
+     */
+    public static void expectNotEditableByUser(Component component) {
+        try {
+            checkEditableByUser(component);
+        } catch (IllegalStateException ex) {
+            // okay
+            return;
+        }
+        throw new AssertionError("The "
+                + PrettyPrintTreeKt.toPrettyString(component) + " is editable");
+    }
+
+    static boolean isEffectivelyVisible(Component component) {
+        return _isVisible(component) && (!component.getParent().isPresent()
+                || isEffectivelyVisible(component.getParent().get()));
+    }
+
+    /**
+     * Computes whether this component and all of its parents are enabled.
+     *
+     * Recursively checks that all ancestors are also enabled (the "implicitly
+     * disabled" effect, see {@link HasEnabled#isEnabled} javadoc for more
+     * details).
+     *
+     * Also check that the component is not inert due to there being a modal
+     * component.
+     *
+     * @return false if this component or any of its parent is disabled or is
+     *         inert.
+     */
+    public static boolean isEffectivelyEnabled(Component component) {
+        return component.getElement().isEnabled()
+                && !component.getElement().getNode().isInert();
+    }
+
+    /**
+     * Fires {@link FocusNotifier.FocusEvent} on the component, but only if it's
+     * editable.
+     */
+    public static <T extends Component & Focusable<T>> void _focus(
+            T component) {
+        checkEditableByUser(component);
+        _fireEvent(component,
+                new FocusNotifier.FocusEvent<>(component, true, null));
+    }
+
+    /**
+     * Fires {@link BlurNotifier.BlurEvent} on the component, but only if it's
+     * editable.
+     */
+    public static <T extends Component & Focusable<T>> void _blur(T component) {
+        checkEditableByUser(component);
+        _fireEvent(component,
+                new BlurNotifier.BlurEvent<>(component, true, null));
+    }
+
+    /**
+     * Closes the UI and simulates the end of the request. The {@link UI#close}
+     * is called, but also the session is set to null which fires the detach
+     * listeners and makes the UI and all of its components detached.
+     */
+    public static void _close(UI ui) {
+        ui.close();
+        // Mock closing of UI after request handled.
+        VaadinSession.getCurrent().removeUI(ui);
+    }
+
+    /**
+     * Returns child components which were added to this component via
+     * {@code com.vaadin.flow.dom.Element.appendVirtualChild}.
+     */
+    public static List<Component> _getVirtualChildren(Component component) {
+        List<Component> result = new ArrayList<>();
+        for (Element child : ElementUtils
+                .getVirtualChildren(component.getElement())) {
+            result.addAll(ElementUtils._findComponents(child));
+        }
+        return result;
+    }
+
+    static String errorMessage(InternalServerError error) {
+        return error.getElement().getText();
+    }
+
+    public static int _saneFetchLimit() {
+        // don't use high value otherwise Vaadin 19+ will calculate negative
+        // limit and will pass it to SizeVerifier,
+        // failing instantly.
+        return Integer.MAX_VALUE / 1000;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java
new file mode 100644
index 00000000..298a0460
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java
@@ -0,0 +1,608 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import com.vaadin.flow.component.ClickEvent;
+import com.vaadin.flow.component.ClickNotifier;
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.ComponentEvent;
+import com.vaadin.flow.component.ComponentUtil;
+import com.vaadin.flow.component.HasComponents;
+import com.vaadin.flow.component.HasElement;
+import com.vaadin.flow.component.HasOrderedComponents;
+import com.vaadin.flow.component.HasPlaceholder;
+import com.vaadin.flow.component.HasStyle;
+import com.vaadin.flow.component.HasText;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.checkbox.Checkbox;
+import com.vaadin.flow.component.checkbox.CheckboxGroup;
+import com.vaadin.flow.component.combobox.ComboBox;
+import com.vaadin.flow.component.confirmdialog.ConfirmDialog;
+import com.vaadin.flow.component.contextmenu.ContextMenuBase;
+import com.vaadin.flow.component.datepicker.DatePicker;
+import com.vaadin.flow.component.dialog.Dialog;
+import com.vaadin.flow.component.formlayout.FormLayout;
+import com.vaadin.flow.component.grid.Grid;
+import com.vaadin.flow.component.listbox.ListBoxBase;
+import com.vaadin.flow.component.login.LoginOverlay;
+import com.vaadin.flow.component.notification.Notification;
+import com.vaadin.flow.component.radiobutton.RadioButtonGroup;
+import com.vaadin.flow.component.select.Select;
+import com.vaadin.flow.component.sidenav.SideNav;
+import com.vaadin.flow.component.sidenav.SideNavItem;
+import com.vaadin.flow.component.textfield.PasswordField;
+import com.vaadin.flow.component.textfield.TextArea;
+import com.vaadin.flow.component.textfield.TextField;
+import com.vaadin.flow.data.provider.DataProvider;
+import com.vaadin.flow.dom.DomEventListener;
+import com.vaadin.flow.dom.DomListenerRegistration;
+import com.vaadin.flow.dom.Element;
+import com.vaadin.flow.router.Location;
+
+/**
+ * Helpers for reading and writing the component properties a lookup needs, and
+ * for walking the component tree.
+ * <p>
+ * Much of this exists because Flow spreads one concept over several unrelated
+ * interfaces: a placeholder or a label is declared separately on every
+ * component that has one, so {@link #placeholder(Component)} and
+ * {@link #label(Component)} resolve it wherever it happens to live. The rest
+ * fills gaps Flow leaves open, such as splitting a whitespace-separated class
+ * name list.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class ComponentUtils {
+
+    private ComponentUtils() {
+    }
+
+    /**
+     * Fires given event on the component.
+     */
+    public static void fireEvent(Component component, ComponentEvent<?> event) {
+        ComponentUtil.fireEvent(component, event);
+    }
+
+    /**
+     * Adds {@code com.vaadin.flow.component.button.Button.click} functionality
+     * to all {@link ClickNotifier}s. This function directly calls all click
+     * listeners, thus it avoids the roundtrip to client and back. It even works
+     * with browserless testing.
+     */
+    public static <T extends ClickNotifier<?>> void serverClick(T notifier) {
+        serverClick(notifier, true, 0, 1, false, false, false, false);
+    }
+
+    public static <T extends ClickNotifier<?>> void serverClick(T notifier,
+            boolean fromClient, int button, int clickCount, boolean shiftKey,
+            boolean ctrlKey, boolean altKey, boolean metaKey) {
+        Component component = (Component) notifier;
+        fireEvent(component, new ClickEvent<>(component, fromClient, -1, -1, -1,
+                -1, clickCount, button, ctrlKey, shiftKey, altKey, metaKey));
+    }
+
+    /**
+     * Sets the alignment of the text in the component. One of `center`, `left`,
+     * `right`, `justify`.
+     */
+    public static String textAlign(Component component) {
+        return component.getElement().getStyle().get("textAlign");
+    }
+
+    public static void textAlign(Component component, String value) {
+        component.getElement().getStyle().set("textAlign", value);
+    }
+
+    /**
+     * Sets or removes the `title` attribute on component's element.
+     */
+    public static String tooltip(Component component) {
+        return component.getElement().getAttribute("title");
+    }
+
+    public static void tooltip(Component component, String value) {
+        ElementUtils.setOrRemoveAttribute(component.getElement(), "title",
+                value);
+    }
+
+    /**
+     * Adds the right-click (context-menu) {@code listener} to the component.
+     * Also causes the right-click browser menu not to be shown on this
+     * component (see {@link #preventDefault}).
+     */
+    public static DomListenerRegistration addContextMenuListener(
+            Component component, DomEventListener listener) {
+        return preventDefault(component.getElement()
+                .addEventListener("contextmenu", listener));
+    }
+
+    /**
+     * Makes the client-side listener call <a href=
+     * "https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault">Event.preventDefault()</a>
+     * on the event.
+     *
+     * @return this
+     */
+    public static DomListenerRegistration preventDefault(
+            DomListenerRegistration registration) {
+        return registration.addEventData("event.preventDefault()");
+    }
+
+    /**
+     * Removes the component from its parent. Does nothing if the component is
+     * not attached to a parent.
+     */
+    public static void removeFromParent(Component component) {
+        Component parent = component.getParent().orElse(null);
+        if (parent instanceof HasComponents) {
+            ((HasComponents) parent).remove(component);
+        }
+    }
+
+    /**
+     * Finds component's parent, parent's parent (etc) which satisfies given
+     * {@code predicate}. Returns null if there is no such parent.
+     */
+    public static Component findAncestor(Component component,
+            Predicate<Component> predicate) {
+        return findAncestorOrSelf(component,
+                c -> c != component && predicate.test(c));
+    }
+
+    /**
+     * Finds component, component's parent, parent's parent (etc) which
+     * satisfies given {@code predicate}. Returns null if no component on the
+     * ancestor-or-self axis satisfies.
+     */
+    public static Component findAncestorOrSelf(Component component,
+            Predicate<Component> predicate) {
+        Component current = component;
+        while (current != null) {
+            if (predicate.test(current)) {
+                return current;
+            }
+            current = current.getParent().orElse(null);
+        }
+        return null;
+    }
+
+    /**
+     * Checks if this component is nested in {@code potentialAncestor}.
+     */
+    public static boolean isNestedIn(Component component,
+            Component potentialAncestor) {
+        return findAncestor(component, c -> c == potentialAncestor) != null;
+    }
+
+    /**
+     * Checks whether this component is currently attached to a {@link UI}.
+     *
+     * Returns true for attached components even if the UI itself is closed.
+     */
+    public static boolean isAttached(Component component) {
+        // see https://github.com/vaadin/flow/issues/7911
+        return component.getElement().getNode().isAttached();
+    }
+
+    /**
+     * Returns the data provider currently set to this Component.
+     *
+     * Works both with Vaadin 16 and Vaadin 17: Vaadin 17 components no longer
+     * implement HasItems.
+     */
+    public static DataProvider<?, ?> dataProvider(Component component) {
+        try {
+            // until https://github.com/vaadin/flow/issues/6296 is resolved
+            if (component instanceof Grid) {
+                return ((Grid<?>) component).getDataProvider();
+            }
+            if (component instanceof Select) {
+                return ((Select<?>) component).getDataProvider();
+            }
+            if (component instanceof ListBoxBase) {
+                return (DataProvider<?, ?>) _ListBoxBase_getDataProvider
+                        .invoke(component);
+            }
+            if (component instanceof RadioButtonGroup) {
+                return (DataProvider<?, ?>) _RadioButtonGroup_getDataProvider
+                        .invoke(component);
+            }
+            if (component instanceof CheckboxGroup) {
+                return (DataProvider<?, ?>) _CheckboxGroup_getDataProvider
+                        .invoke(component);
+            }
+            if (component instanceof ComboBox) {
+                return ((ComboBox<?>) component).getDataProvider();
+            }
+            return null;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Inserts this component as a child, right before an {@code existing} one.
+     *
+     * In case the specified component has already been added to another parent,
+     * it will be removed from there and added to this one.
+     */
+    public static void insertBefore(HasOrderedComponents container,
+            Component newComponent, Component existing) {
+        Component parent = existing.getParent().orElse(null);
+        if (parent == null) {
+            throw new IllegalArgumentException(existing + " has no parent");
+        }
+        if (parent != container) {
+            throw new IllegalArgumentException(
+                    existing + " is not nested in " + container);
+        }
+        container.addComponentAtIndex(container.indexOf(existing),
+                newComponent);
+    }
+
+    /**
+     * Return the location of the currently shown view. The function will report
+     * the current (old) view in {@code com.vaadin.flow.router.BeforeLeaveEvent}
+     * and {@code com.vaadin.flow.router.BeforeEnterEvent}.
+     */
+    public static Location currentViewLocation(UI ui) {
+        return ui.getInternals().getActiveViewLocation();
+    }
+
+    /**
+     * True when the component has any children.
+     */
+    public static boolean hasChildren(HasComponents container) {
+        return ((Component) container).getChildren().findFirst().isPresent();
+    }
+
+    /**
+     * Splits {@code classNames} by whitespaces to obtain individual class
+     * names, then calls {@link HasStyle#addClassName} on each class name. Does
+     * nothing if the string is blank.
+     */
+    public static void addClassNames2(HasStyle target, String classNames) {
+        // workaround for https://github.com/vaadin/flow/issues/11709
+        for (String name : Utils.splitByWhitespaces(classNames)) {
+            target.addClassName(name);
+        }
+    }
+
+    /**
+     * Splits {@code classNames} by whitespaces to obtain individual class
+     * names, then calls {@link #addClassNames2} on each class name. Does
+     * nothing if the string is blank.
+     */
+    public static void addClassNames2(HasStyle target, String... classNames) {
+        // workaround for https://github.com/vaadin/flow/issues/11709
+        for (String c : classNames) {
+            addClassNames2(target, c);
+        }
+    }
+
+    /**
+     * Splits {@code classNames} by whitespaces to obtain individual class
+     * names, then calls {@link HasStyle#removeClassName} on each class name.
+     * Does nothing if the string is blank.
+     */
+    public static void removeClassNames2(HasStyle target, String classNames) {
+        // workaround for https://github.com/vaadin/flow/issues/11709
+        for (String name : Utils.splitByWhitespaces(classNames)) {
+            target.removeClassName(name);
+        }
+    }
+
+    /**
+     * Splits {@code classNames} by whitespaces to obtain individual class
+     * names, then calls {@link #removeClassNames2} on each class name. Does
+     * nothing if the string is blank.
+     */
+    public static void removeClassNames2(HasStyle target,
+            String... classNames) {
+        // workaround for https://github.com/vaadin/flow/issues/11709
+        for (String c : classNames) {
+            removeClassNames2(target, c);
+        }
+    }
+
+    /**
+     * Splits {@code classNames} by whitespaces to obtain individual class
+     * names, then clears the class names and calls {@link #addClassNames2} on
+     * each class name. Does nothing if the string is blank.
+     */
+    public static void setClassNames2(HasStyle target, String classNames) {
+        // workaround for https://github.com/vaadin/flow/issues/11709
+        target.getStyle().clear();
+        addClassNames2(target, classNames);
+    }
+
+    /**
+     * Splits {@code classNames} by whitespaces to obtain individual class
+     * names, then clears the class names and calls {@link #addClassNames2} on
+     * each class name. Does nothing if the string is blank.
+     */
+    public static void setClassNames2(HasStyle target, String... classNames) {
+        // workaround for https://github.com/vaadin/flow/issues/11709
+        target.getStyle().clear();
+        addClassNames2(target, classNames);
+    }
+
+    /**
+     * A component placeholder, usually shown when there's no value selected.
+     * Not all components support a placeholder; those that don't will return
+     * null.
+     */
+    public static String placeholder(Component component) {
+        // modify when this is fixed: https://github.com/vaadin/flow/issues/4068
+        if (component instanceof TextField) {
+            return ((TextField) component).getPlaceholder();
+        }
+        if (component instanceof TextArea) {
+            return ((TextArea) component).getPlaceholder();
+        }
+        if (component instanceof PasswordField) {
+            return ((PasswordField) component).getPlaceholder();
+        }
+        if (component instanceof ComboBox) {
+            return ((ComboBox<?>) component).getPlaceholder();
+        }
+        if (component instanceof DatePicker) {
+            return ((DatePicker) component).getPlaceholder();
+        }
+        if (component instanceof HasPlaceholder) {
+            return ((HasPlaceholder) component).getPlaceholder();
+        }
+        return null;
+    }
+
+    public static void placeholder(Component component, String value) {
+        if (component instanceof TextField) {
+            ((TextField) component).setPlaceholder(value);
+        } else if (component instanceof TextArea) {
+            ((TextArea) component).setPlaceholder(value);
+        } else if (component instanceof PasswordField) {
+            ((PasswordField) component).setPlaceholder(value);
+        } else if (component instanceof ComboBox) {
+            ((ComboBox<?>) component).setPlaceholder(value);
+        } else if (component instanceof DatePicker) {
+            ((DatePicker) component).setPlaceholder(value);
+        } else if (component instanceof HasPlaceholder) {
+            ((HasPlaceholder) component).setPlaceholder(value);
+        } else {
+            throw new IllegalStateException(component.getClass().getSimpleName()
+                    + " doesn't support setting placeholder");
+        }
+    }
+
+    /**
+     * Concatenates texts from all elements placed in the `label` slot. This
+     * effectively returns whatever was provided in the String label via
+     * {@link FormLayout#addFormItem}.
+     */
+    public static String label(FormLayout.FormItem item) {
+        List<Component> captions = item.getChildren().filter(
+                c -> "label".equals(c.getElement().getAttribute("slot")))
+                .collect(Collectors.toList());
+        StringBuilder sb = new StringBuilder();
+        for (Component c : captions) {
+            if (c instanceof HasText) {
+                String text = ((HasText) c).getText();
+                if (text != null) {
+                    sb.append(text);
+                }
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * The `HasLabel` interface has been introduced in Vaadin 21 but is missing
+     * in Vaadin 14. Use reflection.
+     */
+    private static final Class<?> _HasLabel = Utils
+            .findClass("com.vaadin.flow.component.HasLabel");
+    private static final Method _HasLabel_getLabel;
+    private static final Method _HasLabel_setLabel;
+    static {
+        Method get = null;
+        Method set = null;
+        if (_HasLabel != null) {
+            try {
+                get = _HasLabel.getDeclaredMethod("getLabel");
+                set = _HasLabel.getDeclaredMethod("setLabel", String.class);
+            } catch (NoSuchMethodException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        _HasLabel_getLabel = get;
+        _HasLabel_setLabel = set;
+    }
+
+    /**
+     * Determines the component's `label` (usually it's the HTML element's
+     * `label` property, but it's {@link Checkbox#getLabel} for checkbox).
+     * Intended to be used for fields such as {@link TextField}.
+     *
+     * *For `FormItem`:* Concatenates texts from all elements placed in the
+     * `label` slot. This effectively returns whatever was provided in the
+     * String label via {@link FormLayout#addFormItem}.
+     *
+     * {@link Button#caption} is displayed directly on the component while label
+     * is displayed next to the component in a layout (e.g. a {@link TextField}
+     * nested in a form layout).
+     *
+     * Vote for <a href="https://github.com/vaadin/flow/issues/3241">issue
+     * #3241</a>.
+     *
+     * **WARNING:** the label is displayed by the component itself, rather than
+     * by the parent layout. If a component doesn't contain necessary machinery
+     * to display a label, setting this property will have no visual effect. For
+     * example, setting a label to a {@link FormLayout} nested within a
+     * `VerticalLayout` will show nothing since {@link FormLayout} doesn't
+     * display a label itself. See {@code LabelWrapper} for a list of possible
+     * solutions.
+     */
+    public static String label(Component component) {
+        try {
+            if (_HasLabel != null && _HasLabel.isInstance(component)) {
+                String value = (String) _HasLabel_getLabel.invoke(component);
+                return value == null ? "" : value;
+            }
+            if (component instanceof Checkbox) {
+                String v = ((Checkbox) component).getLabel();
+                return v == null ? "" : v;
+            }
+            if (component instanceof FormLayout.FormItem) {
+                return label((FormLayout.FormItem) component);
+            }
+            if (component instanceof SideNav) {
+                String v = ((SideNav) component).getLabel();
+                return v == null ? "" : v;
+            }
+            if (component instanceof SideNavItem) {
+                String v = ((SideNavItem) component).getLabel();
+                return v == null ? "" : v;
+            }
+            String v = component.getElement().getProperty("label");
+            return v == null ? "" : v;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void label(Component component, String value) {
+        try {
+            if (_HasLabel != null && _HasLabel.isInstance(component)) {
+                _HasLabel_setLabel.invoke(component, value);
+            } else if (component instanceof Checkbox) {
+                ((Checkbox) component).setLabel(value);
+            } else if (component instanceof FormLayout.FormItem) {
+                throw new IllegalArgumentException(
+                        "Setting the caption of FormItem is currently unsupported");
+            } else if (component instanceof SideNav) {
+                ((SideNav) component).setLabel(value);
+            } else if (component instanceof SideNavItem) {
+                ((SideNavItem) component).setLabel(value);
+            } else {
+                component.getElement().setProperty("label",
+                        value == null || value.isBlank() ? null : value);
+            }
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * The Component's caption: {@link Button#getText} for {@link Button},
+     * {@code label} for fields such as {@link TextField}.
+     *
+     * Caption is generally displayed directly on the component (e.g. the Button
+     * text), while {@code label} is displayed next to the component in a layout
+     * (e.g. a {@link TextField} nested in a form layout).
+     *
+     * **Deprecated:** this property was intended to unify captions and labels,
+     * but only managed to create confusion between the two concepts. Also,
+     * there's only a {@link Button} which has the notion of a caption. Will be
+     * removed with no replacement.
+     */
+    @Deprecated
+    public static String caption(Component component) {
+        if (component instanceof Button) {
+            return ((Button) component).getText();
+        }
+        return label(component);
+    }
+
+    @Deprecated
+    public static void caption(Component component, String value) {
+        if (component instanceof Button) {
+            ((Button) component).setText(value);
+        } else {
+            label(component, value);
+        }
+    }
+
+    /**
+     * Sets up an event listener for overlay components that fires a `closed`
+     * DOM event when the component is closed. This simulates the event being
+     * fired from the browser after the closing animation has finished.
+     */
+    public static void simulateClosedEvent(Component component) {
+        if (ComponentUtil.getData(component,
+                "hasSimulatedClosedEvent") != null) {
+            return;
+        }
+        if (component instanceof Dialog || component instanceof ConfirmDialog
+                || component instanceof LoginOverlay
+                || component instanceof ContextMenuBase
+                || component instanceof Notification) {
+            ComponentUtil.setData(component, "hasSimulatedClosedEvent", true);
+            component.getElement().addPropertyChangeListener("opened",
+                    event -> {
+                        if (Boolean.FALSE.equals(event.getValue())) {
+                            BasicUtils._fireDomEvent(component, "closed");
+                        }
+                    });
+        }
+    }
+
+    static Component getChildComponentInSlot(HasElement parent,
+            String slotName) {
+        return ElementUtils.getChildrenInSlot(parent.getElement(), slotName)
+                .stream().findFirst().flatMap(Element::getComponent)
+                .orElse(null);
+    }
+
+    static void setChildComponentToSlot(HasElement parent, String slotName,
+            Component component) {
+        ElementUtils.clearSlot(parent.getElement(), slotName);
+        if (component != null) {
+            component.getElement().setAttribute("slot", slotName);
+            parent.getElement().appendChild(component.getElement());
+        }
+    }
+
+    static boolean isPolymerTemplate(Component component) {
+        return Utils.polymerTemplateClass != null && Utils.polymerTemplateClass
+                .isAssignableFrom(component.getClass());
+    }
+
+    private static final Method _ListBoxBase_getDataProvider;
+    private static final Method _CheckboxGroup_getDataProvider;
+    private static final Method _RadioButtonGroup_getDataProvider;
+    static {
+        try {
+            _ListBoxBase_getDataProvider = ListBoxBase.class
+                    .getDeclaredMethod("getDataProvider");
+            _ListBoxBase_getDataProvider.setAccessible(true);
+            _CheckboxGroup_getDataProvider = CheckboxGroup.class
+                    .getDeclaredMethod("getDataProvider");
+            _CheckboxGroup_getDataProvider.setAccessible(true);
+            _RadioButtonGroup_getDataProvider = RadioButtonGroup.class
+                    .getDeclaredMethod("getDataProvider");
+            _RadioButtonGroup_getDataProvider.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java b/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java
new file mode 100644
index 00000000..79030a2d
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import com.vaadin.flow.component.Component;
+
+/**
+ * Walks the child tree, depth-first: first the node, then its descendants,
+ * then its next sibling.
+ */
+/**
+ * Walks a tree depth-first: a node, then its descendants, then its next
+ * sibling.
+ * <p>
+ * The traversal order is what makes a component tree dump and a lookup failure
+ * message readable, because it matches the order the components appear in.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ *
+ * @param <T>
+ *            the node type
+ */
+public class DepthFirstTreeIterator<T> implements Iterator<T> {
+
+    private final Deque<T> queue;
+    private final Function<T, List<T>> children;
+
+    /**
+     * @param root
+     *            start here.
+     * @param children
+     *            fetches children of given node.
+     */
+    public DepthFirstTreeIterator(T root, Function<T, List<T>> children) {
+        this.children = children;
+        this.queue = new ArrayDeque<>();
+        this.queue.push(root);
+    }
+
+    @Override
+    public boolean hasNext() {
+        return !queue.isEmpty();
+    }
+
+    @Override
+    public T next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        T result = queue.pop();
+        List<T> kids = children.apply(result);
+        ListIterator<T> it = kids.listIterator(kids.size());
+        while (it.hasPrevious()) {
+            queue.push(it.previous());
+        }
+        return result;
+    }
+
+    /**
+     * Walks the component child tree, depth-first: first the component, then
+     * its descendants, then its next sibling.
+     */
+    public static Iterable<Component> walk(Component root) {
+        return () -> new DepthFirstTreeIterator<>(root, component -> component
+                .getChildren().collect(Collectors.toList()));
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java
new file mode 100644
index 00000000..d2c55775
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Node;
+import org.jsoup.nodes.TextNode;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.ComponentUtil;
+import com.vaadin.flow.dom.ClassList;
+import com.vaadin.flow.dom.DomEvent;
+import com.vaadin.flow.dom.Element;
+import com.vaadin.flow.dom.ElementUtil;
+import com.vaadin.flow.internal.StateNode;
+import com.vaadin.flow.internal.nodefeature.ElementListenerMap;
+import com.vaadin.flow.internal.nodefeature.VirtualChildrenList;
+
+/**
+ * Helpers for the element tree underneath the components: slots, virtual
+ * children, class lists and DOM events.
+ * <p>
+ * A lookup cannot rely on {@code Component.getChildren()} alone, because a
+ * component may keep parts of itself in a slot or as a virtual child. These
+ * helpers reach those, and fire DOM events the way the client would.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class ElementUtils {
+
+    private ElementUtils() {
+    }
+
+    /**
+     * Either calls {@link Element#setAttribute} (if the {@code value} is not
+     * null), or {@link Element#removeAttribute} (if the {@code value} is null).
+     * 
+     * @param attribute
+     *            the name of the attribute.
+     */
+    public static void setOrRemoveAttribute(Element element, String attribute,
+            String value) {
+        if (value == null) {
+            element.removeAttribute(attribute);
+        } else {
+            element.setAttribute(attribute, value);
+        }
+    }
+
+    /**
+     * Toggles {@code className} - removes it if it was there, or adds it if it
+     * wasn't there.
+     * 
+     * @param className
+     *            the class name to toggle, cannot contain spaces.
+     */
+    public static void toggle(ClassList classList, String className) {
+        if (Utils.containsWhitespace(className)) {
+            throw new IllegalArgumentException(
+                    "'" + className + "' cannot contain whitespace");
+        }
+        classList.set(className, !classList.contains(className));
+    }
+
+    /**
+     * Inserts {@code newNode} as a child, right before an {@code existingNode}.
+     * A counterpart for JavaScript DOM `Node.insertBefore()`.
+     */
+    public static void insertBefore(Element parent, Element newNode,
+            Element existingNode) {
+        Element existingParent = existingNode.getParent();
+        if (existingParent == null) {
+            throw new IllegalArgumentException(
+                    existingNode + " has no parent element");
+        }
+        if (!existingParent.equals(parent)) {
+            throw new IllegalArgumentException(
+                    existingNode + " is not nested in " + parent);
+        }
+        parent.insertChild(parent.indexOfChild(existingNode), newNode);
+    }
+
+    /**
+     * This function actually works, as opposed to
+     * {@link Element#getTextRecursively}.
+     */
+    public static String textRecursively2(Element element) {
+        // remove when this is fixed: https://github.com/vaadin/flow/issues/3668
+        Node node = ElementUtil.toJsoup(new Document(""), element);
+        return textRecursively(node);
+    }
+
+    public static String textRecursively(Node node) {
+        if (node instanceof TextNode) {
+            return ((TextNode) node).text();
+        }
+        StringBuilder sb = new StringBuilder();
+        for (Node child : node.childNodes()) {
+            sb.append(textRecursively(child));
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Returns all virtual child elements added via
+     * {@link Element#appendVirtualChild}.
+     */
+    public static List<Element> getVirtualChildren(Element element) {
+        if (element.getNode().hasFeature(VirtualChildrenList.class)) {
+            VirtualChildrenList virtualChildrenList = element.getNode()
+                    .getFeatureIfInitialized(VirtualChildrenList.class)
+                    .orElse(null);
+            if (virtualChildrenList != null) {
+                List<Element> result = new ArrayList<>();
+                Iterator<StateNode> it = virtualChildrenList.iterator();
+                while (it.hasNext()) {
+                    result.add(Element.get(it.next()));
+                }
+                return result;
+            }
+        }
+        return List.of();
+    }
+
+    /**
+     * Gets the element mapped to the given state node.
+     */
+    public static Element element(StateNode node) {
+        return Element.get(node);
+    }
+
+    /**
+     * Returns child elements with the `slot` attribute set to given
+     * {@code slotName}.
+     */
+    public static List<Element> getChildrenInSlot(Element element,
+            String slotName) {
+        return element.getChildren()
+                .filter(child -> slotName.equals(child.getAttribute("slot")))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Removes all child elements from given slot, leaving it empty.
+     */
+    public static void clearSlot(Element element, String slotName) {
+        if (slotName == null || slotName.isBlank()) {
+            throw new IllegalArgumentException();
+        }
+        for (Element child : getChildrenInSlot(element, slotName)) {
+            child.removeFromParent();
+        }
+    }
+
+    /**
+     * Returns all components that are closest to {@code this} element.
+     */
+    public static List<Component> _findComponents(Element element) {
+        List<Component> components = new ArrayList<>();
+        ComponentUtil.findComponents(element, components::add);
+        return components;
+    }
+
+    /**
+     * Fires a DOM {@code event} on this element.
+     */
+    public static void _fireDomEvent(Element element, DomEvent event) {
+        element.getNode().getFeature(ElementListenerMap.class).fireEvent(event);
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java b/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
new file mode 100644
index 00000000..1a7d5fc0
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import org.jsoup.Jsoup;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.data.renderer.BasicRenderer;
+import com.vaadin.flow.data.renderer.ComponentRenderer;
+import com.vaadin.flow.data.renderer.Renderer;
+import com.vaadin.flow.data.renderer.TextRenderer;
+import com.vaadin.flow.function.ValueProvider;
+
+/**
+ * Renders a {@link com.vaadin.flow.data.renderer.Renderer} server-side, as
+ * close as possible to what the client would show.
+ * <p>
+ * This is what lets a test assert on a rendered grid cell without a browser.
+ * Each renderer kind needs its own route to the value: a basic renderer formats
+ * it, a component renderer builds the component, and a Lit renderer has its
+ * template expression interpolated and the resulting HTML stripped to text.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class Renderers {
+
+    private Renderers() {
+    }
+
+    private static final Method _BasicRenderer_getFormattedValue;
+    private static final Field _BasicRenderer_valueProvider;
+    private static final Field _Renderer_template;
+
+    static {
+        try {
+            Method m = null;
+            for (Method candidate : BasicRenderer.class.getDeclaredMethods()) {
+                if (candidate.getName().equals("getFormattedValue")) {
+                    m = candidate;
+                    break;
+                }
+            }
+            if (m == null) {
+                throw new NoSuchMethodException("getFormattedValue");
+            }
+            m.setAccessible(true);
+            _BasicRenderer_getFormattedValue = m;
+
+            Field valueProviderField = BasicRenderer.class
+                    .getDeclaredField("valueProvider");
+            valueProviderField.setAccessible(true);
+            _BasicRenderer_valueProvider = valueProviderField;
+
+            Field templateField = Renderer.class.getDeclaredField("template");
+            templateField.setAccessible(true);
+            _Renderer_template = templateField;
+        } catch (NoSuchMethodException | NoSuchFieldException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Returns the output of this renderer for given {@code rowObject} formatted
+     * as close as possible to the client-side output.
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> String _getPresentationValue(Renderer<T> renderer,
+            T rowObject) {
+        try {
+            if (renderer instanceof BasicRenderer) {
+                BasicRenderer<T, ?> basicRenderer = (BasicRenderer<T, ?>) renderer;
+                Object value = valueProvider(basicRenderer).apply(rowObject);
+                return (String) _BasicRenderer_getFormattedValue
+                        .invoke(basicRenderer, value);
+            }
+            if (renderer instanceof TextRenderer) {
+                return renderText((TextRenderer<T>) renderer, rowObject);
+            }
+            if (renderer instanceof ComponentRenderer) {
+                ComponentRenderer<?, T> componentRenderer = (ComponentRenderer<?, T>) renderer;
+                Component component = componentRenderer
+                        .createComponent(rowObject);
+                return PrettyPrintTreeKt.toPrettyString(component);
+            }
+            if (renderer.getClass().getSimpleName().equals("LitRenderer")) {
+                // LitRenderer re-declares private members
+                Field templateProperty = renderer.getClass()
+                        .getDeclaredField("templateExpression");
+                templateProperty.setAccessible(true);
+                String templateExpression = (String) templateProperty
+                        .get(renderer);
+
+                Field valueProvidersProperty = renderer.getClass()
+                        .getDeclaredField("valueProviders");
+                valueProvidersProperty.setAccessible(true);
+                Map<String, ValueProvider<T, ?>> valueProviders = (Map<String, ValueProvider<T, ?>>) valueProvidersProperty
+                        .get(renderer);
+
+                String renderedLitTemplateHtml = renderLitTemplate(
+                        templateExpression, valueProviders, rowObject);
+                return ElementUtils
+                        .textRecursively(Jsoup.parse(renderedLitTemplateHtml));
+            }
+            return null;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static <T> String renderLitTemplate(String template,
+            Map<String, ValueProvider<T, ?>> valueProviders, T item) {
+        String renderedTemplate = template;
+        for (Map.Entry<String, ValueProvider<T, ?>> entry : valueProviders
+                .entrySet()) {
+            String placeholder = "${item." + entry.getKey() + "}";
+            if (renderedTemplate.contains(placeholder)) {
+                renderedTemplate = renderedTemplate.replace(placeholder,
+                        String.valueOf(entry.getValue().apply(item)));
+            }
+        }
+        return renderedTemplate;
+    }
+
+    /**
+     * Returns the text rendered for given {@code item}.
+     */
+    public static <T> String renderText(TextRenderer<T> renderer, T item) {
+        return renderer.createComponent(item).getElement().getText();
+    }
+
+    /**
+     * Returns the {@link ValueProvider} set to {@link BasicRenderer}.
+     */
+    @SuppressWarnings("unchecked")
+    public static <T, V> ValueProvider<T, V> valueProvider(
+            BasicRenderer<T, V> renderer) {
+        try {
+            return (ValueProvider<T, V>) _BasicRenderer_valueProvider
+                    .get(renderer);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Returns the Polymer Template set to the {@link Renderer}.
+     */
+    public static String template(Renderer<?> renderer) {
+        try {
+            String template = (String) _Renderer_template.get(renderer);
+            return template != null ? template : "";
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java b/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
new file mode 100644
index 00000000..e92738fc
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import tools.jackson.databind.JsonNode;
+import tools.jackson.databind.node.ObjectNode;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.Key;
+import com.vaadin.flow.component.ShortcutRegistration;
+import com.vaadin.flow.internal.JacksonUtils;
+
+/**
+ * Fires keyboard shortcuts at the current UI.
+ * <p>
+ * A shortcut registration carries a JavaScript filter expression that the
+ * client would evaluate against the key event. There is no client here, so the
+ * event data handed to Flow answers that filter directly: it reports a match
+ * only for the key and modifiers being simulated, which is what makes exactly
+ * the right shortcut listener fire.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class Shortcuts {
+
+    private Shortcuts() {
+    }
+
+    /**
+     * Take a look at `DomEventListenerWrapper.matchesFilter()` to see why this
+     * is necessary. If this stuff stops working, place a breakpoint into the
+     * {@code getBoolean}/{@code hasKey} function, to see what kind of keys
+     * you're receiving and whether it matches {@code filter}.
+     */
+    private static final class MockFilterJsonObject extends ObjectNode {
+
+        private static final Method mgenerateEventKeyFilter;
+        private static final Method mgenerateEventModifierFilter;
+        private static final Constructor<?> chashableKey;
+
+        static {
+            try {
+                mgenerateEventKeyFilter = ShortcutRegistration.class
+                        .getDeclaredMethod("generateEventKeyFilter", Key.class);
+                mgenerateEventModifierFilter = ShortcutRegistration.class
+                        .getDeclaredMethod("generateEventModifierFilter",
+                                java.util.Collection.class);
+                Class<?> hashableKeyClass = ShortcutRegistration.class
+                        .getClassLoader().loadClass(
+                                "com.vaadin.flow.component.ShortcutRegistration$HashableKey");
+                chashableKey = hashableKeyClass.getDeclaredConstructors()[0];
+                mgenerateEventKeyFilter.setAccessible(true);
+                mgenerateEventModifierFilter.setAccessible(true);
+                chashableKey.setAccessible(true);
+            } catch (ReflectiveOperationException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        private final String filter;
+        private String filterString = "";
+
+        MockFilterJsonObject(Key key, Set<Key> modifiers) {
+            super(JacksonUtils.getMapper().getNodeFactory());
+            try {
+                // compute the filter
+                List<Object> hashableModifiers = new ArrayList<>();
+                for (Key modifier : modifiers) {
+                    hashableModifiers.add(chashableKey.newInstance(modifier));
+                }
+                filter = mgenerateEventKeyFilter.invoke(null, key).toString()
+                        + " && " + mgenerateEventModifierFilter
+                                .invoke(null, hashableModifiers).toString();
+
+                // populate the json object so that KeyDownEvent can be created
+                // from it
+                put("event.key", key.getKeys().get(0));
+            } catch (ReflectiveOperationException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        @Override
+        public boolean has(String key) {
+            // the "key" is a JavaScript expression which matches the key
+            // pressed.
+            // we need to match it against the 'filter'
+            if (!key.startsWith("([")) {
+                // not a filter
+                return super.get(key) != null;
+            }
+            return matchesFilter(key);
+        }
+
+        private boolean matchesFilter(String key) {
+            String probeFilter = key;
+            if (probeFilter.endsWith(" && (event.stopPropagation() || true)")) {
+                probeFilter = probeFilter.substring(0, probeFilter.length()
+                        - " && (event.stopPropagation() || true)".length());
+            }
+            if (probeFilter.endsWith(" && (event.preventDefault() || true)")) {
+                probeFilter = probeFilter.substring(0, probeFilter.length()
+                        - " && (event.preventDefault() || true)".length());
+            }
+            return probeFilter.startsWith(filter);
+        }
+
+        @Override
+        public JsonNode get(String keyString) {
+            filterString = keyString;
+            if (keyString.startsWith("([")) {
+                // For filter key we return this so we get the correct matches
+                // for booleanValue as get returns null
+                return this;
+            }
+            return super.get(keyString);
+        }
+
+        @Override
+        public boolean booleanValue() {
+            if (!filterString.startsWith("([")) {
+                return super.booleanValue();
+            }
+            return matchesFilter(filterString);
+        }
+    }
+
+    /**
+     * Fires a shortcut event with given {@code key} and {@code modifiers} in
+     * the current UI. This will in turn notify all components currently
+     * attached to the current UI which subscribed for this exact key
+     * combination.
+     */
+    public static void fireShortcut(Key key, Key... modifiers) {
+        // keep the modifiers of type Key[] instead of KeyModifier[], otherwise
+        // you won't be able to call those from Kotlin:
+        // https://github.com/vaadin/flow/issues/5051
+        // and https://youtrack.jetbrains.com/issue/KT-35021
+        _fireShortcut(Utils.currentUI(), key, modifiers);
+    }
+
+    /**
+     * Use the global `fireShortcut()` function unless you know what you're
+     * doing!
+     */
+    public static void _fireShortcut(Component component, Key key,
+            Key... modifiers) {
+        // all shortcut registration carry a filter with them, in order to
+        // filter out
+        // pressed keys. All the filters are then transferred to the server-side
+        // and compared against DomEventListenerWrapper.filter in
+        // DomEventListenerWrapper.matchesFilter()
+
+        // The `matchesFilter()` function is peculiar: it simply checks whether
+        // the data
+        // contains a boolean value with key 'filter'. We need to fake the json
+        // object
+        // as if it contained all filters (otherwise `matchesFilter()` would NPE
+        // on missing key)
+        // and respond true only to the matching filter.
+        Set<Key> modifierSet = new HashSet<>();
+        for (Key modifier : modifiers) {
+            modifierSet.add(modifier);
+        }
+        MockFilterJsonObject data = new MockFilterJsonObject(key, modifierSet);
+
+        // the shortcut registration is only updated in
+        // [UI.beforeClientResponse]; run the registration code now.
+        MockVaadin.clientRoundtrip();
+
+        // this will fire the "keydown" DOM event, which in turn fires
+        // KeyDownEvent event,
+        // which in turn invokes the ShortcutListener.
+        BasicUtils._fireDomEvent(component, "keydown", data);
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHook.java b/shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHook.java
new file mode 100644
index 00000000..8126d69d
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHook.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.ComponentUtil;
+import com.vaadin.flow.component.Composite;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.contextmenu.MenuItemBase;
+import com.vaadin.flow.component.grid.FooterRow;
+import com.vaadin.flow.component.grid.Grid;
+import com.vaadin.flow.component.grid.HeaderRow;
+import com.vaadin.flow.component.littemplate.LitTemplate;
+import com.vaadin.flow.component.menubar.MenuBar;
+
+/**
+ * The hook a test can implement to take part in the lookup lifecycle, e.g. to
+ * wait for an asynchronous operation to finish before a component is looked up.
+ * Install an implementation through {@link TestingLifecycleHooks#current}.
+ * <h2>Where the server request ends</h2> Browserless Test runs in the same JVM
+ * as the server and there is no browser, so the boundary between one request
+ * and the next is not visible in the source of a test method.
+ * <p>
+ * A test can mark that boundary explicitly by calling
+ * {@link MockVaadin#clientRoundtrip()}, but doing so before every lookup would
+ * be laborious and easy to forget. Instead the environment behaves as if a
+ * client-server round trip happened before every component lookup:
+ * {@link #awaitBeforeLookup()} calls {@code clientRoundtrip()} by default.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public interface TestingLifecycleHook {
+
+    /**
+     * A hook that does nothing beyond the default implementations below.
+     */
+    TestingLifecycleHook DEFAULT = new TestingLifecycleHook() {
+    };
+
+    /**
+     * Invoked before every component lookup, e.g. to wait for an asynchronous
+     * operation to finish and the server to settle down.
+     * <p>
+     * The default implementation calls {@link MockVaadin#clientRoundtrip()}. An
+     * implementation that replaces it should call that too, or call
+     * {@code super}.
+     */
+    default void awaitBeforeLookup() {
+        if (UI.getCurrent() != null) {
+            MockVaadin.clientRoundtrip();
+        }
+    }
+
+    /**
+     * Invoked after every component lookup, e.g. to wait for an asynchronous
+     * operation to finish and the server to settle down. Invoked even when the
+     * lookup itself failed.
+     */
+    default void awaitAfterLookup() {
+    }
+
+    /**
+     * Provides all children of the given component, with workarounds for the
+     * components whose children Flow does not report the way a lookup needs:
+     * <ul>
+     * <li>for a {@link Grid}, the header and footer cell components of all of
+     * its columns, plus the column editor components;</li>
+     * <li>for a {@link MenuItemBase}, all items of its sub-menu.</li>
+     * </ul>
+     *
+     * @param component
+     *            the component whose children to provide
+     * @return the children, never {@code null}
+     */
+    default List<Component> getAllChildren(Component component) {
+        if (component instanceof Grid) {
+            // Header/footer components live as virtual children of the Column
+            // (or ColumnGroup) they belong to, and both of those branches drop
+            // virtual children on purpose: a component in a merged cell is a
+            // virtual child of every column it spans and would otherwise show
+            // up more than once. Collect them here instead, once per Grid.
+            // see https://github.com/mvysny/karibu-testing/issues/52
+            Grid<?> grid = (Grid<?>) component;
+            LinkedHashSet<Component> distinct = new LinkedHashSet<>();
+            grid.getHeaderRows().stream()
+                    .flatMap(row -> row.getCells().stream())
+                    .map(HeaderRow.HeaderCell::getComponent)
+                    .filter(Objects::nonNull).forEach(distinct::add);
+            grid.getFooterRows().stream()
+                    .flatMap(row -> row.getCells().stream())
+                    .map(FooterRow.FooterCell::getComponent)
+                    .filter(Objects::nonNull).forEach(distinct::add);
+            grid.getColumns().stream().map(Grid.Column::getEditorComponent)
+                    .filter(Objects::nonNull).forEach(distinct::add);
+            component.getChildren().forEach(distinct::add);
+            ComponentUtil.getAllChildren(component).forEach(distinct::add);
+            return new ArrayList<>(distinct);
+        }
+        if (component instanceof MenuItemBase) {
+            // also include component.children:
+            // https://github.com/mvysny/karibu-testing/issues/76
+            MenuItemBase<?, ?, ?> menuItem = (MenuItemBase<?, ?, ?>) component;
+            LinkedHashSet<Component> distinct = new LinkedHashSet<>();
+            distinct.addAll(
+                    component.getChildren().collect(Collectors.toList()));
+            distinct.addAll(menuItem.getSubMenu().getItems());
+            return new ArrayList<>(distinct);
+        }
+        if (component instanceof MenuBar) {
+            // don't include virtual children since that would make the
+            // MenuItems appear two times.
+            return component.getChildren().collect(Collectors.toList());
+        }
+        if (isTemplate(component)) {
+            // don't include virtual children since those will include nested
+            // components.
+            // however, those components are only they are only "shallow shells"
+            // of components constructed
+            // server-side - almost none of their properties are transferred to
+            // the server-side.
+            // Listing those components with null captions and other properties
+            // would only be confusing.
+            // Therefore, let's leave the virtual children out for now.
+            // See
+            // https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#polymer-templates--lit-templates
+            return component.getChildren().collect(Collectors.toList());
+        }
+        if ("com.vaadin.flow.component.grid.ColumnGroup"
+                .equals(component.getClass().getName())) {
+            // don't include virtual children since that would include the
+            // header/footer components, which the Grid branch already reports
+            return component.getChildren().collect(Collectors.toList());
+        }
+        if (component instanceof Grid.Column) {
+            // don't include virtual children since that would include the
+            // header/footer components, which the Grid branch already reports
+            return component.getChildren().collect(Collectors.toList());
+        }
+        if (component instanceof Composite) {
+            // The Composite class overrides getChildren() to return a stream
+            // with the wrapped component,
+            // but also getElement() returning the Element of the wrapped
+            // component.
+            // The latter causes the virtual child to be fetched as Composite
+            // direct child,
+            // thus duplicating any virtual children the child component might
+            // have.
+            return component.getChildren().collect(Collectors.toList());
+        }
+        // Union the component's own reported children with Flow's element-tree
+        // traversal. Neither source alone is complete: getChildren() may hide
+        // element children (Dialog and Card exclude slotted content) while
+        // ComponentUtil.getAllChildren, which walks the element hierarchy
+        // (regular and virtual children, descending through non-component
+        // wrapper elements), misses children that are not part of the element
+        // tree (ContextMenu keeps its items in a server-side MenuManager list
+        // that getChildren() delegates to). getAllChildren also keeps virtual
+        // children, see https://github.com/mvysny/karibu-testing/issues/85.
+        LinkedHashSet<Component> distinct = new LinkedHashSet<>();
+        component.getChildren().forEach(distinct::add);
+        ComponentUtil.getAllChildren(component).forEach(distinct::add);
+        return new ArrayList<>(distinct);
+    }
+
+    /**
+     * Tells whether the component is a template, i.e. a Lit or Polymer template
+     * whose children only exist client-side.
+     *
+     * @param component
+     *            the component to check
+     * @return {@code true} if the component is a template
+     */
+    static boolean isTemplate(Component component) {
+        return component instanceof LitTemplate
+                || ComponentUtils.isPolymerTemplate(component);
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHooks.java b/shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHooks.java
new file mode 100644
index 00000000..810a817f
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/TestingLifecycleHooks.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.dialog.Dialog;
+
+/**
+ * Holds the global {@link TestingLifecycleHook} and the lifecycle helpers that
+ * do not belong on the interface itself.
+ * <p>
+ * To hook into the testing lifecycle, e.g. to wait for an asynchronous
+ * operation to finish before a lookup, install an implementation with
+ * {@link #setCurrent(TestingLifecycleHook)}. The hook is global and is
+ * <em>not</em> reset between tests, so a test that installs one has to restore
+ * the previous hook afterwards.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class TestingLifecycleHooks {
+
+    private TestingLifecycleHooks() {
+    }
+
+    private static TestingLifecycleHook current = TestingLifecycleHook.DEFAULT;
+
+    /**
+     * Returns the hook currently in effect. Defaults to
+     * {@link TestingLifecycleHook#DEFAULT}.
+     *
+     * @return the current hook, never {@code null}
+     */
+    public static TestingLifecycleHook getCurrent() {
+        return current;
+    }
+
+    /**
+     * Installs the hook to use for every following lookup.
+     *
+     * @param current
+     *            the hook to install
+     */
+    public static void setCurrent(TestingLifecycleHook current) {
+        TestingLifecycleHooks.current = current;
+    }
+
+    private static final Class<?> _ConfirmDialog_Class = Utils
+            .findClass("com.vaadin.flow.component.confirmdialog.ConfirmDialog");
+
+    private static final Method _ConfirmDialog_isOpened;
+    static {
+        Method m = null;
+        if (_ConfirmDialog_Class != null) {
+            try {
+                m = _ConfirmDialog_Class.getMethod("isOpened");
+            } catch (NoSuchMethodException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        _ConfirmDialog_isOpened = m;
+    }
+
+    /**
+     * Checks whether given {@code component} is a dialog and needs to be
+     * removed from the UI. See {@link #cleanupDialogs} for more info.
+     */
+    private static boolean isDialogAndNeedsRemoval(Component component) {
+        if (component instanceof Dialog && !((Dialog) component).isOpened()) {
+            return true;
+        }
+        // also support ConfirmDialog. But be careful - this is a Pro component
+        // and may not be on classpath.
+        if (_ConfirmDialog_Class != null && _ConfirmDialog_isOpened != null
+                && _ConfirmDialog_Class.isInstance(component)) {
+            try {
+                if (!(Boolean) _ConfirmDialog_isOpened.invoke(component)) {
+                    return true;
+                }
+            } catch (ReflectiveOperationException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Flow Server does not close the dialog when {@link Dialog#close} is
+     * called; instead it tells client-side dialog to close, which then fires
+     * event back to the server that the dialog was closed, and removes itself
+     * from the DOM. Since there's no browser with browserless testing, we need
+     * to cleanup closed dialogs manually, hence this method.
+     */
+    public static void cleanupDialogs() {
+        // Starting with Vaadin 23, nested dialogs are also nested within
+        // respective
+        // modal dialog within the UI. This is probably related to the
+        // "server-side
+        // modality curtain" feature. Also see
+        // https://github.com/mvysny/karibu-testing/issues/102
+        List<Component> toRemove = new ArrayList<>();
+        for (Component c : DepthFirstTreeIterator.walk(UI.getCurrent())) {
+            if (isDialogAndNeedsRemoval(c)) {
+                toRemove.add(c);
+            }
+        }
+        for (Component c : toRemove) {
+            c.getElement().removeFromParent();
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Utils.java b/shared/src/main/java/com/vaadin/browserless/internal/Utils.java
new file mode 100644
index 00000000..3c77514e
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Utils.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import jakarta.servlet.Servlet;
+import jakarta.servlet.ServletContext;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import com.vaadin.browserless.mocks.MockHttpSession;
+import com.vaadin.browserless.mocks.MockRequest;
+import com.vaadin.browserless.mocks.MockResponse;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.internal.ReflectTools;
+import com.vaadin.flow.router.HasErrorParameter;
+import com.vaadin.flow.router.NotFoundException;
+import com.vaadin.flow.server.VaadinContext;
+import com.vaadin.flow.server.VaadinRequest;
+import com.vaadin.flow.server.VaadinResponse;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinServletContext;
+import com.vaadin.flow.server.VaadinServletRequest;
+import com.vaadin.flow.server.VaadinServletResponse;
+import com.vaadin.flow.server.VaadinSession;
+import com.vaadin.flow.server.WrappedHttpSession;
+
+/**
+ * Assorted helpers: reaching the current Vaadin instances, unwrapping them to
+ * the mocks behind them, and loading classes that may not be on the classpath.
+ * <p>
+ * The current-instance accessors fail with an explanatory message rather than
+ * returning {@code null}, because a missing current UI almost always means the
+ * test forgot to set the environment up, and that is worth saying once here
+ * instead of debugging a {@link NullPointerException} at the call site.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class Utils {
+
+    private Utils() {
+    }
+
+    /**
+     * Returns the major JVM version, e.g. 6 for Java 1.6, 8 for Java 8, 11 for
+     * Java 11 etc.
+     */
+    public static int jvmVersion() {
+        return parseJvmVersion(System.getProperty("java.version"));
+    }
+
+    /**
+     * Returns the major JVM version, 1 for 1.1, 2 for 1.2, 3 for 1.3, 4 for
+     * 1.4, 5 for 1.5 etc.
+     */
+    static int parseJvmVersion(String version) {
+        // taken from
+        // https://stackoverflow.com/questions/2591083/getting-java-version-at-runtime
+        String v = version;
+        if (v.startsWith("1.")) {
+            v = v.substring(2);
+        }
+        int end = 0;
+        while (end < v.length() && Character.isDigit(v.charAt(end))) {
+            end++;
+        }
+        return Integer.parseInt(v.substring(0, end));
+    }
+
+    private static final Pattern WHITESPACE = Pattern.compile("\\s+");
+
+    static List<String> splitByWhitespaces(String s) {
+        List<String> result = new ArrayList<>();
+        for (String token : WHITESPACE.split(s)) {
+            if (!token.isBlank()) {
+                result.add(token);
+            }
+        }
+        return result;
+    }
+
+    static boolean containsWhitespace(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            if (Character.isWhitespace(s.charAt(i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static String ellipsize(String s, int maxLength) {
+        return ellipsize(s, maxLength, "...");
+    }
+
+    static String ellipsize(String s, int maxLength, String ellipsize) {
+        if (maxLength < ellipsize.length()) {
+            throw new IllegalArgumentException(
+                    "maxLength must be at least the size of ellipsize "
+                            + ellipsize + " but it was " + maxLength);
+        }
+        if (s.length() <= maxLength || s.length() <= ellipsize.length()) {
+            return s;
+        }
+        return s.substring(0, maxLength - ellipsize.length()) + ellipsize;
+    }
+
+    /**
+     * For a class implementing the {@link HasErrorParameter} interface,
+     * determines the type of the exception handled (the type of `T`). Returns
+     * null if the Class doesn't implement the {@link HasErrorParameter}
+     * interface.
+     */
+    static Class<?> getErrorParameterType(Class<?> clazz) {
+        return ReflectTools.getGenericInterfaceType(clazz,
+                HasErrorParameter.class);
+    }
+
+    static boolean isRouteNotFound(Class<?> clazz) {
+        return getErrorParameterType(clazz) == NotFoundException.class;
+    }
+
+    public static VaadinRequest currentRequest() {
+        VaadinRequest req = VaadinService.getCurrentRequest();
+        if (req == null) {
+            throw new IllegalStateException(
+                    "No current request. Have you called MockVaadin.setup()?");
+        }
+        return req;
+    }
+
+    public static VaadinResponse currentResponse() {
+        VaadinResponse resp = VaadinService.getCurrentResponse();
+        if (resp == null) {
+            throw new IllegalStateException(
+                    "No current response. Have you called MockVaadin.setup()?");
+        }
+        return resp;
+    }
+
+    /**
+     * Returns the {@link UI#getCurrent}; fails with informative error message
+     * if the UI.getCurrent() is null.
+     */
+    public static UI currentUI() {
+        UI ui = UI.getCurrent();
+        if (ui == null) {
+            throw new IllegalStateException(
+                    "UI.getCurrent() is null. Have you called MockVaadin.setup()?");
+        }
+        return ui;
+    }
+
+    /**
+     * Retrieves the mock request which backs up {@link VaadinRequest}. ```
+     * currentRequest.mock.addCookie(Cookie("foo", "bar")) ```
+     */
+    public static MockRequest mock(VaadinRequest request) {
+        return (MockRequest) ((VaadinServletRequest) request).getRequest();
+    }
+
+    /**
+     * Retrieves the mock response which backs up {@link VaadinResponse}. ```
+     * currentResponse.mock.getCookie("foo").value ```
+     */
+    public static MockResponse mock(VaadinResponse response) {
+        return (MockResponse) ((VaadinServletResponse) response).getResponse();
+    }
+
+    /**
+     * Retrieves the mock session which backs up {@link VaadinSession}. ```
+     * VaadinSession.getCurrent().mock ```
+     */
+    public static MockHttpSession mock(VaadinSession session) {
+        return (MockHttpSession) ((WrappedHttpSession) session.getSession())
+                .getHttpSession();
+    }
+
+    public static ServletContext getContext(VaadinContext context) {
+        return ((VaadinServletContext) context).getContext();
+    }
+
+    public static boolean isInitialized(Servlet servlet) {
+        return servlet.getServletConfig() != null;
+    }
+
+    static boolean hasCustomToString(Class<?> clazz) {
+        try {
+            return clazz.getMethod("toString")
+                    .getDeclaringClass() != Object.class;
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    static final Class<?> polymerTemplateClass = findClass(
+            "com.vaadin.flow.component.polymertemplate.PolymerTemplate");
+
+    static boolean hasPolymerTemplates() {
+        return polymerTemplateClass != null;
+    }
+
+    public static Class<?> findClass(String className) {
+        try {
+            return Class.forName(className);
+        } catch (ClassNotFoundException ex) {
+            try {
+                return Class.forName(className, true,
+                        Thread.currentThread().getContextClassLoader());
+            } catch (ClassNotFoundException ex2) {
+                return null;
+            }
+        }
+    }
+
+    public static Class<?> findClassOrThrow(String className)
+            throws ClassNotFoundException {
+        Class<?> clazz = findClass(className);
+        if (clazz == null) {
+            throw new ClassNotFoundException(className);
+        }
+        return clazz;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java
index f49f5404..f3cd85ac 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinHelper.java
@@ -33,7 +33,7 @@
 import tools.jackson.databind.ObjectMapper;
 import tools.jackson.databind.node.ObjectNode;
 
-import com.vaadin.browserless.internal.UtilsKt;
+import com.vaadin.browserless.internal.Utils;
 import com.vaadin.flow.component.geolocation.BrowserlessGeolocationClientFactory;
 import com.vaadin.flow.component.geolocation.GeolocationClientFactory;
 import com.vaadin.flow.di.Lookup;
@@ -171,9 +171,9 @@ public static ObjectNode getTokenFileFromClassloader() {
         Object acf;
         Class<?> dacfClass;
         try {
-            acf = lookup(ctx, UtilsKt.findClassOrThrow(
+            acf = lookup(ctx, Utils.findClassOrThrow(
                     "com.vaadin.flow.server.startup.ApplicationConfigurationFactory"));
-            dacfClass = UtilsKt.findClassOrThrow(
+            dacfClass = Utils.findClassOrThrow(
                     "com.vaadin.flow.server.startup.DefaultApplicationConfigurationFactory");
         } catch (ClassNotFoundException e) {
             throw new RuntimeException(e);
@@ -241,7 +241,7 @@ private static void init(ServletContext ctx, Set<Class<?>> lookupServices) {
         loaders.addAll(lookupServices);
         loaders.add(LookupInitializer.class);
         try {
-            loaders.add(UtilsKt.findClassOrThrow(
+            loaders.add(Utils.findClassOrThrow(
                     "com.vaadin.flow.di.LookupInitializer$ResourceProviderImpl"));
         } catch (ClassNotFoundException e) {
             throw new RuntimeException(e);
@@ -269,7 +269,7 @@ private static void tryLoad(Set<Class<?>> loaders, String className) {
         // sometimes customers don't include entire vaadin-core and exclude
         // stuff like fusion on purpose.
         // load the class only if it exists.
-        Class<?> clazz = UtilsKt.findClass(className);
+        Class<?> clazz = Utils.findClass(className);
         if (clazz != null) {
             loaders.add(clazz);
         }
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
index 5512aaae..61dfe2e5 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
@@ -19,7 +19,7 @@
 import java.lang.reflect.Method;
 import java.util.concurrent.atomic.AtomicReference;
 
-import com.vaadin.browserless.internal.ComponentUtilsKt;
+import com.vaadin.browserless.internal.ComponentUtils;
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.ModalityMode;
 import com.vaadin.flow.component.UI;
@@ -74,7 +74,7 @@ public void setChildComponentModal(Component childComponent,
     public void addToModalComponent(Component component) {
         super.addToModalComponent(component);
         if (component != null) {
-            ComponentUtilsKt.simulateClosedEvent(component);
+            ComponentUtils.simulateClosedEvent(component);
         }
     }
 
diff --git a/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java b/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java
index 598f3159..26db9be0 100644
--- a/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java
@@ -24,7 +24,7 @@
 
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
-import com.vaadin.browserless.internal.BasicUtilsKt;
+import com.vaadin.browserless.internal.BasicUtils;
 import com.vaadin.flow.component.ItemLabelGenerator;
 import com.vaadin.flow.data.provider.DataCommunicator;
 import com.vaadin.flow.function.SerializableConsumer;
@@ -184,8 +184,8 @@ public List<Y> getSuggestionItems() {
 
             final Method fetchFromProvider = getMethod(DataCommunicator.class,
                     "fetchFromProvider", int.class, int.class);
-            List<Y> result = ((Stream<Y>) fetchFromProvider.invoke(
-                    dataCommunicator, 0, BasicUtilsKt.get_saneFetchLimit()))
+            List<Y> result = ((Stream<Y>) fetchFromProvider
+                    .invoke(dataCommunicator, 0, BasicUtils._saneFetchLimit()))
                     .collect(Collectors.toList());
             return result;
         } catch (IllegalAccessException | InvocationTargetException e) {
diff --git a/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java b/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java
index 5a72b22c..2bf7fd00 100644
--- a/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java
@@ -27,7 +27,7 @@
 
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
-import com.vaadin.browserless.internal.BasicUtilsKt;
+import com.vaadin.browserless.internal.BasicUtils;
 import com.vaadin.flow.component.ItemLabelGenerator;
 import com.vaadin.flow.data.provider.DataCommunicator;
 import com.vaadin.flow.function.SerializableConsumer;
@@ -162,8 +162,8 @@ public List<Y> getSuggestionItems() {
 
             final Method fetchFromProvider = getMethod(DataCommunicator.class,
                     "fetchFromProvider", int.class, int.class);
-            List<Y> result = ((Stream<Y>) fetchFromProvider.invoke(
-                    dataCommunicator, 0, BasicUtilsKt.get_saneFetchLimit()))
+            List<Y> result = ((Stream<Y>) fetchFromProvider
+                    .invoke(dataCommunicator, 0, BasicUtils._saneFetchLimit()))
                     .collect(Collectors.toList());
             return result;
         } catch (IllegalAccessException | InvocationTargetException e) {
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt b/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
index f5a1e913..e1482fa7 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
@@ -54,13 +54,13 @@ import com.vaadin.flow.function.ValueProvider
 import com.vaadin.browserless.internal.DepthFirstTreeIterator
 import com.vaadin.browserless.internal.MockVaadin
 import com.vaadin.browserless.internal.PrettyPrintTree
-import com.vaadin.browserless.internal._fireEvent
-import com.vaadin.browserless.internal._getPresentationValue
-import com.vaadin.browserless.internal._saneFetchLimit
-import com.vaadin.browserless.internal.checkEditableByUser
+import com.vaadin.browserless.internal.BasicUtils._fireEvent
+import com.vaadin.browserless.internal.Renderers._getPresentationValue
+import com.vaadin.browserless.internal.BasicUtils._saneFetchLimit
+import com.vaadin.browserless.internal.BasicUtils.checkEditableByUser
 import com.vaadin.browserless.internal.filterNotBlank
 import com.vaadin.browserless.internal.size
-import com.vaadin.browserless.internal.template
+import com.vaadin.browserless.internal.Renderers.template
 import com.vaadin.browserless.internal.toPrettyString
 import java.lang.reflect.Method
 import java.lang.reflect.Field
@@ -68,7 +68,7 @@ import java.util.stream.Stream
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty1
 import kotlin.streams.toList
-import com.vaadin.browserless.internal.findClassOrThrow
+import com.vaadin.browserless.internal.Utils.findClassOrThrow
 
 /**
  * Returns the item on given row. Fails if the row index is invalid. The data provider is
@@ -184,7 +184,7 @@ private val _DataCommunicator_setPagingEnabled: Method? =
  * This is an internal stuff, most probably you wish to call [_fetch].
  */
 public fun <T> DataCommunicator<T>.fetch(offset: Int, limit: Int): List<T> {
-    require(limit <= _saneFetchLimit) { "Vaadin doesn't handle fetching of many items very well unfortunately. The sane limit is $_saneFetchLimit but you asked for $limit" }
+    require(limit <= _saneFetchLimit()) { "Vaadin doesn't handle fetching of many items very well unfortunately. The sane limit is ${_saneFetchLimit()} but you asked for $limit" }
 
     // make sure the DataCommunicator is not in paged mode: https://github.com/mvysny/karibu-testing/issues/99
     _DataCommunicator_setPagingEnabled?.invoke(this, false)
@@ -200,7 +200,7 @@ public fun <T> DataCommunicator<T>.fetch(offset: Int, limit: Int): List<T> {
  *
  * This is an internal stuff, most probably you wish to call [_fetch].
  */
-public fun <T> DataCommunicator<T>.fetchAll(): List<T> = fetch(0, _saneFetchLimit)
+public fun <T> DataCommunicator<T>.fetchAll(): List<T> = fetch(0, _saneFetchLimit())
 
 /**
  * Returns all items in given data provider. Uses current Grid sorting.
@@ -212,7 +212,7 @@ public fun <T> DataCommunicator<T>.fetchAll(): List<T> = fetch(0, _saneFetchLimi
  *
  * @return the list of items.
  */
-public fun <T> Grid<T>._findAll(): List<T> = _fetch(0, _saneFetchLimit)
+public fun <T> Grid<T>._findAll(): List<T> = _fetch(0, _saneFetchLimit())
 
 /**
  * Returns the number of items in this data provider.
@@ -396,7 +396,7 @@ public fun <T : Any> Grid.Column<T>.getPresentationValue(rowObject: T): Any? {
         val value: Any? = valueProvider.apply(rowObject)
         return value.toString()
     }
-    return renderer._getPresentationValue(rowObject)
+    return _getPresentationValue(renderer, rowObject)
 }
 
 private fun <T> Grid<T>.getSortIndicator(column: Grid.Column<T>): String {
@@ -604,7 +604,7 @@ public fun <T : Any> Grid<T>._clickItem(rowIndex: Int, button: Int = 0, ctrlKey:
 @JvmOverloads
 public fun <T : Any> Grid<T>._clickItem(rowIndex: Int, column: Grid.Column<*>?, button: Int = 1, ctrlKey: Boolean = false,
                            shiftKey: Boolean = false, altKey: Boolean = false, metaKey: Boolean = false) {
-    checkEditableByUser()
+    checkEditableByUser(this)
     // fire SelectionEvent if need be: https://github.com/mvysny/karibu-testing/issues/96
     val item: T = _get(rowIndex)
     if (selectionModel is GridSingleSelectionModel) {
@@ -621,7 +621,7 @@ public fun <T : Any> Grid<T>._clickItem(rowIndex: Int, column: Grid.Column<*>?,
     val itemKey: String = dataCommunicator.keyMapper.key(item)
     val internalColumnId = column?._internalId
     val event = ItemClickEvent<T>(this, true, itemKey, internalColumnId, -1, -1, -1, -1, 1, button, ctrlKey, shiftKey, altKey, metaKey)
-    _fireEvent(event)
+    _fireEvent(this, event)
 }
 
 /**
@@ -652,10 +652,10 @@ public fun <T : Any> Grid<T>._clickItem(rowIndex: Int, columnKey: String, button
 @JvmOverloads
 public fun <T : Any> Grid<T>._doubleClickItem(rowIndex: Int, button: Int = 1, ctrlKey: Boolean = false,
                                         shiftKey: Boolean = false, altKey: Boolean = false, metaKey: Boolean = false) {
-    checkEditableByUser()
+    checkEditableByUser(this)
     val itemKey: String = dataCommunicator.keyMapper.key(_get(rowIndex))
     val event = ItemDoubleClickEvent<T>(this, true, itemKey, null, -1, -1, -1, -1, 2, button, ctrlKey, shiftKey, altKey, metaKey)
-    _fireEvent(event)
+    _fireEvent(this, event)
 }
 
 /**
@@ -833,7 +833,7 @@ private fun <T> Grid<T>._selectAllCheckboxModel(action: String): GridMultiSelect
  * In single select clears the selection and select only given [item], for multiselect add to selection.
  */
 public fun <T: Any> Grid<T>._select(item: T) {
-    checkEditableByUser()
+    checkEditableByUser(this)
     if(selectionModel is GridSingleSelectionModel) {
         deselectAll()
     }
@@ -846,7 +846,7 @@ public fun <T: Any> Grid<T>._select(item: T) {
  * Fails if the grid is not multi-select or the "select all" checkbox is hidden.
  */
 public fun <T> Grid<T>._selectAll() {
-    checkEditableByUser()
+    checkEditableByUser(this)
     val model = _selectAllCheckboxModel("Select all")
     _AbstractGridMultiSelectionModel_clientSelectAll.invoke(model)
 }
@@ -863,7 +863,7 @@ public fun <T> Grid<T>._selectAll() {
  * [GridSingleSelectionModel.isDeselectAllowed] set to false.
  */
 public fun <T: Any> Grid<T>._deselect(item: T) {
-    checkEditableByUser()
+    checkEditableByUser(this)
     if(selectionModel !is GridNoneSelectionModel && !selectionModel.isSelected(item)) {
         throw IllegalStateException("Can not deselect ${item}: the row is not selected")
     }
@@ -880,7 +880,7 @@ public fun <T: Any> Grid<T>._deselect(item: T) {
  * cause by unchecking rows one by one. Call [_deselect] per row to model that instead.
  */
 public fun <T> Grid<T>._deselectAll() {
-    checkEditableByUser()
+    checkEditableByUser(this)
     val model = _selectAllCheckboxModel("Deselect all")
     _AbstractGridMultiSelectionModel_clientDeselectAll.invoke(model)
 }
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/BasicUtils.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/BasicUtils.kt
deleted file mode 100644
index 89e50819..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/BasicUtils.kt
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-@file:Suppress("FunctionName")
-
-package com.vaadin.browserless.internal
-
-import com.vaadin.flow.component.BlurNotifier
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.ComponentEvent
-import com.vaadin.flow.component.ComponentUtil
-import com.vaadin.flow.component.FocusNotifier
-import com.vaadin.flow.component.Focusable
-import com.vaadin.flow.component.HasEnabled
-import com.vaadin.flow.component.HasText
-import com.vaadin.flow.component.HasValue
-import com.vaadin.flow.component.Text
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.dom.DomEvent
-import com.vaadin.flow.internal.JacksonUtils
-import com.vaadin.flow.router.InternalServerError
-import com.vaadin.flow.server.VaadinSession
-import tools.jackson.databind.node.ObjectNode
-
-/**
- * Allows us to fire any Vaadin event on any Vaadin component.
- * @receiver the component, not null.
- * @param event the event, not null.
- */
-fun Component._fireEvent(event: ComponentEvent<*>) {
-    ComponentUtil.fireEvent(this, event)
-}
-
-/**
- * Fires a DOM event on this component.
- * @param eventType the event type, e.g. "click"
- * @param eventData optional event data, defaults to an empty object.
- */
-@JvmOverloads
-fun Component._fireDomEvent(eventType: String, eventData: ObjectNode = JacksonUtils.createObjectNode()) {
-    element._fireDomEvent(DomEvent(element, eventType, eventData))
-}
-
-/**
- * The same as [Component.getId] but without Optional.
- *
- * Workaround for https://github.com/vaadin/flow/issues/664
- */
-var Component.id_: String?
-    get() = id.orElse(null)
-    set(value) {
-        setId(value)
-    }
-
-/**
- * Checks whether the component is visible (usually [Component.isVisible] but for [Text]
- * the text must be non-empty).
- */
-val Component._isVisible: Boolean
-    get() = when (this) {
-        is Text -> !text.isNullOrBlank()   // workaround for https://github.com/vaadin/flow/issues/3201
-        else -> isVisible
-    }
-
-/**
- * Returns direct text contents (it doesn't peek into the child elements).
- */
-val Component._text: String?
-    get() = when (this) {
-        is HasText -> text
-        else -> null
-    }
-
-/**
- * Checks that a component is actually editable by the user:
- * * The component must be effectively visible: it itself must be visible, its parent must be visible and all of its ascendants must be visible.
- *   For the purpose of testing individual components not attached to the [UI], a component may be considered visible even though it's not
- *   currently nested in a [UI].
- * * The component must be effectively enabled: it itself must be enabled, its parent must be enabled and all of its ascendants must be enabled.
- * * If the component is [HasValue], it must not be [HasValue.isReadOnly].
- * @throws IllegalStateException if any of the above doesn't hold.
- */
-fun Component.checkEditableByUser() {
-    check(isEffectivelyVisible()) { "The ${toPrettyString()} is not effectively visible - either it is hidden, or its ascendant is hidden" }
-    val parentNullOrEnabled = !parent.isPresent || parent.get().isEffectivelyEnabled()
-    if (parentNullOrEnabled) {
-        check(element.isEnabled) { "The ${toPrettyString()} is not enabled" }
-    }
-    check(isEffectivelyEnabled()) { "The ${toPrettyString()} is nested in a disabled component" }
-    if (this is HasValue<*, *>) {
-        @Suppress("UNCHECKED_CAST")
-        val hasValue = this as HasValue<HasValue.ValueChangeEvent<Any?>, Any?>
-        check(!hasValue.isReadOnly) { "The ${toPrettyString()} is read-only" }
-    }
-    check(isAttached) { " The ${toPrettyString()} is not attached" }
-}
-
-/**
- * Fails if the component is editable. See [checkEditableByUser] for more details.
- * @throws AssertionError if the component is editable.
- */
-fun Component.expectNotEditableByUser() {
-    try {
-        checkEditableByUser()
-        throw AssertionError("The ${toPrettyString()} is editable")
-    } catch (ex: IllegalStateException) {
-        // okay
-    }
-}
-
-internal fun Component.isEffectivelyVisible(): Boolean = _isVisible && (!parent.isPresent || parent.get().isEffectivelyVisible())
-
-/**
- * Computes whether this component and all of its parents are enabled.
- *
- * Recursively checks that all ancestors are also enabled (the "implicitly disabled" effect, see [HasEnabled.isEnabled]
- * javadoc for more details).
- *
- * Also check that the component is not inert due to there being a modal component.
- *
- * @return false if this component or any of its parent is disabled or is inert.
- */
-fun Component.isEffectivelyEnabled(): Boolean = element.isEnabled && !element.node.isInert
-
-/**
- * Checks whether this component matches given spec. All rules are matched except the [count] rule. The
- * rules are matched against given component only (not against its children).
- */
-fun Component.matches(spec: SearchSpec<Component>.() -> Unit): Boolean =
-        SearchSpec(Component::class.java).apply { spec() }.toPredicate().invoke(this)
-
-/**
- * Fires [FocusNotifier.FocusEvent] on the component, but only if it's editable.
- */
-fun <T> T._focus() where T : Focusable<*>, T : Component {
-    checkEditableByUser()
-    _fireEvent(FocusNotifier.FocusEvent<T>(this, true, null))
-}
-
-/**
- * Fires [BlurNotifier.BlurEvent] on the component, but only if it's editable.
- */
-fun <T> T._blur() where T : Focusable<*>, T : Component {
-    checkEditableByUser()
-    _fireEvent(BlurNotifier.BlurEvent<T>(this, true, null))
-}
-
-/**
- * Closes the UI and simulates the end of the request. The [UI.close] is called,
- * but also the session is set to null which fires the detach listeners and makes
- * the UI and all of its components detached.
- */
-fun UI._close() {
-    close()
-    // Mock closing of UI after request handled.
-    VaadinSession.getCurrent().removeUI(this)
-}
-
-/**
- * Returns child components which were added to this component via
- * [com.vaadin.flow.dom.Element.appendVirtualChild].
- */
-fun Component._getVirtualChildren(): List<Component> =
-        element.getVirtualChildren().map { it._findComponents() }.flatten()
-
-internal val InternalServerError.errorMessage: String get() = element.text
-
-val _saneFetchLimit: Int get() =
-// don't use high value otherwise Vaadin 19+ will calculate negative limit and will pass it to SizeVerifier,
-    // failing instantly.
-    Int.MAX_VALUE / 1000
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/ComponentUtils.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/ComponentUtils.kt
deleted file mode 100644
index a9bc5348..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/ComponentUtils.kt
+++ /dev/null
@@ -1,440 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.lang.reflect.Method
-import com.vaadin.flow.component.ClickEvent
-import com.vaadin.flow.component.ClickNotifier
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.ComponentEvent
-import com.vaadin.flow.component.ComponentUtil
-import com.vaadin.flow.component.HasComponents
-import com.vaadin.flow.component.HasElement
-import com.vaadin.flow.component.HasOrderedComponents
-import com.vaadin.flow.component.HasPlaceholder
-import com.vaadin.flow.component.HasStyle
-import com.vaadin.flow.component.HasText
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.checkbox.Checkbox
-import com.vaadin.flow.component.checkbox.CheckboxGroup
-import com.vaadin.flow.component.combobox.ComboBox
-import com.vaadin.flow.component.confirmdialog.ConfirmDialog
-import com.vaadin.flow.component.contextmenu.ContextMenuBase
-import com.vaadin.flow.component.datepicker.DatePicker
-import com.vaadin.flow.component.dialog.Dialog
-import com.vaadin.flow.component.formlayout.FormLayout
-import com.vaadin.flow.component.grid.Grid
-import com.vaadin.flow.component.listbox.ListBoxBase
-import com.vaadin.flow.component.login.LoginOverlay
-import com.vaadin.flow.component.notification.Notification
-import com.vaadin.flow.component.radiobutton.RadioButtonGroup
-import com.vaadin.flow.component.select.Select
-import com.vaadin.flow.component.sidenav.SideNav
-import com.vaadin.flow.component.sidenav.SideNavItem
-import com.vaadin.flow.component.textfield.PasswordField
-import com.vaadin.flow.component.textfield.TextArea
-import com.vaadin.flow.component.textfield.TextField
-import com.vaadin.flow.data.binder.HasDataProvider
-import com.vaadin.flow.data.provider.DataProvider
-import com.vaadin.flow.dom.DomEventListener
-import com.vaadin.flow.dom.DomListenerRegistration
-import com.vaadin.flow.router.Location
-import com.vaadin.browserless.component.dataProvider
-
-/**
- * Fires given event on the component.
- */
-fun Component.fireEvent(event: ComponentEvent<*>) {
-    ComponentUtil.fireEvent(this, event)
-}
-
-/**
- * Adds [com.vaadin.flow.component.button.Button.click] functionality to all [ClickNotifier]s. This function directly calls
- * all click listeners, thus it avoids the roundtrip to client and back. It even works with browserless testing.
- * @param fromClient see [ComponentEvent.isFromClient], defaults to true.
- * @param button see [ClickEvent.getButton], defaults to 0.
- * @param clickCount see [ClickEvent.getClickCount], defaults to 1.
- */
-fun <T: ClickNotifier<*>> T.serverClick(
-    fromClient: Boolean = true,
-    button: Int = 0,
-    clickCount: Int = 1,
-    shiftKey: Boolean = false,
-    ctrlKey: Boolean = false,
-    altKey: Boolean = false,
-    metaKey: Boolean = false
-) {
-    (this as Component).fireEvent(ClickEvent<Component>(this,
-        fromClient, -1, -1, -1, -1, clickCount, button, ctrlKey, shiftKey, altKey, metaKey))
-}
-
-/**
- * Sets the alignment of the text in the component. One of `center`, `left`, `right`, `justify`.
- */
-var Component.textAlign: String?
-    get() = element.style.get("textAlign")
-    set(value) { element.style.set("textAlign", value) }
-
-/**
- * Sets or removes the `title` attribute on component's element.
- */
-var Component.tooltip: String?
-    get() = element.getAttribute("title")
-    set(value) { element.setOrRemoveAttribute("title", value) }
-
-/**
- * Adds the right-click (context-menu) [listener] to the component. Also causes the right-click browser
- * menu not to be shown on this component (see [preventDefault]).
- */
-fun Component.addContextMenuListener(listener: DomEventListener): DomListenerRegistration =
-        element.addEventListener("contextmenu", listener)
-                .preventDefault()
-
-/**
- * Makes the client-side listener call [Event.preventDefault()](https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
- * on the event.
- *
- * @return this
- */
-fun DomListenerRegistration.preventDefault(): DomListenerRegistration = addEventData("event.preventDefault()")
-
-/**
- * Removes the component from its parent. Does nothing if the component is not attached to a parent.
- */
-fun Component.removeFromParent() {
-    (parent.orElse(null) as? HasComponents)?.remove(this)
-}
-
-/**
- * Finds component's parent, parent's parent (etc) which satisfies given [predicate].
- * Returns null if there is no such parent.
- */
-fun Component.findAncestor(predicate: (Component) -> Boolean): Component? =
-        findAncestorOrSelf { it != this && predicate(it) }
-
-/**
- * Finds component, component's parent, parent's parent (etc) which satisfies given [predicate].
- * Returns null if no component on the ancestor-or-self axis satisfies.
- */
-tailrec fun Component.findAncestorOrSelf(predicate: (Component) -> Boolean): Component? {
-    if (predicate(this)) {
-        return this
-    }
-    val p: Component = parent.orElse(null) ?: return null
-    return p.findAncestorOrSelf(predicate)
-}
-
-/**
- * Checks if this component is nested in [potentialAncestor].
- */
-fun Component.isNestedIn(potentialAncestor: Component): Boolean =
-        findAncestor { it == potentialAncestor } != null
-
-/**
- * Checks whether this component is currently attached to a [UI].
- *
- * Returns true for attached components even if the UI itself is closed.
- */
-fun Component.isAttached(): Boolean {
-    // see https://github.com/vaadin/flow/issues/7911
-    return element.node.isAttached
-}
-
-/**
- * Returns the data provider currently set to this Component.
- *
- * Works both with Vaadin 16 and Vaadin 17: Vaadin 17 components no longer implement HasItems.
- */
-val Component.dataProvider: DataProvider<*, *>? get() = when (this) {
-    // until https://github.com/vaadin/flow/issues/6296 is resolved
-    is HasDataProvider<*> -> this.dataProvider
-    is Grid<*> -> this.dataProvider
-    is Select<*> -> this.dataProvider
-    is ListBoxBase<*, *, *> -> _ListBoxBase_getDataProvider.invoke(this) as DataProvider<*, *>
-    is RadioButtonGroup<*> -> _RadioButtonGroup_getDataProvider.invoke(this) as DataProvider<*, *>
-    is CheckboxGroup<*> -> _CheckboxGroup_getDataProvider.invoke(this) as DataProvider<*, *>
-    is ComboBox<*> -> this.dataProvider
-    else -> null
-}
-
-/**
- * Inserts this component as a child, right before an [existing] one.
- *
- * In case the specified component has already been added to another parent,
- * it will be removed from there and added to this one.
- */
-fun HasOrderedComponents.insertBefore(newComponent: Component, existing: Component) {
-    val parent: Component = requireNotNull(existing.parent.orElse(null)) { "$existing has no parent" }
-    require(parent == this) { "$existing is not nested in $this" }
-    addComponentAtIndex(indexOf(existing), newComponent)
-}
-
-/**
- * Return the location of the currently shown view. The function will report the current (old)
- * view in [com.vaadin.flow.router.BeforeLeaveEvent] and [com.vaadin.flow.router.BeforeEnterEvent].
- */
-val UI.currentViewLocation: Location get() = internals.activeViewLocation
-
-/**
- * True when the component has any children. Alias for [hasChildren].
- *
- * Deprecated: poorly named. A `form.isNotEmpty` may be ambiguous - it may refer to
- * whether the form has any children, or whether the form value is not empty, or something else.
- */
-//@Deprecated("use hasChildren", replaceWith = ReplaceWith("hasChildren"))
-//val HasComponents.isNotEmpty: Boolean get() = hasChildren
-
-/**
- * True when the component has any children.
- */
-val HasComponents.hasChildren: Boolean get() = (this as Component).children.findFirst().isPresent
-
-/**
- * True when the component has no children.
- *
- * Deprecated: poorly named. A `form.isEmpty` may be ambiguous - it may refer to
- * whether the form has any children, or whether the form value is empty, or something else.
- */
-//@Deprecated("use !hasChildren")
-//val HasComponents.isEmpty: Boolean get() = !hasChildren
-
-/**
- * Splits [classNames] by whitespaces to obtain individual class names, then
- * calls [HasStyle.addClassName] on each class name. Does nothing if the string
- * is blank.
- */
-fun HasStyle.addClassNames2(classNames: String) {
-    // workaround for https://github.com/vaadin/flow/issues/11709
-    classNames.splitByWhitespaces().forEach { addClassName(it) }
-}
-
-/**
- * Splits [classNames] by whitespaces to obtain individual class names, then
- * calls [addClassNames2] on each class name. Does nothing if the string
- * is blank.
- */
-fun HasStyle.addClassNames2(vararg classNames: String) {
-    // workaround for https://github.com/vaadin/flow/issues/11709
-    classNames.forEach { addClassNames2(it) }
-}
-
-/**
- * Splits [classNames] by whitespaces to obtain individual class names, then
- * calls [HasStyle.removeClassName] on each class name. Does nothing if the string
- * is blank.
- */
-fun HasStyle.removeClassNames2(classNames: String) {
-    // workaround for https://github.com/vaadin/flow/issues/11709
-    classNames.splitByWhitespaces().forEach { removeClassName(it) }
-}
-
-/**
- * Splits [classNames] by whitespaces to obtain individual class names, then
- * calls [removeClassNames2] on each class name. Does nothing if the string
- * is blank.
- */
-fun HasStyle.removeClassNames2(vararg classNames: String) {
-    // workaround for https://github.com/vaadin/flow/issues/11709
-    classNames.forEach { removeClassNames2(it) }
-}
-
-/**
- * Splits [classNames] by whitespaces to obtain individual class names, then
- * clears the class names and calls [addClassNames2] on each class name. Does nothing if the string
- * is blank.
- */
-fun HasStyle.setClassNames2(classNames: String) {
-    // workaround for https://github.com/vaadin/flow/issues/11709
-    style.clear()
-    addClassNames2(classNames)
-}
-
-/**
- * Splits [classNames] by whitespaces to obtain individual class names, then
- * clears the class names and calls [addClassNames2] on each class name. Does nothing if the string
- * is blank.
- */
-fun HasStyle.setClassNames2(vararg classNames: String) {
-    // workaround for https://github.com/vaadin/flow/issues/11709
-    style.clear()
-    addClassNames2(*classNames)
-}
-
-/**
- * A component placeholder, usually shown when there's no value selected.
- * Not all components support a placeholder; those that don't will return null.
- */
-var Component.placeholder: String?
-    // modify when this is fixed: https://github.com/vaadin/flow/issues/4068
-    get() = when (this) {
-        is TextField -> placeholder
-        is TextArea -> placeholder
-        is PasswordField -> placeholder
-        is ComboBox<*> -> this.placeholder  // https://youtrack.jetbrains.com/issue/KT-24275
-        is DatePicker -> placeholder
-        is HasPlaceholder -> placeholder
-        else -> null
-    }
-    set(value) {
-        when (this) {
-            is TextField -> placeholder = value
-            is TextArea -> placeholder = value
-            is PasswordField -> placeholder = value
-            is ComboBox<*> -> this.placeholder = value
-            is DatePicker -> placeholder = value
-            is HasPlaceholder -> placeholder = value
-            else -> throw IllegalStateException("${javaClass.simpleName} doesn't support setting placeholder")
-        }
-    }
-
-/**
- * Concatenates texts from all elements placed in the `label` slot. This effectively
- * returns whatever was provided in the String label via [FormLayout.addFormItem].
- */
-val FormLayout.FormItem.label: String get() {
-    val captions: List<Component> = children.toList().filter { it.element.getAttribute("slot") == "label" }
-    return captions.joinToString("") { (it as? HasText)?.text ?: "" }
-}
-
-/**
- * The `HasLabel` interface has been introduced in Vaadin 21 but is missing in Vaadin 14.
- * Use reflection.
- */
-private val _HasLabel: Class<*>? = findClass("com.vaadin.flow.component.HasLabel")
-private val _HasLabel_getLabel: Method? = _HasLabel?.getDeclaredMethod("getLabel")
-private val _HasLabel_setLabel: Method? = _HasLabel?.getDeclaredMethod("setLabel", String::class.java)
-
-/**
- * Determines the component's `label` (usually it's the HTML element's `label` property, but it's [Checkbox.getLabel] for checkbox).
- * Intended to be used for fields such as [TextField].
-
- * *For `FormItem`:* Concatenates texts from all elements placed in the `label` slot. This effectively
- * returns whatever was provided in the String label via [FormLayout.addFormItem].
- *
- * [Button.caption] is displayed directly on the component
- * while label is displayed next to the component in a layout (e.g. a [TextField] nested in a form layout).
- *
- * Vote for [issue #3241](https://github.com/vaadin/flow/issues/3241).
- *
- * **WARNING:** the label is displayed by the component itself, rather than by the parent layout.
- * If a component doesn't contain necessary machinery
- * to display a label, setting this property will have no visual effect.
- * For example, setting a label to a [FormLayout]
- * nested within a `VerticalLayout`
- * will show nothing since [FormLayout] doesn't display a label itself.
- * See [LabelWrapper] for a list of possible solutions.
- */
-var Component.label: String
-    get() = when {
-        _HasLabel != null && _HasLabel.isInstance(this) -> _HasLabel_getLabel!!.invoke(this) as String? ?: ""
-        this is Checkbox -> label ?: ""
-        this is FormLayout.FormItem -> this.label
-        this is SideNav -> label ?: ""
-        this is SideNavItem -> label ?: ""
-        else -> element.getProperty("label") ?: ""
-    }
-    set(value) {
-        when {
-            _HasLabel != null && _HasLabel.isInstance(this) -> _HasLabel_setLabel!!.invoke(this, value)
-            this is Checkbox -> label = value
-            this is FormLayout.FormItem -> throw IllegalArgumentException("Setting the caption of FormItem is currently unsupported")
-            this is SideNav -> label = value
-            this is SideNavItem -> label = value
-            else -> element.setProperty("label", value.ifBlank { null })
-        }
-    }
-
-/**
- * The Component's caption: [Button.getText] for [Button], [label] for fields such as [TextField].
- *
- * Caption is generally displayed directly on the component (e.g. the Button text),
- * while [label] is displayed next to the component in a layout (e.g. a [TextField] nested in a form layout).
- *
- * **Deprecated:** this property was intended to unify captions and labels, but only managed to
- * create confusion between the two concepts. Also, there's only a [Button] which
- * has the notion of a caption. Will be removed with no replacement.
- */
-@Deprecated("don't use")
-var Component.caption: String
-    get() = when (this) {
-        is Button -> caption
-        else -> label
-    }
-    set(value) {
-        when (this) {
-            is Button -> caption = value
-            else -> label = value
-        }
-    }
-
-/**
- * Sets up an event listener for overlay components that fires a `closed` DOM
- * event when the component is closed. This simulates the event being fired
- * from the browser after the closing animation has finished.
- */
-fun Component.simulateClosedEvent() {
-    if (ComponentUtil.getData(this, "hasSimulatedClosedEvent") != null) {
-        return
-    }
-    when (this) {
-        is Dialog, is ConfirmDialog, is LoginOverlay, is ContextMenuBase<*, *, *>, is Notification -> {
-            ComponentUtil.setData(this, "hasSimulatedClosedEvent", true)
-            element.addPropertyChangeListener("opened") { event ->
-                if (event.value == false) {
-                    _fireDomEvent("closed")
-                }
-            }
-        }
-    }
-}
-
-/**
- * The Button's caption. Alias for [Button.getText].
- *
- * Caption is generally displayed directly on the component (e.g. the Button text),
- * while [label] is displayed next to the component in a layout (e.g. a [TextField] nested in a form layout).
- */
-var Button.caption: String
-    get() = text
-    set(value) {
-        text = value
-    }
-
-internal fun HasElement.getChildComponentInSlot(slotName: String): Component? =
-    element.getChildrenInSlot(slotName).firstOrNull()?.component?.get()
-
-internal fun HasElement.setChildComponentToSlot(slotName: String, component: Component?) {
-    element.clearSlot(slotName)
-    if (component != null) {
-        component.element.setAttribute("slot", slotName)
-        element.appendChild(component.element)
-    }
-}
-
-internal fun isPolymerTemplate(component: Component): Boolean {
-    return polymerTemplateClass != null
-            && polymerTemplateClass.isAssignableFrom(component.javaClass);
-}
-
-private val _ListBoxBase_getDataProvider: Method =
-    ListBoxBase::class.java.getDeclaredMethod("getDataProvider").apply { isAccessible = true }
-private val _Grid_getDataProvider: Method =
-    Grid::class.java.getDeclaredMethod("getDataProvider").apply { isAccessible = true }
-private val _CheckboxGroup_getDataProvider: Method =
-    CheckboxGroup::class.java.getDeclaredMethod("getDataProvider").apply { isAccessible = true }
-private val _RadioButtonGroup_getDataProvider: Method =
-    RadioButtonGroup::class.java.getDeclaredMethod("getDataProvider").apply { isAccessible = true }
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIterator.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIterator.kt
deleted file mode 100644
index 7ee9ee64..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIterator.kt
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.util.Deque
-import java.util.LinkedList
-import kotlin.streams.toList
-import com.vaadin.flow.component.Component
-
-/**
- * Walks the child tree, depth-first: first the node, then its descendants,
- * then its next sibling.
- * @param root start here.
- * @param children fetches children of given node.
- */
-class DepthFirstTreeIterator<out T>(root: T, private val children: (T) -> List<T>) : Iterator<T> {
-    private val queue: Deque<T> = LinkedList(listOf(root))
-    override fun hasNext(): Boolean = !queue.isEmpty()
-    override fun next(): T {
-        if (!hasNext()) throw NoSuchElementException()
-        val result: T = queue.pop()
-        children(result).asReversed().forEach { queue.push(it) }
-        return result
-    }
-}
-
-/**
- * Walks the component child tree, depth-first: first the component, then its descendants,
- * then its next sibling.
- */
-fun Component.walk(): Iterable<Component> = Iterable {
-    DepthFirstTreeIterator(this) { component: Component -> component.children.toList() }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/ElementUtils.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/ElementUtils.kt
deleted file mode 100644
index afd02e88..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/ElementUtils.kt
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import kotlin.streams.toList
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.ComponentUtil
-import com.vaadin.flow.dom.ClassList
-import com.vaadin.flow.dom.DomEvent
-import com.vaadin.flow.dom.Element
-import com.vaadin.flow.dom.ElementUtil
-import com.vaadin.flow.internal.StateNode
-import com.vaadin.flow.internal.nodefeature.ElementListenerMap
-import com.vaadin.flow.internal.nodefeature.VirtualChildrenList
-import org.jsoup.nodes.Document
-import org.jsoup.nodes.Node
-import org.jsoup.nodes.TextNode
-
-/**
- * Either calls [Element.setAttribute] (if the [value] is not null), or
- * [Element.removeAttribute] (if the [value] is null).
- * @param attribute the name of the attribute.
- */
-fun Element.setOrRemoveAttribute(attribute: String, value: String?) {
-    if (value == null) {
-        removeAttribute(attribute)
-    } else {
-        setAttribute(attribute, value)
-    }
-}
-
-/**
- * Toggles [className] - removes it if it was there, or adds it if it wasn't there.
- * @param className the class name to toggle, cannot contain spaces.
- */
-fun ClassList.toggle(className: String) {
-    require(!className.containsWhitespace()) { "'$className' cannot contain whitespace" }
-    set(className, !contains(className))
-}
-
-/**
- * Inserts [newNode] as a child, right before an [existingNode].
- * A counterpart for JavaScript DOM `Node.insertBefore()`.
- */
-fun Element.insertBefore(newNode: Element, existingNode: Element) {
-    val parent: Element = requireNotNull(existingNode.parent) { "$existingNode has no parent element" }
-    require(parent == this) { "$existingNode is not nested in $this" }
-    insertChild(indexOfChild(existingNode), newNode)
-}
-
-/**
- * This function actually works, as opposed to [Element.getTextRecursively].
- */
-val Element.textRecursively2: String
-    get() {
-        // remove when this is fixed: https://github.com/vaadin/flow/issues/3668
-        val node = ElementUtil.toJsoup(Document(""), this)
-        return node.textRecursively
-    }
-
-val Node.textRecursively: String
-    get() = when (this) {
-        is TextNode -> this.text()
-        else -> childNodes().joinToString(separator = "", transform = { it.textRecursively })
-    }
-
-/**
- * Returns all virtual child elements added via [Element.appendVirtualChild].
- */
-fun Element.getVirtualChildren(): List<Element> {
-    if (node.hasFeature(VirtualChildrenList::class.java)) {
-        val virtualChildrenList: VirtualChildrenList? =
-            node.getFeatureIfInitialized(VirtualChildrenList::class.java)
-                .orElse(null)
-        if (virtualChildrenList != null) {
-            return virtualChildrenList.iterator().asSequence().map { it.element } .toList()
-        }
-    }
-    return listOf()
-}
-
-/**
- * Gets the element mapped to the given state node.
- */
-val StateNode.element: Element get() = Element.get(this)
-
-/**
- * Returns child elements with the `slot` attribute set to given [slotName].
- */
-fun Element.getChildrenInSlot(slotName: String): List<Element> =
-    children.filter { child -> child.getAttribute("slot") == slotName } .toList()
-
-/**
- * Removes all child elements from given slot, leaving it empty.
- */
-fun Element.clearSlot(slotName: String) {
-    require(slotName.isNotBlank())
-    getChildrenInSlot(slotName).forEach { it.removeFromParent() }
-}
-
-/**
- * Returns all components that are closest to [this] element.
- */
-fun Element._findComponents(): List<Component> {
-    val components = mutableListOf<Component>()
-
-    ComponentUtil.findComponents(this) {
-        components.add(it)
-    }
-
-    return components
-}
-
-/**
- * Fires a DOM [event] on this element.
- */
-fun Element._fireDomEvent(event: DomEvent) {
-    node.getFeature(ElementListenerMap::class.java).fireEvent(event)
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
index 5f4c1e42..0c6347b3 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
@@ -24,6 +24,14 @@ import com.vaadin.flow.component.HasValue
 import com.vaadin.flow.component.UI
 import com.vaadin.flow.component.dialog.Dialog
 import com.vaadin.flow.router.InternalServerError
+import com.vaadin.browserless.internal.BasicUtils.errorMessage
+import com.vaadin.browserless.internal.BasicUtils.id_
+import com.vaadin.browserless.internal.BasicUtils.isEffectivelyVisible
+import com.vaadin.browserless.internal.ComponentUtils.caption
+import com.vaadin.browserless.internal.ComponentUtils.isPolymerTemplate
+import com.vaadin.browserless.internal.ComponentUtils.placeholder
+import com.vaadin.browserless.internal.Utils.currentUI
+import com.vaadin.browserless.internal.Utils.hasPolymerTemplates
 
 /**
  * A criterion for matching components. The component must match all of non-null fields.
@@ -93,10 +101,10 @@ class SearchSpec<T : Component>(
     fun toPredicate(): (Component) -> Boolean {
         val p = mutableListOf<(Component)->Boolean>()
         p.add { component -> clazz.isInstance(component)}
-        if (id != null) p.add { component -> component.id_ == id }
+        if (id != null) p.add { component -> id_(component) == id }
         if (testId != null) p.add { component -> component.testId == testId }
-        if (caption != null) p.add { component -> component.caption == caption }
-        if (placeholder != null) p.add { component -> component.placeholder == placeholder }
+        if (caption != null) p.add { component -> caption(component) == caption }
+        if (placeholder != null) p.add { component -> placeholder(component) == placeholder }
         if (!classes.isNullOrBlank()) p.add { component -> component.hasAllClasses(classes!!) }
         if (!withoutClasses.isNullOrBlank()) p.add { component -> component.doesntHaveAnyClasses(withoutClasses!!) }
         if (!themes.isNullOrBlank()) p.add { component -> component.hasAllThemes(themes!!) }
@@ -110,7 +118,7 @@ class SearchSpec<T : Component>(
 
 
 private data class CaptionContainsPredicate<T : Component>(val substring: String) : Predicate<T> {
-    override fun test(t: T): Boolean = t.caption.contains(substring)
+    override fun test(t: T): Boolean = caption(t).contains(substring)
     override fun toString() = "captionContains('$substring')"
 }
 
@@ -174,7 +182,7 @@ inline fun <reified T: Component> _get(noinline block: SearchSpec<T>.()->Unit =
  * @return the only matching component, never null.
  * @throws IllegalArgumentException if no component matched, or if more than one component matches.
  */
-fun <T: Component> _get(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}): T = currentUI._get(clazz, block)
+fun <T: Component> _get(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}): T = currentUI()._get(clazz, block)
 
 /**
  * Finds a list of VISIBLE components of given [clazz] which matches [block]. This component and all of its descendants are searched.
@@ -229,17 +237,17 @@ inline fun <reified T: Component> _find(noinline block: SearchSpec<T>.()->Unit =
  * @return the list of matching components, may be empty.
  */
 fun <T: Component> _find(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}): List<T> =
-        currentUI._find(clazz, block)
+        currentUI()._find(clazz, block)
 
 private fun Component.find(predicate: (Component)->Boolean): List<Component> {
-    testingLifecycleHook.awaitBeforeLookup()
+    TestingLifecycleHooks.getCurrent().awaitBeforeLookup()
     val descendants: List<Component> = _walkAll().toList()
-    testingLifecycleHook.awaitAfterLookup()
+    TestingLifecycleHooks.getCurrent().awaitAfterLookup()
     val error: InternalServerError? = descendants.filterIsInstance<InternalServerError>().firstOrNull()
     if (error != null) {
-        throw AssertionError("An internal server error occurred; please check log for the actual stack-trace. Error text: ${error.errorMessage}\n${currentUI.toPrettyTree()}")
+        throw AssertionError("An internal server error occurred; please check log for the actual stack-trace. Error text: ${errorMessage(error)}\n${currentUI().toPrettyTree()}")
     }
-    return descendants.filter { it.isEffectivelyVisible() && predicate(it) }
+    return descendants.filter { isEffectivelyVisible(it) && predicate(it) }
 }
 
 /**
@@ -253,7 +261,7 @@ private fun <T> Iterable<(T) -> Boolean>.and(): (T) -> Boolean =
  * then its next sibling.
  */
 fun Component._walkAll(): Iterable<Component> = Iterable {
-    DepthFirstTreeIterator(this) { component: Component -> testingLifecycleHook.getAllChildren(component) }
+    DepthFirstTreeIterator(this) { component: Component -> TestingLifecycleHooks.getCurrent().getAllChildren(component) }
 }
 
 /**
@@ -297,7 +305,7 @@ inline fun <reified T: Component> _expectNone(noinline block: SearchSpec<T>.()->
  * @throws IllegalArgumentException if one or more components matched.
  */
 fun <T: Component> _expectNone(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}) {
-    currentUI._expectNone(clazz, block)
+    currentUI()._expectNone(clazz, block)
 }
 
 /**
@@ -331,7 +339,7 @@ inline fun <reified T : Component> _expectOne(noinline block: SearchSpec<T>.() -
  * @throws AssertionError if none, or more than one components matched.
  */
 fun <T : Component> _expectOne(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
-    currentUI._expectOne(clazz, block)
+    currentUI()._expectOne(clazz, block)
 }
 
 /**
@@ -399,7 +407,7 @@ inline fun <reified T : Component> _expect(count: Int = 1, noinline block: Searc
  * @throws AssertionError if incorrect count of component matched.
  */
 fun <T : Component> _expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T>.() -> Unit = {}) {
-    currentUI._expect(clazz, count, block)
+    currentUI()._expect(clazz, count, block)
 }
 
 /**
@@ -407,15 +415,15 @@ fun <T : Component> _expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T
  * with given [expectedErrorMessage].
  */
 fun _expectInternalServerError(expectedErrorMessage: String = "") {
-    testingLifecycleHook.awaitBeforeLookup()
-    val descendants: List<Component> = currentUI._walkAll().toList()
-    testingLifecycleHook.awaitAfterLookup()
+    TestingLifecycleHooks.getCurrent().awaitBeforeLookup()
+    val descendants: List<Component> = currentUI()._walkAll().toList()
+    TestingLifecycleHooks.getCurrent().awaitAfterLookup()
     val error: InternalServerError? = descendants.filterIsInstance<InternalServerError>().firstOrNull()
     if (error == null) {
-        throw AssertionError("Expected an internal server error but none happened. Component tree:\n${currentUI.toPrettyTree()}")
+        throw AssertionError("Expected an internal server error but none happened. Component tree:\n${currentUI().toPrettyTree()}")
     }
-    if (!error.errorMessage.contains(expectedErrorMessage)) {
-        throw AssertionError("Expected InternalServerError with message '$expectedErrorMessage' but was '${error.errorMessage}'. Component tree:\n${currentUI.toPrettyTree()}")
+    if (!errorMessage(error).contains(expectedErrorMessage)) {
+        throw AssertionError("Expected InternalServerError with message '$expectedErrorMessage' but was '${errorMessage(error)}'. Component tree:\n${currentUI().toPrettyTree()}")
     }
 }
 
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Matches.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Matches.kt
new file mode 100644
index 00000000..8e54ae82
--- /dev/null
+++ b/shared/src/main/kotlin/com/vaadin/browserless/internal/Matches.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal
+
+import com.vaadin.flow.component.Component
+
+/**
+ * Checks whether this component matches given spec. All rules are matched except the [count] rule. The
+ * rules are matched against given component only (not against its children).
+ *
+ * Stays Kotlin until [SearchSpec] is ported, since it takes a Kotlin DSL block.
+ */
+fun Component.matches(spec: SearchSpec<Component>.() -> Unit): Boolean =
+    SearchSpec(Component::class.java).apply { spec() }.toPredicate().invoke(this)
+
+/**
+ * Size of the [IntRange], used by the `Grid._dump()` implementation.
+ *
+ * Stays Kotlin until `Grid.kt` is ported.
+ */
+val IntRange.size: Int get() = (endInclusive + 1 - start).coerceAtLeast(0)
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
index e7c5f02c..378d2014 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
@@ -51,6 +51,9 @@ import com.vaadin.flow.server.WrappedHttpSession
 import com.vaadin.flow.shared.communication.PushMode
 import com.vaadin.browserless.BrowserlessConfiguration
 import com.vaadin.browserless.BrowserlessTestSetupException
+import com.vaadin.browserless.internal.BasicUtils._close
+import com.vaadin.browserless.internal.Utils.isInitialized
+import com.vaadin.browserless.internal.Utils.mock
 import com.vaadin.browserless.mocks.MockHttpSession
 import com.vaadin.browserless.mocks.MockRequest
 import com.vaadin.browserless.mocks.MockResponse
@@ -179,7 +182,7 @@ object MockVaadin {
                      lookupServices: Set<Class<*>> = emptySet(),
                      configuration: BrowserlessConfiguration = BrowserlessConfiguration.empty()
     ): VaadinServletService {
-        if (!servlet.isInitialized) {
+        if (!isInitialized(servlet)) {
             // Lookup services can be given both explicitly and through the configuration
             // (e.g. by a @BrowserlessTestConfig annotation); they accumulate.
             val ctx: ServletContext = MockVaadinHelper.createMockContext(
@@ -255,7 +258,7 @@ object MockVaadin {
         // recreation) reuses it, keeping @PreserveOnRefresh's cache key stable.
         lastWindowName.set(ui.internals.extendedClientDetails.windowName)
         if (ui.isClosing && ui.internals.session != null) {
-            ui._close()
+            _close(ui)
         }
         if (fireUIDetach) {
             ComponentUtil.onComponentDetach(ui)
@@ -479,7 +482,7 @@ object MockVaadin {
         checkNotNull(VaadinSession.getCurrent()) { "No VaadinSession" }
         runUIQueue()
         UI.getCurrent().internals.stateTree.runExecutionsBeforeClientResponse()
-        cleanupDialogs()
+        TestingLifecycleHooks.cleanupDialogs()
     }
 
     /**
@@ -570,7 +573,7 @@ object MockVaadin {
         if (!currentlyClosingSession.get()) {
             // Vaadin 20.0.5+: closing session also clears the wrapped VaadinSession.getSession().
             // Acquire the wrapped session beforehand.
-            val mockSession: MockHttpSession = session.mock
+            val mockSession: MockHttpSession = mock(session)
             clearVaadinInstances(true)
             mockSession.destroy()
             createSession(mockSession.servletContext, uiFactory)
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt
index 4cf6d5a0..473c70a5 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt
@@ -28,6 +28,13 @@ import com.vaadin.flow.component.button.Button
 import com.vaadin.flow.component.grid.Grid
 import com.vaadin.flow.component.html.Anchor
 import com.vaadin.flow.component.icon.Icon
+import com.vaadin.browserless.internal.BasicUtils._isVisible
+import com.vaadin.browserless.internal.BasicUtils._text
+import com.vaadin.browserless.internal.ComponentUtils.caption
+import com.vaadin.browserless.internal.ComponentUtils.dataProvider
+import com.vaadin.browserless.internal.ComponentUtils.label
+import com.vaadin.browserless.internal.Utils.ellipsize
+import com.vaadin.browserless.internal.Utils.hasCustomToString
 import com.vaadin.browserless.internal.PrettyPrintTree.Companion.ofVaadin
 
 
@@ -69,7 +76,7 @@ class PrettyPrintTree(val name: String, val children: MutableList<PrettyPrintTre
 
         fun ofVaadin(root: Component): PrettyPrintTree {
             val result = PrettyPrintTree(root.toPrettyString(), mutableListOf())
-            for (child: Component in testingLifecycleHook.getAllChildren(root)) {
+            for (child: Component in TestingLifecycleHooks.getCurrent().getAllChildren(root)) {
                 result.children.add(ofVaadin(child))
             }
             return result
@@ -95,7 +102,7 @@ fun Component.toPrettyString(): String {
     if (id.isPresent) {
         list.add("#${id.get()}")
     }
-    if (!_isVisible) {
+    if (!_isVisible(this)) {
         list.add("INVIS")
     }
     if (this is HasValue<*, *> && (this as HasValue<HasValue.ValueChangeEvent<Any?>, Any?>).isReadOnly) {
@@ -104,14 +111,14 @@ fun Component.toPrettyString(): String {
     if (!element.isEnabled) {
         list.add("DISABLED")
     }
-    if (label.isNotBlank()) {
-        list.add("label='$label'")
+    if (label(this).isNotBlank()) {
+        list.add("label='${label(this)}'")
     }
-    if (label != caption && caption.isNotBlank()) {
-        list.add("caption='$caption'")
+    if (label(this) != caption(this) && caption(this).isNotBlank()) {
+        list.add("caption='${caption(this)}'")
     }
-    if (!_text.isNullOrBlank() && _text != caption) {
-        list.add("text='$_text'")
+    if (!_text(this).isNullOrBlank() && _text(this) != caption(this)) {
+        list.add("text='${_text(this)}'")
     }
     if (this is HasValue<*, *>) {
         list.add("value='${(this as HasValue<HasValue.ValueChangeEvent<Any?>, Any?>).value}'")
@@ -151,13 +158,13 @@ fun Component.toPrettyString(): String {
     }
     if (this is Html) {
         val outerHtml: String = this.element.outerHTML.trim().replace(Regex("\\s+"), " ")
-        list.add(outerHtml.ellipsize(100))
+        list.add(ellipsize(outerHtml, 100))
     }
     if (this is Grid<*> && this.beanType != null) {
         list.add("<${this.beanType.simpleName}>")
     }
-    if (this.dataProvider != null) {
-        list.add("dataprovider='${this.dataProvider}'")
+    if (dataProvider(this) != null) {
+        list.add("dataprovider='${dataProvider(this)}'")
     }
     element.attributeNames
         .filter { !dontDumpAttributes.contains(it) }
@@ -173,7 +180,7 @@ fun Component.toPrettyString(): String {
             element.getProperty("innerHTML").trim().replace(Regex("\\s+"), " ")
         list.add("innerHTML='$innerHTML'")
     }
-    if (this.javaClass.hasCustomToString()) {
+    if (hasCustomToString(this.javaClass)) {
         // by default Vaadin components do not introduce toString() at all;
         // toString() therefore defaults to Object's toString() which is useless. However,
         // if a component does introduce a toString() then use it - it could provide
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Renderers.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Renderers.kt
deleted file mode 100644
index 3213318b..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Renderers.kt
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.data.renderer.BasicRenderer
-import com.vaadin.flow.data.renderer.ComponentRenderer
-import com.vaadin.flow.data.renderer.Renderer
-import com.vaadin.flow.data.renderer.TextRenderer
-import com.vaadin.flow.function.ValueProvider
-import org.jsoup.Jsoup
-import java.lang.reflect.Field
-import java.lang.reflect.Method
-
-private val _BasicRenderer_getFormattedValue: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val getFormattedValueM: Method = BasicRenderer::class.java.declaredMethods
-        .first { it.name == "getFormattedValue" }
-    getFormattedValueM.isAccessible = true
-    getFormattedValueM
-}
-
-/**
- * Returns the output of this renderer for given [rowObject] formatted as close as possible
- * to the client-side output.
- */
-fun <T> Renderer<T>._getPresentationValue(rowObject: T): String? = when {
-    this is BasicRenderer<T, *> -> {
-        val value: Any? = this.valueProvider.apply(rowObject)
-        _BasicRenderer_getFormattedValue.invoke(this, value) as String?
-    }
-    this is TextRenderer<T> -> {
-        renderText(rowObject)
-    }
-    this is ComponentRenderer<*, T> -> {
-        val component: Component = createComponent(rowObject)
-        component.toPrettyString()
-    }
-    this::class.simpleName == "LitRenderer" -> {
-        // LitRenderer re-declares private members
-        val templateProperty = this::class.java.getDeclaredField("templateExpression")
-        templateProperty.isAccessible = true
-        val templateExpression = templateProperty.get(this) as String
-
-        val valueProvidersProperty = this::class.java.getDeclaredField("valueProviders")
-        valueProvidersProperty.isAccessible = true
-        val valueProviders = valueProvidersProperty.get(this) as Map<String, ValueProvider<T, *>>
-
-        val renderedLitTemplateHtml: String = renderLitTemplate(templateExpression, valueProviders, rowObject)
-        Jsoup.parse(renderedLitTemplateHtml).textRecursively
-    }
-    else -> null
-}
-
-fun <T> renderLitTemplate(template: String, valueProviders: Map<String, ValueProvider<T, *>>, item: T): String {
-    var renderedTemplate = template;
-    valueProviders.forEach { (k: String, v: ValueProvider<T, *>) ->
-        if (renderedTemplate.contains("\${item.$k}")) {
-            renderedTemplate = renderedTemplate.replace("\${item.$k}", v.apply(item).toString())
-        }
-    }
-    return renderedTemplate
-}
-
-/**
- * Returns the text rendered for given [item].
- */
-@Suppress("UNCHECKED_CAST")
-fun <T> TextRenderer<T>.renderText(item: T): String =
-    createComponent(item).element.text
-
-private val _BasicRenderer_valueProvider: Field by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val javaField: Field = BasicRenderer::class.java.getDeclaredField("valueProvider")
-    javaField.isAccessible = true
-    javaField
-}
-
-/**
- * Returns the [ValueProvider] set to [BasicRenderer].
- */
-@Suppress("UNCHECKED_CAST", "ConflictingExtensionProperty")
-val <T, V> BasicRenderer<T, V>.valueProvider: ValueProvider<T, V>
-    get() = _BasicRenderer_valueProvider.get(this) as ValueProvider<T, V>
-
-private val _Renderer_template: Field by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val templateF: Field = Renderer::class.java.getDeclaredField("template")
-    templateF.isAccessible = true
-    templateF
-}
-
-/**
- * Returns the Polymer Template set to the [Renderer].
- */
-val Renderer<*>.template: String
-    get() {
-        val template: String? = _Renderer_template.get(this) as String?
-        return template ?: ""
-    }
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt
index c243a8d8..33fa1eb7 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt
@@ -33,6 +33,8 @@ import com.vaadin.flow.router.RouterLayout
 import com.vaadin.flow.router.internal.DefaultErrorHandler
 import com.vaadin.flow.server.HttpStatusCode
 import com.vaadin.flow.server.VaadinContext
+import com.vaadin.browserless.internal.Utils.getContext
+import com.vaadin.browserless.internal.Utils.isRouteNotFound
 import com.vaadin.flow.server.startup.ApplicationRouteRegistry
 import com.vaadin.flow.server.startup.RouteRegistryInitializer
 import io.github.classgraph.ClassGraph
@@ -65,8 +67,8 @@ data class Routes(
     @Suppress("UNCHECKED_CAST")
     fun register(sc: VaadinContext) {
         val classSet: Set<Class<*>> = routes.toSet<Class<*>>() + layouts
-        RouteRegistryInitializer().onStartup(classSet, sc.context)
-        checkNotNull(sc.context.getAttribute("com.vaadin.flow.server.startup.ApplicationRouteRegistry${'$'}ApplicationRouteRegistryWrapper")) {
+        RouteRegistryInitializer().onStartup(classSet, getContext(sc))
+        checkNotNull(getContext(sc).getAttribute("com.vaadin.flow.server.startup.ApplicationRouteRegistry${'$'}ApplicationRouteRegistryWrapper")) {
             "RouteRegistryInitializer did not register the ApplicationRouteRegistry!"
         }
         val registry: ApplicationRouteRegistry = ApplicationRouteRegistry.getInstance(sc)
@@ -130,7 +132,7 @@ data class Routes(
     private fun cleanupErrorRoutes() {
         // https://github.com/mvysny/karibu-testing/issues/50
         // if the app defines its own NotFoundException handler, remove MockRouteNotFoundError
-        if (errorRoutes.any { it != MockRouteNotFoundError::class.java && it.isRouteNotFound }) {
+        if (errorRoutes.any { it != MockRouteNotFoundError::class.java && isRouteNotFound(it) }) {
             errorRoutes.remove(MockRouteNotFoundError::class.java)
         }
 
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Shortcuts.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Shortcuts.kt
deleted file mode 100644
index e59737be..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Shortcuts.kt
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.Key
-import com.vaadin.flow.component.ShortcutRegistration
-import com.vaadin.flow.internal.JacksonUtils
-import tools.jackson.databind.JsonNode
-import tools.jackson.databind.node.ObjectNode
-
-/**
- * Take a look at `DomEventListenerWrapper.matchesFilter()` to see why this is necessary.
- * If this stuff stops working, place a breakpoint into the [getBoolean]/[hasKey] function,
- * to see what kind of keys you're receiving and whether it matches [filter].
- */
-private class MockFilterJsonObject(val key: Key, val modifiers: Set<Key>) : ObjectNode(
-    JacksonUtils.getMapper().nodeFactory
-) {
-    val filter: String
-    var filterString: String = ""
-    init {
-
-        // compute the filter
-        filter = mgenerateEventKeyFilter.invoke(null, key).toString() + " && " +
-                // we call the private method with Hashable keys implementations as the ShortcutRegistration class is
-                // called by these objects/classes in regular cases.
-                mgenerateEventModifierFilter.invoke(null, modifiers.map { getHashableKey(it)}).toString()
-
-        // populate the json object so that KeyDownEvent can be created from it
-        put("event.key", key.keys.first())
-    }
-
-    /**
-     * Returns a HashableKey instance for the given key modifier.
-     * @param keyModifier the key modifier
-     * @return the HashableKey instance
-     *
-      */
-    private fun getHashableKey(keyModifier: Key): Any? {
-        return chashableKey.newInstance(keyModifier)
-    }
-
-    override fun has(key: String): Boolean {
-        // the "key" is a JavaScript expression which matches the key pressed.
-        // we need to match it against the 'filter'
-        if (!key.startsWith("([")) {
-            // not a filter
-            return super.get(key) != null
-        }
-        return matchesFilter(key)
-    }
-
-    private fun matchesFilter(key: String): Boolean {
-        // the "key" is a JavaScript expression which matches the key pressed.
-        // we need to match it against the 'filter'
-        val probeFilter = key.removeSuffix(" && (event.stopPropagation() || true)")
-            .removeSuffix(" && (event.preventDefault() || true)")
-        return probeFilter.startsWith(filter)
-    }
-
-    override fun get(keyString: String): JsonNode? {
-        filterString = keyString
-        if (keyString.startsWith("([")) {
-            // For filter key we return this so we get the correct matches
-            // for booleanValue as get returns null
-            return this
-        }
-        return super.get(keyString)
-    }
-
-
-    override fun booleanValue(): Boolean {
-        // the "key" is a JavaScript expression which matches the key pressed.
-        // we need to match it against the 'filter'
-        if (!filterString.startsWith("([")) {
-            // not a filter
-            return super.booleanValue()
-        }
-        return matchesFilter(filterString)
-    }
-
-    companion object {
-        private val mgenerateEventKeyFilter = ShortcutRegistration::class.java.getDeclaredMethod("generateEventKeyFilter", Key::class.java)
-        private val mgenerateEventModifierFilter = ShortcutRegistration::class.java.getDeclaredMethod("generateEventModifierFilter", Collection::class.java)
-        private val chashableKey = ShortcutRegistration::class.java
-            .classLoader
-            .loadClass("com.vaadin.flow.component.ShortcutRegistration\$HashableKey")
-            .declaredConstructors[0]
-        init {
-            mgenerateEventKeyFilter.isAccessible = true
-            mgenerateEventModifierFilter.isAccessible = true
-            chashableKey.isAccessible = true
-        }
-    }
-}
-
-/**
- * Fires a shortcut event with given [key] and [modifiers] in the current UI.
- * This will in turn notify all components currently attached to the current UI
- * which subscribed for this exact key combination.
- */
-public fun fireShortcut(key: Key, vararg modifiers: Key) {
-    // keep the modifiers of type Key[] instead of KeyModifier[], otherwise
-    // you won't be able to call those from Kotlin: https://github.com/vaadin/flow/issues/5051
-    // and https://youtrack.jetbrains.com/issue/KT-35021
-    currentUI._fireShortcut(key, *modifiers)
-}
-
-/**
- * Use the global `fireShortcut()` function unless you know what you're doing!
- */
-public fun Component._fireShortcut(key: Key, vararg modifiers: Key) {
-    // all shortcut registration carry a filter with them, in order to filter out
-    // pressed keys. All the filters are then transferred to the server-side
-    // and compared against DomEventListenerWrapper.filter in
-    // DomEventListenerWrapper.matchesFilter()
-
-    // The `matchesFilter()` function is peculiar: it simply checks whether the data
-    // contains a boolean value with key 'filter'. We need to fake the json object
-    // as if it contained all filters (otherwise `matchesFilter()` would NPE on missing key)
-    // and respond true only to the matching filter.
-    val data = MockFilterJsonObject(key, modifiers.toSet())
-
-    // the shortcut registration is only updated in [UI.beforeClientResponse]; run the registration code now.
-    MockVaadin.clientRoundtrip()
-
-    // this will fire the "keydown" DOM event, which in turn fires KeyDownEvent event,
-    // which in turn invokes the ShortcutListener.
-    _fireDomEvent("keydown", data)
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/TestingLifecycleHook.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/TestingLifecycleHook.kt
deleted file mode 100644
index e1c5804e..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/TestingLifecycleHook.kt
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.lang.reflect.Method
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.ComponentUtil
-import com.vaadin.flow.component.Composite
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.contextmenu.MenuItemBase
-import com.vaadin.flow.component.dialog.Dialog
-import com.vaadin.flow.component.grid.Grid
-import com.vaadin.flow.component.littemplate.LitTemplate
-import com.vaadin.flow.component.menubar.MenuBar
-
-/**
- * If you need to hook into the testing lifecycle (e.g. you need to wait for any async operations to finish),
- * provide your own custom implementation of this interface, then set it into [testingLifecycleHook].
- *
- * ### Mocking server request end
- *
- * Since Browserless Testing runs in the same JVM as the server and there is no browser, the boundaries between the client and
- * the server become unclear. When looking into sources of any test method, it's really hard to tell where exactly the server request ends, and
- * where another request starts.
- *
- * You can establish an explicit client boundary in your test, by explicitly calling [MockVaadin.clientRoundtrip]. However, since that
- * would be both laborous and error-prone, the default operation is that Browserless Testing pretends as if there was a client-server
- * roundtrip before every component lookup
- * via the [_get]/[_find]/[_expectNone]/[_expectOne] call. Therefore, [MockVaadin.clientRoundtrip] is called from [awaitBeforeLookup] by default.
- */
-interface TestingLifecycleHook {
-    /**
-     * Invoked before every component lookup. You can e.g. wait for any async operations to finish and for the server to settle down.
-     *
-     * The default implementation calls the [MockVaadin.clientRoundtrip] method. When implementing this method, you should
-     * also call [MockVaadin.clientRoundtrip] (or simply call super).
-     */
-    fun awaitBeforeLookup() {
-        if (UI.getCurrent() != null) {
-            MockVaadin.clientRoundtrip()
-        }
-    }
-
-    /**
-     * Invoked after every component lookup. You can e.g. wait for any async operations to finish and for the server to settle down.
-     * Invoked even if the `_get()`/`_find()`/`_expectNone()` function fails.
-     */
-    fun awaitAfterLookup() {}
-
-    /**
-     * Provides all children of given component. Provides workarounds for certain components:
-     * * For [Grid] the function will also return the header and footer cell components of all of its columns, plus the column editor components.
-     * * For [MenuItemBase] the function returns all items of a sub-menu.
-     */
-    fun getAllChildren(component: Component): List<Component> = when {
-        component is Grid<*> -> {
-            // Header/footer components live as virtual children of the Column
-            // (or ColumnGroup) they belong to, and both of those branches drop
-            // virtual children on purpose: a component in a merged cell is a
-            // virtual child of every column it spans and would otherwise show
-            // up more than once. Collect them here instead, once per Grid.
-            // see https://github.com/mvysny/karibu-testing/issues/52
-            val headerComponents: List<Component> = component.headerRows
-                    .flatMap { row -> row.cells.map { it.component } }
-                    .filterNotNull()
-            val footerComponents: List<Component> = component.footerRows
-                    .flatMap { row -> row.cells.map { it.component } }
-                    .filterNotNull()
-            val editorComponents: List<Component> = component.columns
-                    .mapNotNull { it.editorComponent }
-            (headerComponents + footerComponents + editorComponents
-                    + component.children.toList()
-                    + ComponentUtil.getAllChildren(component).toList()).distinct()
-        }
-        component is MenuItemBase<*, *, *> -> {
-            // also include component.children: https://github.com/mvysny/karibu-testing/issues/76
-            (component.children.toList() + component.subMenu.items).distinct()
-        }
-
-        component is MenuBar -> {
-            // don't include virtual children since that would make the MenuItems appear two times.
-            component.children.toList()
-        }
-
-        component.isTemplate -> {
-            // don't include virtual children since those will include nested components.
-            // however, those components are only they are only "shallow shells" of components constructed
-            // server-side - almost none of their properties are transferred to the server-side.
-            // Listing those components with null captions and other properties would only be confusing.
-            // Therefore, let's leave the virtual children out for now.
-            // See https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#polymer-templates--lit-templates
-            component.children.toList()
-        }
-
-        component.javaClass.name == "com.vaadin.flow.component.grid.ColumnGroup" -> {
-            // don't include virtual children since that would include the header/footer
-            // components, which the [Grid] branch already reports
-            component.children.toList()
-        }
-
-        component is Grid.Column<*> -> {
-            // don't include virtual children since that would include the header/footer
-            // components, which the [Grid] branch already reports
-            component.children.toList()
-        }
-        component is Composite<*> -> {
-            // The Composite class overrides getChildren() to return a stream with the wrapped component,
-            // but also getElement() returning the Element of the wrapped component.
-            // The latter causes the virtual child to be fetched as Composite direct child,
-            // thus duplicating any virtual children the child component might have.
-            component.children.toList()
-        }
-        // Union the component's own reported children with Flow's element-tree
-        // traversal. Neither source alone is complete: getChildren() may hide
-        // element children (Dialog and Card exclude slotted content) while
-        // ComponentUtil.getAllChildren, which walks the element hierarchy
-        // (regular and virtual children, descending through non-component
-        // wrapper elements), misses children that are not part of the element
-        // tree (ContextMenu keeps its items in a server-side MenuManager list
-        // that getChildren() delegates to). getAllChildren also keeps virtual
-        // children, see https://github.com/mvysny/karibu-testing/issues/85.
-        else -> (component.children.toList()
-                + ComponentUtil.getAllChildren(component).toList()).distinct()
-    }
-
-
-    companion object {
-        /**
-         * A default lifecycle hook that simply runs default implementations of the hook functions.
-         */
-        val default: TestingLifecycleHook
-            get() = object : TestingLifecycleHook {}
-    }
-}
-
-val Component.isTemplate: Boolean
-    get() = this is LitTemplate || isPolymerTemplate(this)
-
-/**
- * If you need to hook into the testing lifecycle (e.g. you need to wait for any async operations to finish),
- * set your custom implementation here. See [TestingLifecycleHook] for more info on
- * where exactly you can hook into.
- */
-var testingLifecycleHook: TestingLifecycleHook = TestingLifecycleHook.default
-
-private val _ConfirmDialog_Class: Class<*>? = findClass("com.vaadin.flow.component.confirmdialog.ConfirmDialog")
-
-private val _ConfirmDialog_isOpened: Method? =
-    _ConfirmDialog_Class?.getMethod("isOpened")
-
-/**
- * Checks whether given [component] is a dialog and needs to be removed from the UI.
- * See [cleanupDialogs] for more info.
- */
-private fun isDialogAndNeedsRemoval(component: Component): Boolean {
-    if (component is Dialog && !component.isOpened) {
-        return true
-    }
-    // also support ConfirmDialog. But be careful - this is a Pro component and may not be on classpath.
-    if (_ConfirmDialog_Class != null && _ConfirmDialog_isOpened != null && _ConfirmDialog_Class.isInstance(
-            component
-        ) && !(_ConfirmDialog_isOpened.invoke(component) as Boolean)
-    ) {
-        return true
-    }
-    return false
-}
-
-/**
- * Flow Server does not close the dialog when [Dialog.close] is called; instead it tells client-side dialog to close,
- * which then fires event back to the server that the dialog was closed, and removes itself from the DOM.
- * Since there's no browser with browserless testing, we need to cleanup closed dialogs manually, hence this method.
- */
-fun cleanupDialogs() {
-    // Starting with Vaadin 23, nested dialogs are also nested within respective
-    // modal dialog within the UI. This is probably related to the "server-side
-    // modality curtain" feature. Also see https://github.com/mvysny/karibu-testing/issues/102
-    UI.getCurrent().walk()
-        .filter { isDialogAndNeedsRemoval(it) }
-        .forEach { it.element.removeFromParent() }
-}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Utils.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Utils.kt
deleted file mode 100644
index d0d02eb6..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Utils.kt
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.io.ByteArrayOutputStream
-import java.io.ObjectInputStream
-import java.io.ObjectOutputStream
-import java.io.Serializable
-import kotlin.jvm.Throws
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.internal.ReflectTools
-import com.vaadin.flow.router.HasErrorParameter
-import com.vaadin.flow.router.NotFoundException
-import com.vaadin.flow.server.VaadinContext
-import com.vaadin.flow.server.VaadinRequest
-import com.vaadin.flow.server.VaadinResponse
-import com.vaadin.flow.server.VaadinService
-import com.vaadin.flow.server.VaadinServletContext
-import com.vaadin.flow.server.VaadinServletRequest
-import com.vaadin.flow.server.VaadinServletResponse
-import com.vaadin.flow.server.VaadinSession
-import com.vaadin.flow.server.WrappedHttpSession
-import com.vaadin.browserless.mocks.MockHttpSession
-import com.vaadin.browserless.mocks.MockRequest
-import com.vaadin.browserless.mocks.MockResponse
-import jakarta.servlet.Servlet
-import jakarta.servlet.ServletContext
-
-
-fun Serializable.serializeToBytes(): ByteArray =
-    ByteArrayOutputStream().use { ObjectOutputStream(it).writeObject(this); it }
-        .toByteArray()
-
-inline fun <reified T : Serializable> ByteArray.deserialize(): T =
-    ObjectInputStream(inputStream()).readObject() as T
-
-inline fun <reified T : Serializable> T.serializeDeserialize(): T =
-    serializeToBytes().deserialize<T>()
-
-val IntRange.size: Int get() = (endInclusive + 1 - start).coerceAtLeast(0)
-
-/**
- * Returns the major JVM version, e.g. 6 for Java 1.6, 8 for Java 8, 11 for Java 11 etc.
- */
-val jvmVersion: Int get() = System.getProperty("java.version").parseJvmVersion()
-
-/**
- * Returns the major JVM version, 1 for 1.1, 2 for 1.2, 3 for 1.3, 4 for 1.4, 5
- * for 1.5 etc.
- */
-internal fun String.parseJvmVersion(): Int {
-    // taken from https://stackoverflow.com/questions/2591083/getting-java-version-at-runtime
-    val version: String = removePrefix("1.").takeWhile { it.isDigit() }
-    return version.toInt()
-}
-
-private val regexWhitespace = Regex("\\s+")
-internal fun String.splitByWhitespaces(): List<String> =
-    split(regexWhitespace).filterNot { it.isBlank() }
-
-internal fun String.containsWhitespace(): Boolean = any { it.isWhitespace() }
-internal fun String.ellipsize(
-    maxLength: Int,
-    ellipsize: String = "..."
-): String {
-    require(maxLength >= ellipsize.length) { "maxLength must be at least the size of ellipsize $ellipsize but it was $maxLength" }
-    return when {
-        (length <= maxLength) || (length <= ellipsize.length) -> this
-        else -> take(maxLength - ellipsize.length) + ellipsize
-    }
-}
-
-/**
- * For a class implementing the [HasErrorParameter] interface, determines the type of
- * the exception handled (the type of `T`). Returns null if the Class doesn't implement the
- * [HasErrorParameter] interface.
- */
-internal fun Class<*>.getErrorParameterType(): Class<*>? =
-    ReflectTools.getGenericInterfaceType(this, HasErrorParameter::class.java)
-
-internal val Class<*>.isRouteNotFound: Boolean
-    get() = getErrorParameterType() == NotFoundException::class.java
-
-val currentRequest: VaadinRequest
-    get() = VaadinService.getCurrentRequest()
-        ?: throw IllegalStateException("No current request. Have you called MockVaadin.setup()?")
-val currentResponse: VaadinResponse
-    get() = VaadinService.getCurrentResponse()
-        ?: throw IllegalStateException("No current response. Have you called MockVaadin.setup()?")
-
-/**
- * Returns the [UI.getCurrent]; fails with informative error message if the UI.getCurrent() is null.
- */
-val currentUI: UI
-    get() = UI.getCurrent()
-        ?: throw IllegalStateException("UI.getCurrent() is null. Have you called MockVaadin.setup()?")
-
-/**
- * Retrieves the mock request which backs up [VaadinRequest].
- * ```
- * currentRequest.mock.addCookie(Cookie("foo", "bar"))
- * ```
- */
-val VaadinRequest.mock: MockRequest get() = (this as VaadinServletRequest).request as MockRequest
-
-/**
- * Retrieves the mock request which backs up [VaadinResponse].
- * ```
- * currentResponse.mock.getCookie("foo").value
- * ```
- */
-val VaadinResponse.mock: MockResponse get() = (this as VaadinServletResponse).response as MockResponse
-
-/**
- * Retrieves the mock session which backs up [VaadinSession].
- * ```
- * VaadinSession.getCurrent().mock
- * ```
- */
-val VaadinSession.mock: MockHttpSession get() = (session as WrappedHttpSession).httpSession as MockHttpSession
-
-val VaadinContext.context: ServletContext get() = (this as VaadinServletContext).context
-
-val Servlet.isInitialized: Boolean get() = servletConfig != null
-
-internal fun Class<*>.hasCustomToString(): Boolean =
-    getMethod("toString").declaringClass != java.lang.Object::class.java
-
-internal val polymerTemplateClass = findClass(
-    "com.vaadin.flow.component.polymertemplate.PolymerTemplate"
-)
-
-internal fun hasPolymerTemplates(): Boolean = polymerTemplateClass != null
-
-internal fun findClass(className: String): Class<*>? {
-    try {
-        return Class.forName(className)
-    } catch (ex: ClassNotFoundException) {
-        try {
-            return Class.forName(
-                className,
-                true,
-                Thread.currentThread().contextClassLoader
-            )
-        } catch (ex: ClassNotFoundException) {
-            return null
-        }
-    }
-}
-
-@Throws(ClassNotFoundException::class)
-internal fun findClassOrThrow(className: String): Class<*>{
-    val clazz = findClass(className)
-    if (clazz == null) {
-        throw ClassNotFoundException(className)
-    }
-    return clazz
-}
\ No newline at end of file
diff --git a/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt b/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
index 0da60122..2cf598ad 100644
--- a/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
+++ b/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
@@ -33,9 +33,9 @@ class AllTests : DynaTest({
 
 
     test("Component.isTemplate") {
-        expect(false) { Button("foo").isTemplate }
-        expect(true) { MyLitTemplate().isTemplate }
-        expect(true) { MyPolymerTemplate().isTemplate }
+        expect(false) { TestingLifecycleHook.isTemplate(Button("foo")) }
+        expect(true) { TestingLifecycleHook.isTemplate(MyLitTemplate()) }
+        expect(true) { TestingLifecycleHook.isTemplate(MyPolymerTemplate()) }
     }
 
 })
diff --git a/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java b/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java
index 3708e0ca..495eea82 100644
--- a/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java
+++ b/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java
@@ -28,7 +28,7 @@
 import org.springframework.web.context.WebApplicationContext;
 import org.springframework.web.context.support.WebApplicationContextUtils;
 
-import com.vaadin.browserless.internal.UtilsKt;
+import com.vaadin.browserless.internal.Utils;
 import com.vaadin.browserless.mocks.MockWebApplicationContext;
 import com.vaadin.browserless.mocks.SpringSecurityRequestCustomizer;
 import com.vaadin.flow.function.VaadinApplicationInitializationBootstrap;
@@ -143,7 +143,7 @@ public void initialize(VaadinContext context,
             VaadinApplicationInitializationBootstrap bootstrap)
             throws ServletException {
         ApplicationContext appCtx = applicationContext.get();
-        ServletContext servletContext = UtilsKt.getContext(context);
+        ServletContext servletContext = Utils.getContext(context);
         WebApplicationContext webAppCtx = WebApplicationContextUtils
                 .getWebApplicationContext(servletContext);
         if (webAppCtx == null) {
diff --git a/spring/src/main/java/com/vaadin/browserless/SpringSecuritySupport.java b/spring/src/main/java/com/vaadin/browserless/SpringSecuritySupport.java
index 9d016344..bab2423f 100644
--- a/spring/src/main/java/com/vaadin/browserless/SpringSecuritySupport.java
+++ b/spring/src/main/java/com/vaadin/browserless/SpringSecuritySupport.java
@@ -17,7 +17,7 @@
 
 import java.util.function.BooleanSupplier;
 
-import com.vaadin.browserless.internal.UtilsKt;
+import com.vaadin.browserless.internal.Utils;
 
 /**
  * Detects whether Spring Security is present on the classpath.
@@ -34,7 +34,7 @@ final class SpringSecuritySupport {
 
     private static final String SECURITY_CONTEXT_HOLDER_CLASS = "org.springframework.security.core.context.SecurityContextHolder";
 
-    private static final BooleanSupplier DEFAULT_DETECTOR = () -> UtilsKt
+    private static final BooleanSupplier DEFAULT_DETECTOR = () -> Utils
             .findClass(SECURITY_CONTEXT_HOLDER_CLASS) != null;
 
     private static volatile BooleanSupplier detector = DEFAULT_DETECTOR;
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
index 591110ee..a2797545 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
@@ -34,7 +34,7 @@
 
 import com.vaadin.browserless.internal.Routes;
 import com.vaadin.browserless.internal.UIFactory;
-import com.vaadin.browserless.internal.UtilsKt;
+import com.vaadin.browserless.internal.Utils;
 import com.vaadin.flow.component.UI;
 import com.vaadin.flow.function.DeploymentConfiguration;
 import com.vaadin.flow.server.ServiceException;
@@ -169,13 +169,13 @@ private static Principal currentPrincipal() {
         }
 
         private static boolean hasSpringSecurity() {
-            return UtilsKt.findClass(
+            return Utils.findClass(
                     "org.springframework.security.core.context.SecurityContextHolder") != null;
         }
 
         private static UnaryOperator<HttpServletRequest> springSecurityRequestWrapper() {
             try {
-                Constructor<?> constructor = UtilsKt.findClassOrThrow(
+                Constructor<?> constructor = Utils.findClassOrThrow(
                         "org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestWrapper")
                         .getConstructor(HttpServletRequest.class, String.class);
                 return req -> {

From bffb5b9516df494b67a269f69efe00db56551433 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 09:08:41 +0000
Subject: [PATCH 04/13] refactor!: port PrettyPrintTree and Routes from Kotlin
 to Java
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Third phase of removing Kotlin from `shared`; `Locator`, `MockVaadin` and `Grid`
are still Kotlin. See `de-kotlin-plan.md`.

`MockRouteNotFoundError` and `MockInternalSeverError` get their own files, since
Java allows one public class per file. `Routes` keeps the constructor overloads
the Kotlin default arguments produced, and its sets are insertion-ordered as
`mutableSetOf()` was, so the route list in a dump and in a `not found` message
stays in a predictable order.

`TreeOnFailureExtension` no longer goes through `PrettyPrintTree.Companion`.
That line only runs when a test fails, so no suite would have caught it.

Breaking changes:

* `PrettyPrintTreeKt` and `RoutesKt` are gone: their functions are statics on
  `PrettyPrintTree` and `Routes`, and `PrettyPrintTree.Companion.ofVaadin(…)`
  becomes `PrettyPrintTree.ofVaadin(…)`.
* `prettyStringHook` takes a `BiConsumer` in place of the Kotlin function type,
  and it and the other two globals move behind accessors:
  `getPrettyPrintUseAscii()`, `getPrettyStringHook()`,
  `getDontDumpAttributes()` and their setters.
* `Routes` loses the members the `data class` generated: `component1()` through
  `component4()`, and `copy(…)` with defaulted arguments. The explicit
  four-argument `copy(…)`, `equals`, `hashCode` and `toString` remain.
* `Routes` fields are behind accessors: `getRoutes()`, `getErrorRoutes()`,
  `getLayouts()`, `getSkipPwaInit()` and `setSkipPwaInit(…)`.
* `MockRouteNotFoundError.cause` is behind `getCause()` and `setCause(…)`.
---
 de-kotlin-plan.md                             |  29 +-
 .../browserless/TreeOnFailureExtension.java   |   2 +-
 .../browserless/internal/MockVaadinTest.kt    |   4 +-
 .../internal/PrettyPrintTreeTest.kt           |   7 +
 .../vaadin/browserless/internal/RoutesTest.kt |  12 +-
 .../vaadin/browserless/ComponentTester.java   |  11 +-
 .../browserless/internal/BasicUtils.java      |  12 +-
 .../internal/MenuItemNavigation.java          |   2 +-
 .../internal/MockInternalSeverError.java      |  61 +++
 .../internal/MockRouteNotFoundError.java      | 100 ++++
 .../browserless/internal/PrettyPrintTree.java | 430 ++++++++++++++++++
 .../browserless/internal/Renderers.java       |   2 +-
 .../vaadin/browserless/internal/Routes.java   | 337 ++++++++++++++
 .../flow/component/gridpro/GridProTester.java |   4 +-
 .../com/vaadin/browserless/component/Grid.kt  |  18 +-
 .../vaadin/browserless/internal/Locator.kt    |  10 +-
 .../browserless/internal/PrettyPrintTree.kt   | 270 -----------
 .../com/vaadin/browserless/internal/Routes.kt | 207 ---------
 18 files changed, 997 insertions(+), 521 deletions(-)
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/Routes.java
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt

diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index e9f3aec2..e9a3c041 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -120,16 +120,25 @@ was written and is live on `main`, and its fallback moved from
 `_getVirtualChildren` to `ComponentUtil.getAllChildren`. Porting the old Java as
 written would have silently reverted both.
 
-### Phase 3 — `PrettyPrintTree` + `Routes`
+### Phase 3 — `PrettyPrintTree` + `Routes` — done
+
+On `refactor/no-kotlin-pretty-routes`. All five suites match the `main`
+baseline: shared 42, junit6 1406, junit6-cdi-tests 4, spring 41, quarkus 31.
 
 `MockRouteNotFoundError` and `MockInternalSeverError` move to their own files
-(Java allows one public class per file). Reconcile against `main`'s rewritten
-`hrefValue()`, which already removed the `kotlin-reflect` usage this phase was
-originally about.
+(Java allows one public class per file). `main`'s `hrefValue()` had already been
+rewritten in plain Java reflection, and it is considerably more thorough than
+what the prior port carried — it walks the class hierarchy reading declared
+methods *and* fields at any visibility, because `Anchor` keeps its `href` in a
+private field. That version is the one to port; the prior port's getter-only
+lookup would have quietly changed what a tree dump shows for an `Anchor`.
+
+`TreeOnFailureExtension` (`PrettyPrintTree.Companion.ofVaadin`) is fixed here.
+Nothing else referenced it, and the line only runs on test failure, so a green
+suite does not catch it.
 
-Fix `junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java:40`
-(`PrettyPrintTree.Companion.ofVaadin`) in this phase. It only runs on test
-failure, so a green suite does not catch it.
+`kotlin-reflect` was already dropped on `main` by `df099d0`, so this phase has
+no dependency change.
 
 ### Phase 4 — `Locator` + `MockVaadin`
 
@@ -227,6 +236,12 @@ top of a Java method that declares checked exceptions.
   `MockHttpEnvironment.INSTANCE.setLocalPort(…)`. The Java port gives the same
   accessor names as statics, so `INSTANCE`-qualified calls break. Same for
   `MockVaadinHelper`.
+- **A `Boolean` property is `getX()`, not `isX()`.** Kotlin only uses the `is`
+  prefix when the property name already starts with `is`, so `var skipPwaInit`
+  compiles to `getSkipPwaInit()` and `var prettyPrintUseAscii` to
+  `getPrettyPrintUseAscii()`. Naming the Java getter the bean-conventional
+  `isSkipPwaInit()` breaks every Kotlin caller using the property syntax, and
+  every Java caller too. Keep Kotlin's name.
 - **`Companion` and other Kotlin synthetics** — `MockContext.Companion`,
   `MockHttpSession.Companion` (whose `create` becomes a real static),
   `MockInstantiator.Companion`, the `$default` bridges behind default arguments,
diff --git a/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java b/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
index b66456b1..e9000f12 100644
--- a/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
+++ b/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
@@ -37,7 +37,7 @@ public void afterTestExecution(ExtensionContext extensionContext) {
         boolean testFailed = extensionContext.getExecutionException()
                 .isPresent();
         if (testFailed) {
-            final String prettyPrintTree = PrettyPrintTree.Companion
+            final String prettyPrintTree = PrettyPrintTree
                     .ofVaadin(UI.getCurrent()).print();
             extensionContext.publishReportEntry("Test "
                     + extensionContext.getTestClass().get().getSimpleName()
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
index 44b70f91..43e3ba36 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
@@ -61,7 +61,7 @@ internal fun DynaNodeGroup.mockVaadinTest() {
 └── MockedUI[]
     └── WelcomeView[@theme='spacing padding']
         └── Text[text='Welcome!']
-""".trim().withSortedThemeNames()) { UI.getCurrent().toPrettyTree().trim().withSortedThemeNames() }
+""".trim().withSortedThemeNames()) { PrettyPrintTree.toPrettyTree(UI.getCurrent()).trim().withSortedThemeNames() }
     }
     afterEach { MockVaadin.tearDown() }
 
@@ -306,7 +306,7 @@ internal fun DynaNodeGroup.mockVaadinTest() {
     └── WelcomeView[@theme='spacing padding']
         └── Text[text='Welcome!']
 """.trim().withSortedThemeNames()
-            ) { UI.getCurrent().toPrettyTree().trim().withSortedThemeNames() }
+            ) { PrettyPrintTree.toPrettyTree(UI.getCurrent()).trim().withSortedThemeNames() }
         }
     }
 
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
index dca54759..249e2fc6 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
@@ -28,6 +28,7 @@ import com.github.mvysny.karibudsl.v10.tooltip
 import com.vaadin.flow.component.Html
 import com.vaadin.flow.component.Text
 import com.vaadin.flow.component.UI
+import com.vaadin.flow.component.Component
 import com.vaadin.flow.component.button.Button
 import com.vaadin.flow.component.contextmenu.ContextMenu
 import com.vaadin.flow.component.formlayout.FormLayout
@@ -364,3 +365,9 @@ private class HtmlSpan(@Language("html") innerHTML: String = "") : Span() {
         this.innerHTML = innerHTML
     }
 }
+
+// Extension shims over the Java statics, so the assertions below keep reading
+// as `component.toPrettyString()` instead of wrapping every one of them.
+private fun Component.toPrettyString(): String = PrettyPrintTree.toPrettyString(this)
+
+private fun Component.toPrettyTree(): String = PrettyPrintTree.toPrettyTree(this)
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
index 9528fa44..a686536a 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
@@ -119,11 +119,13 @@ fun DynaNodeGroup.routesTestBatch() {
     }
 
     test("merge routes") {
-        val routes1 = Routes(mutableSetOf(HelloWorldView::class.java, WelcomeView::class.java,
-                ViewPackagesTestView::class.java, SignalsView::class.java, packagePrivateViewClass),
-                mutableSetOf(ErrorView::class.java))
-        val routes2 = Routes(mutableSetOf(ParametrizedView::class.java, ChildView::class.java, NavigationPostponeView::class.java),
-                mutableSetOf(MockRouteNotFoundError::class.java, MockInternalSeverError::class.java))
+        val routes1 = Routes(
+                mutableSetOf<Class<out Component>>(HelloWorldView::class.java, WelcomeView::class.java,
+                        ViewPackagesTestView::class.java, SignalsView::class.java, packagePrivateViewClass),
+                mutableSetOf<Class<out HasErrorParameter<*>>>(ErrorView::class.java))
+        val routes2 = Routes(
+                mutableSetOf<Class<out Component>>(ParametrizedView::class.java, ChildView::class.java, NavigationPostponeView::class.java),
+                mutableSetOf<Class<out HasErrorParameter<*>>>(MockRouteNotFoundError::class.java, MockInternalSeverError::class.java))
         val merged = routes1.merge(routes2);
         expect(allViews) { merged.routes.toSet() }
         expect(allErrorRoutes) { merged.errorRoutes.toSet() }
diff --git a/shared/src/main/java/com/vaadin/browserless/ComponentTester.java b/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
index dc40ebc4..4b451306 100644
--- a/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
+++ b/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
@@ -29,7 +29,7 @@
 import org.slf4j.LoggerFactory;
 import tools.jackson.databind.node.ObjectNode;
 
-import com.vaadin.browserless.internal.PrettyPrintTreeKt;
+import com.vaadin.browserless.internal.PrettyPrintTree;
 import com.vaadin.flow.component.AbstractCompositeField;
 import com.vaadin.flow.component.AbstractField;
 import com.vaadin.flow.component.Component;
@@ -229,7 +229,7 @@ private static void throwIfNotUsable(Component component,
             Consumer<Consumer<String>> reasonsProvider) {
         if (!usableTest.test(component)) {
             StringBuilder message = new StringBuilder(
-                    PrettyPrintTreeKt.toPrettyString(component)
+                    PrettyPrintTree.toPrettyString(component)
                             + " is not usable");
             Stream.Builder<String> reasons = Stream.builder();
             reasonsProvider.accept(reasons::add);
@@ -300,7 +300,7 @@ protected void ensureVisible() {
     protected static void ensureVisible(Component component) {
         if (!component.isVisible() || !component.isAttached()) {
             throw new IllegalStateException(
-                    PrettyPrintTreeKt.toPrettyString(component)
+                    PrettyPrintTree.toPrettyString(component)
                             + " is not visible!");
         }
     }
@@ -471,9 +471,8 @@ protected <R extends Component> Optional<R> findByQuery(
             StringBuilder message = new StringBuilder(
                     "Expecting the query to produce at most one result, but got ")
                     .append(result.size()).append(": ");
-            message.append(
-                    result.stream().map(PrettyPrintTreeKt::toPrettyString)
-                            .collect(Collectors.joining(", ")));
+            message.append(result.stream().map(PrettyPrintTree::toPrettyString)
+                    .collect(Collectors.joining(", ")));
             throw new IllegalArgumentException(message.toString());
         }
         return Optional.of(result.get(0));
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
index 8d7acd2d..a56dad27 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
@@ -145,7 +145,7 @@ public static String _text(Component component) {
     public static void checkEditableByUser(Component component) {
         if (!isEffectivelyVisible(component)) {
             throw new IllegalStateException("The "
-                    + PrettyPrintTreeKt.toPrettyString(component)
+                    + PrettyPrintTree.toPrettyString(component)
                     + " is not effectively visible - either it is hidden, or its ascendant is hidden");
         }
         boolean parentNullOrEnabled = !component.getParent().isPresent()
@@ -153,13 +153,13 @@ public static void checkEditableByUser(Component component) {
         if (parentNullOrEnabled) {
             if (!component.getElement().isEnabled()) {
                 throw new IllegalStateException(
-                        "The " + PrettyPrintTreeKt.toPrettyString(component)
+                        "The " + PrettyPrintTree.toPrettyString(component)
                                 + " is not enabled");
             }
         }
         if (!isEffectivelyEnabled(component)) {
             throw new IllegalStateException(
-                    "The " + PrettyPrintTreeKt.toPrettyString(component)
+                    "The " + PrettyPrintTree.toPrettyString(component)
                             + " is nested in a disabled component");
         }
         if (component instanceof HasValue) {
@@ -167,13 +167,13 @@ public static void checkEditableByUser(Component component) {
             HasValue<HasValue.ValueChangeEvent<Object>, Object> hasValue = (HasValue) component;
             if (hasValue.isReadOnly()) {
                 throw new IllegalStateException(
-                        "The " + PrettyPrintTreeKt.toPrettyString(component)
+                        "The " + PrettyPrintTree.toPrettyString(component)
                                 + " is read-only");
             }
         }
         if (!component.isAttached()) {
             throw new IllegalStateException(
-                    " The " + PrettyPrintTreeKt.toPrettyString(component)
+                    " The " + PrettyPrintTree.toPrettyString(component)
                             + " is not attached");
         }
     }
@@ -193,7 +193,7 @@ public static void expectNotEditableByUser(Component component) {
             return;
         }
         throw new AssertionError("The "
-                + PrettyPrintTreeKt.toPrettyString(component) + " is editable");
+                + PrettyPrintTree.toPrettyString(component) + " is editable");
     }
 
     static boolean isEffectivelyVisible(Component component) {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MenuItemNavigation.java b/shared/src/main/java/com/vaadin/browserless/internal/MenuItemNavigation.java
index b6164bb1..95344bb7 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/MenuItemNavigation.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MenuItemNavigation.java
@@ -270,7 +270,7 @@ private static void ensureMenuItemIsUsable(MenuItemBase<?, ?, ?> menuItem,
         if (!menuItem.isEnabled() || !menuItem.isVisible()) {
             throw new IllegalStateException(
                     "Menu item " + fullPath + " is not usable. "
-                            + PrettyPrintTreeKt.toPrettyTree(menuItem));
+                            + PrettyPrintTree.toPrettyTree(menuItem));
         }
     }
 }
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java b/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java
new file mode 100644
index 00000000..3a449e26
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import com.vaadin.flow.router.BeforeEnterEvent;
+import com.vaadin.flow.router.ErrorParameter;
+import com.vaadin.flow.router.InternalServerError;
+import com.vaadin.flow.router.internal.DefaultErrorHandler;
+
+/**
+ * Replaces Vaadin's {@link InternalServerError} so that an unhandled exception
+ * is visible to a test.
+ * <p>
+ * The stock view logs the exception and renders nothing that names it, which in
+ * a browserless test means a failure whose cause is only in the log. This one
+ * records the target view, the message, the exception type and the stack trace
+ * as element properties, so a lookup that lands on it can report what actually
+ * went wrong.
+ * <p>
+ * Registered in place of {@link InternalServerError} by {@link Routes}.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+@DefaultErrorHandler
+public class MockInternalSeverError extends InternalServerError {
+
+    @Override
+    public int setErrorParameter(BeforeEnterEvent event,
+            ErrorParameter<Exception> parameter) {
+        getElement().setProperty("targetView", event.getLocation().getPath());
+        if (parameter.hasCustomMessage()) {
+            getElement().setProperty("failureMessage",
+                    parameter.getCustomMessage());
+        } else {
+            getElement().setProperty("failureMessage",
+                    parameter.getException().getMessage());
+        }
+        getElement().setProperty("exceptionType",
+                parameter.getException().getClass().getName());
+        StringWriter sw = new StringWriter();
+        parameter.getException().printStackTrace(new PrintWriter(sw));
+        getElement().setProperty("stackTrace", sw.toString());
+        return super.setErrorParameter(event, parameter);
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java b/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java
new file mode 100644
index 00000000..8389e7b8
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.List;
+import java.util.StringJoiner;
+
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.router.BeforeEnterEvent;
+import com.vaadin.flow.router.ErrorParameter;
+import com.vaadin.flow.router.NotFoundException;
+import com.vaadin.flow.router.RouteData;
+import com.vaadin.flow.router.RouteNotFoundError;
+import com.vaadin.flow.router.internal.DefaultErrorHandler;
+
+/**
+ * Replaces Vaadin's {@code RouteNotFoundError} so that navigating to a route
+ * that was never registered fails with a message naming the routes that were.
+ * <p>
+ * Registered by {@link Routes} by default. An application that handles
+ * {@link com.vaadin.flow.router.NotFoundException} itself takes precedence: in
+ * that case {@link Routes} drops this view, so the application's own error view
+ * is what a test sees.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+@Tag(Tag.DIV)
+@DefaultErrorHandler
+public class MockRouteNotFoundError extends RouteNotFoundError {
+
+    private NotFoundException cause = null;
+
+    /**
+     * Returns the exception describing the failed navigation, built while
+     * handling it.
+     *
+     * @return the cause, or {@code null} if this view has not handled a
+     *         navigation yet
+     */
+    public NotFoundException getCause() {
+        return cause;
+    }
+
+    /**
+     * Sets the exception describing the failed navigation.
+     *
+     * @param cause
+     *            the cause
+     */
+    public void setCause(NotFoundException cause) {
+        this.cause = cause;
+    }
+
+    @Override
+    public int setErrorParameter(BeforeEnterEvent event,
+            ErrorParameter<NotFoundException> parameter) {
+        StringBuilder sb = new StringBuilder();
+        String path = event.getLocation().getPath();
+        sb.append("No route found for '").append(path).append("'");
+        if (parameter.hasCustomMessage()) {
+            sb.append(": ").append(parameter.getCustomMessage());
+        }
+        sb.append("\nAvailable routes: ");
+        List<RouteData> routes = event.getSource().getRegistry()
+                .getRegisteredRoutes();
+        StringJoiner sj = new StringJoiner(", ", "[", "]");
+        for (RouteData rd : routes) {
+            sj.add(toPrettyString(rd));
+        }
+        sb.append(sj.toString());
+        sb.append(
+                "\nIf you'd like to revert back to the original Vaadin RouteNotFoundError, please remove the ")
+                .append(MockRouteNotFoundError.class)
+                .append(" from Routes.errorRoutes");
+        NotFoundException nfe = new NotFoundException(sb.toString());
+        nfe.initCause(parameter.getCaughtException());
+        cause = nfe;
+        return super.setErrorParameter(event, parameter);
+    }
+
+    private static String toPrettyString(RouteData rd) {
+        String template = rd.getTemplate();
+        String path = (template == null || template.isBlank()) ? "<root>"
+                : "/" + template;
+        return rd.getNavigationTarget().getSimpleName() + " at '" + path + "'";
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java b/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
new file mode 100644
index 00000000..7f54541e
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.BiConsumer;
+import java.util.regex.Pattern;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.HasValidation;
+import com.vaadin.flow.component.HasValue;
+import com.vaadin.flow.component.Html;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.grid.Grid;
+import com.vaadin.flow.component.html.Anchor;
+import com.vaadin.flow.component.icon.Icon;
+import com.vaadin.flow.data.provider.DataProvider;
+import com.vaadin.flow.dom.Element;
+
+/**
+ * A pretty-printed ASCII tree of arbitrary nodes, for printing to a console.
+ * <p>
+ * Build it out of any tree structure by giving each node a name and its
+ * children; {@link #ofVaadin(Component)} does that for a Vaadin component tree,
+ * which is what {@code TreeOnFailureExtension} prints when a test fails and
+ * what a failed lookup appends to its error message.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class PrettyPrintTree {
+
+    private static boolean prettyPrintUseAscii = false;
+
+    private static BiConsumer<Component, LinkedList<String>> prettyStringHook = (
+            c, l) -> {
+    };
+
+    private static Set<String> dontDumpAttributes = new HashSet<>(
+            Arrays.asList("disabled", "id", "href"));
+
+    /**
+     * Tells whether the tree is drawn with ASCII characters.
+     *
+     * @return {@code true} if ASCII is used
+     */
+    public static boolean getPrettyPrintUseAscii() {
+        return prettyPrintUseAscii;
+    }
+
+    /**
+     * Draws the tree with {@code \--} instead of {@code └──}, which some
+     * terminals render as {@code ???}.
+     *
+     * @param prettyPrintUseAscii
+     *            {@code true} to use ASCII
+     */
+    public static void setPrettyPrintUseAscii(boolean prettyPrintUseAscii) {
+        PrettyPrintTree.prettyPrintUseAscii = prettyPrintUseAscii;
+    }
+
+    /**
+     * Returns the hook that adds extra properties to a dumped component.
+     *
+     * @return the hook, never {@code null}
+     */
+    public static BiConsumer<Component, LinkedList<String>> getPrettyStringHook() {
+        return prettyStringHook;
+    }
+
+    /**
+     * Installs a hook invoked by {@link #toPrettyString(Component)} to add
+     * properties of a custom component to the dump, e.g.
+     * {@code list.add("icon='" + icon + "'")}. Does nothing by default.
+     *
+     * @param prettyStringHook
+     *            the hook to install
+     */
+    public static void setPrettyStringHook(
+            BiConsumer<Component, LinkedList<String>> prettyStringHook) {
+        PrettyPrintTree.prettyStringHook = prettyStringHook;
+    }
+
+    /**
+     * Returns the attribute names {@link #toPrettyString(Component)} never
+     * dumps. The set is live and directly modifiable.
+     * <p>
+     * Ignored by default: {@code disabled}, which is dumped separately as
+     * {@code DISABLED}; {@code id}, dumped as {@code #id}; and {@code href},
+     * which has its own handling so that it is reported for any component
+     * declaring it, not just an {@link Anchor}.
+     *
+     * @return the ignored attribute names
+     */
+    public static Set<String> getDontDumpAttributes() {
+        return dontDumpAttributes;
+    }
+
+    /**
+     * Replaces the attribute names {@link #toPrettyString(Component)} never
+     * dumps.
+     *
+     * @param dontDumpAttributes
+     *            the attribute names to ignore
+     */
+    public static void setDontDumpAttributes(Set<String> dontDumpAttributes) {
+        PrettyPrintTree.dontDumpAttributes = dontDumpAttributes;
+    }
+
+    private final String name;
+
+    private final List<PrettyPrintTree> children;
+
+    /**
+     * Creates a node.
+     *
+     * @param name
+     *            the text to print for this node
+     * @param children
+     *            this node's children, in print order
+     */
+    public PrettyPrintTree(String name, List<PrettyPrintTree> children) {
+        this.name = name;
+        this.children = children;
+    }
+
+    /**
+     * Returns the text printed for this node.
+     *
+     * @return the node name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Returns this node's children, live and directly modifiable.
+     *
+     * @return the children, in print order
+     */
+    public List<PrettyPrintTree> getChildren() {
+        return children;
+    }
+
+    /**
+     * Renders this node and everything below it.
+     *
+     * @return the rendered tree, one node per line
+     */
+    public String print() {
+        StringBuilder sb = new StringBuilder();
+        print(sb, "", true);
+        return sb.toString();
+    }
+
+    private void print(StringBuilder sb, String prefix, boolean isTail) {
+        char pipe = !prettyPrintUseAscii ? '│' : '|';
+        String branchTail = !prettyPrintUseAscii ? "└── " : "\\-- ";
+        String branch = !prettyPrintUseAscii ? "├── " : "|-- ";
+        sb.append(prefix).append(isTail ? branchTail : branch).append(name)
+                .append("\n");
+        String childPrefix = prefix + (isTail ? "    " : pipe + "   ");
+        for (int i = 0; i < children.size() - 1; i++) {
+            children.get(i).print(sb, childPrefix, false);
+        }
+        if (!children.isEmpty()) {
+            children.get(children.size() - 1).print(sb, childPrefix, true);
+        }
+    }
+
+    public static PrettyPrintTree ofVaadin(Component root) {
+        PrettyPrintTree result = new PrettyPrintTree(toPrettyString(root),
+                new ArrayList<>());
+        for (Component child : TestingLifecycleHooks.getCurrent()
+                .getAllChildren(root)) {
+            result.children.add(ofVaadin(child));
+        }
+        return result;
+    }
+
+    public static String toPrettyTree(Component c) {
+        return PrettyPrintTree.ofVaadin(c).print();
+    }
+
+    private static final Pattern WHITESPACE = Pattern.compile("\\s+");
+
+    private static final Set<String> IGNORED_PROPERTIES = new HashSet<>(
+            Arrays.asList("value", "invalid", "openOn", "label", "errorMessage",
+                    "innerHTML", "i18n", "error", "stackTrace"));
+
+    /**
+     * Returns the most basic properties of the component, formatted as a
+     * concise string: * The component class * The {@link Component#getId} *
+     * Whether the component is {@link Component#isVisible} * Whether it is a
+     * {@link HasValue} that is read-only * the styles * The
+     * {@link Component#label} and text * The {@link HasValue#getValue}
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static String toPrettyString(Component c) {
+        LinkedList<String> list = new LinkedList<>();
+        if (c.getId().isPresent()) {
+            list.add("#" + c.getId().get());
+        }
+        if (!BasicUtils._isVisible(c)) {
+            list.add("INVIS");
+        }
+        if (c instanceof HasValue && ((HasValue) c).isReadOnly()) {
+            list.add("RO");
+        }
+        Element element = c.getElement();
+        if (!element.isEnabled()) {
+            list.add("DISABLED");
+        }
+        String labelText = ComponentUtils.label(c);
+        if (labelText != null && !labelText.isBlank()) {
+            list.add("label='" + labelText + "'");
+        }
+        String captionText = ComponentUtils.caption(c);
+        if (!java.util.Objects.equals(labelText, captionText)
+                && captionText != null && !captionText.isBlank()) {
+            list.add("caption='" + captionText + "'");
+        }
+        String textValue = BasicUtils._text(c);
+        if (textValue != null && !textValue.isBlank()
+                && !java.util.Objects.equals(textValue, captionText)) {
+            list.add("text='" + textValue + "'");
+        }
+        if (c instanceof HasValue) {
+            list.add("value='" + ((HasValue) c).getValue() + "'");
+        }
+        if (c instanceof HasValidation) {
+            HasValidation hv = (HasValidation) c;
+            if (hv.isInvalid()) {
+                list.add("INVALID");
+            }
+            String errorMessage = hv.getErrorMessage();
+            if (errorMessage != null && !errorMessage.isBlank()) {
+                list.add("errorMessage='" + errorMessage + "'");
+            }
+        }
+        /*
+         * TODO: uncomment when importing Grid stuff if (c instanceof
+         * Grid.Column<?>) { if (this.header2.isNotBlank()) {
+         * list.add("header='${this.header2}'") } if (!this.key.isNullOrBlank())
+         * { list.add("key='${this.key}'") } }
+         */
+        // TODO: add a system property to allow verbose pretty print with
+        // ignored attributes
+        for (String propName : element.getPropertyNames().toList()) {
+            String propertyValue = element.getProperty(propName);
+            if (propertyValue != null && !IGNORED_PROPERTIES.contains(propName)
+                    && !propertyValue.isEmpty() && !propName.startsWith("_")) {
+                list.add(propName + "='" + propertyValue + "'");
+            }
+        }
+        // Any component with href should output it not only Anchor
+        Object href = hrefValue(c);
+        if (href != null) {
+            list.add("href='" + href + "'");
+        }
+        if (c instanceof Button && ((Button) c).getIcon() instanceof Icon) {
+            Icon icon = (Icon) ((Button) c).getIcon();
+            list.add("icon='" + icon.getElement().getAttribute("icon") + "'");
+        }
+        if (c instanceof Html) {
+            String outerHtml = WHITESPACE.matcher(element.getOuterHTML().trim())
+                    .replaceAll(" ");
+            list.add(Utils.ellipsize(outerHtml, 100));
+        }
+        if (c instanceof Grid<?> && ((Grid<?>) c).getBeanType() != null) {
+            list.add("<" + ((Grid<?>) c).getBeanType().getSimpleName() + ">");
+        }
+        DataProvider<?, ?> dp = ComponentUtils.dataProvider(c);
+        if (dp != null) {
+            list.add("dataprovider='" + dp + "'");
+        }
+        // the attributes may come in arbitrary order; make sure to sort them,
+        // in order to have predictable order and repeatable tests.
+        TreeSet<String> sortedAttrs = new TreeSet<>();
+        element.getAttributeNames().forEach(a -> {
+            if (!dontDumpAttributes.contains(a)) {
+                sortedAttrs.add(a);
+            }
+        });
+        for (String attributeName : sortedAttrs) {
+            String value = element.getAttribute(attributeName);
+            if (value != null && !value.isBlank()) {
+                list.add("@" + attributeName + "='" + value + "'");
+            }
+        }
+        if (!(c instanceof Html)) {
+            String innerHTML = element.getProperty("innerHTML");
+            if (innerHTML != null && !innerHTML.isBlank()) {
+                String compacted = WHITESPACE.matcher(innerHTML.trim())
+                        .replaceAll(" ");
+                list.add("innerHTML='" + compacted + "'");
+            }
+        }
+        if (Utils.hasCustomToString(c.getClass())) {
+            // by default Vaadin components do not introduce toString() at all;
+            // toString() therefore defaults to Object's toString() which is
+            // useless. However,
+            // if a component does introduce a toString() then use it - it could
+            // provide
+            // valuable information.
+            list.add(c.toString());
+        }
+        prettyStringHook.accept(c, list);
+        String name = c.getClass().getSimpleName();
+        if (name.isEmpty()) {
+            // anonymous classes
+            name = c.getClass().getName();
+        }
+        return name + list;
+    }
+
+    /**
+     * Reads the {@code href} value of the given component, so that
+     * {@link #toPrettyString(Component)} can dump it for any component
+     * declaring it, not just an {@link Anchor}.
+     * <p>
+     * The first member holding a non-blank value wins, looked up in this order:
+     * a no-arg {@code href()} method or an {@code href} field declared anywhere
+     * in the class hierarchy, at any visibility — that is also what a Kotlin
+     * {@code href} property with a backing field compiles to — and finally the
+     * public no-arg {@code href()} and {@code getHref()} methods, which covers
+     * bean getters, Kotlin properties without a backing field and members
+     * inherited from an interface.
+     * <p>
+     * The Java reflection API is used on purpose since it resolves member
+     * metadata lazily: some components have methods referencing classes (e.g.
+     * Spring ones) which may not be present in all projects, and eagerly
+     * scanning all metadata (parameters, generics, ...) would fail for those.
+     *
+     * @param c
+     *            the component to read from
+     * @return the {@code href} value, or {@code null} if this component has
+     *         none
+     */
+    private static Object hrefValue(Component c) {
+        // members declared by the component classes themselves, at any
+        // visibility: Anchor.href e.g. is a private field
+        for (Class<?> clazz = c.getClass(); clazz != null; clazz = clazz
+                .getSuperclass()) {
+            for (Method method : clazz.getDeclaredMethods()) {
+                if ("href".equals(method.getName())
+                        && method.getParameterCount() == 0) {
+                    Object value = readHref(c, method);
+                    if (value != null) {
+                        return value;
+                    }
+                    break;
+                }
+            }
+            for (Field field : clazz.getDeclaredFields()) {
+                if ("href".equals(field.getName())) {
+                    Object value = readHref(c, field);
+                    if (value != null) {
+                        return value;
+                    }
+                    break;
+                }
+            }
+        }
+        // bean getters, e.g. RouterLink.getHref(), and members inherited from
+        // an interface. getMethods() only gets consulted here, since it is the
+        // more expensive call and most components declare no href member at all
+        for (Method method : c.getClass().getMethods()) {
+            if (("href".equals(method.getName())
+                    || "getHref".equals(method.getName()))
+                    && method.getParameterCount() == 0) {
+                Object value = readHref(c, method);
+                if (value != null) {
+                    return value;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Reads the value the given {@code href} member holds for the component.
+     *
+     * @param c
+     *            the component to read from
+     * @param member
+     *            the {@code href} method or field
+     * @return the value, or {@code null} if there is none or it is blank — a
+     *         getter typically reports a missing {@code href} as an empty
+     *         string, e.g. {@link Anchor#getHref()}
+     */
+    private static Object readHref(Component c, AccessibleObject member) {
+        try {
+            member.setAccessible(true);
+            Object value = null;
+            if (member instanceof Method) {
+                value = ((Method) member).invoke(c);
+            } else if (member instanceof Field) {
+                value = ((Field) member).get(c);
+            }
+            return value != null && !value.toString().isBlank() ? value : null;
+        } catch (ReflectiveOperationException | RuntimeException e) {
+            // href is best-effort: a member that cannot be read, or whose
+            // metadata references a class this project does not have, simply
+            // does not contribute to the dump
+            return null;
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java b/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
index 1a7d5fc0..6946395a 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
@@ -97,7 +97,7 @@ public static <T> String _getPresentationValue(Renderer<T> renderer,
                 ComponentRenderer<?, T> componentRenderer = (ComponentRenderer<?, T>) renderer;
                 Component component = componentRenderer
                         .createComponent(rowObject);
-                return PrettyPrintTreeKt.toPrettyString(component);
+                return PrettyPrintTree.toPrettyString(component);
             }
             if (renderer.getClass().getSimpleName().equals("LitRenderer")) {
                 // LitRenderer re-declares private members
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Routes.java b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
new file mode 100644
index 00000000..93e1fcad
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
@@ -0,0 +1,337 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import jakarta.servlet.ServletContext;
+
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.ScanResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.router.HasErrorParameter;
+import com.vaadin.flow.router.InternalServerError;
+import com.vaadin.flow.router.Layout;
+import com.vaadin.flow.router.Route;
+import com.vaadin.flow.router.RouterLayout;
+import com.vaadin.flow.server.VaadinContext;
+import com.vaadin.flow.server.startup.ApplicationRouteRegistry;
+import com.vaadin.flow.server.startup.RouteRegistryInitializer;
+
+/**
+ * The routes, error routes and layouts the mocked environment registers.
+ * <p>
+ * A deployment discovers these by classpath scanning at startup; here the set
+ * is built explicitly, either by hand or with
+ * {@link #autoDiscoverViews(String...)}. Vaadin ignores any route not present,
+ * so a test navigating to a view that was never registered gets a
+ * {@code not found} rather than the view.
+ * <p>
+ * Scanning is the slow part of setting a test up, so build one instance and
+ * reuse it across setups.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class Routes implements Serializable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Routes.class);
+
+    private final Set<Class<? extends Component>> routes;
+
+    private final Set<Class<? extends HasErrorParameter<?>>> errorRoutes;
+
+    private final Set<Class<? extends RouterLayout>> layouts;
+
+    private boolean skipPwaInit;
+
+    public Routes() {
+        this(new LinkedHashSet<>(), defaultErrorRoutes(), new LinkedHashSet<>(),
+                true);
+    }
+
+    public Routes(Set<Class<? extends Component>> routes,
+            Set<Class<? extends HasErrorParameter<?>>> errorRoutes) {
+        this(routes, errorRoutes, new LinkedHashSet<>(), true);
+    }
+
+    public Routes(Set<Class<? extends Component>> routes,
+            Set<Class<? extends HasErrorParameter<?>>> errorRoutes,
+            Set<Class<? extends RouterLayout>> layouts) {
+        this(routes, errorRoutes, layouts, true);
+    }
+
+    public Routes(Set<Class<? extends Component>> routes,
+            Set<Class<? extends HasErrorParameter<?>>> errorRoutes,
+            Set<Class<? extends RouterLayout>> layouts, boolean skipPwaInit) {
+        this.routes = routes;
+        this.errorRoutes = errorRoutes;
+        this.layouts = layouts;
+        this.skipPwaInit = skipPwaInit;
+    }
+
+    /**
+     * Returns the route views to register, live and directly modifiable. Vaadin
+     * ignores any route not in this set.
+     *
+     * @return the route views
+     */
+    public Set<Class<? extends Component>> getRoutes() {
+        return routes;
+    }
+
+    /**
+     * Returns the error views to register, live and directly modifiable.
+     *
+     * @return the error views
+     */
+    public Set<Class<? extends HasErrorParameter<?>>> getErrorRoutes() {
+        return errorRoutes;
+    }
+
+    /**
+     * Returns the {@link Layout}-annotated {@link RouterLayout} classes to
+     * register, live and directly modifiable. These are applied automatically
+     * to routes that do not name a layout in their {@link Route} annotation.
+     *
+     * @return the layouts
+     */
+    public Set<Class<? extends RouterLayout>> getLayouts() {
+        return layouts;
+    }
+
+    /**
+     * Tells whether PWA initialization is skipped.
+     *
+     * @return {@code true} if PWA initialization is skipped
+     */
+    public boolean getSkipPwaInit() {
+        return skipPwaInit;
+    }
+
+    /**
+     * Skips Vaadin's PWA initialization, which takes the environment setup from
+     * roughly two seconds down to fifty milliseconds. Since that is almost
+     * always what a test wants, it is skipped by default.
+     *
+     * @param skipPwaInit
+     *            {@code false} to run PWA initialization
+     */
+    public void setSkipPwaInit(boolean skipPwaInit) {
+        this.skipPwaInit = skipPwaInit;
+    }
+
+    private static Set<Class<? extends HasErrorParameter<?>>> defaultErrorRoutes() {
+        Set<Class<? extends HasErrorParameter<?>>> s = new LinkedHashSet<>();
+        s.add(MockRouteNotFoundError.class);
+        return s;
+    }
+
+    /**
+     * Registers all routes to Vaadin 15 registry. Automatically called from
+     * {@link MockVaadin#setup}.
+     */
+    @SuppressWarnings("unchecked")
+    public void register(VaadinContext sc) {
+        Set<Class<?>> classSet = new LinkedHashSet<>();
+        classSet.addAll(routes);
+        classSet.addAll(layouts);
+        ServletContext servletContext = Utils.getContext(sc);
+        try {
+            new RouteRegistryInitializer().onStartup(classSet, servletContext);
+        } catch (jakarta.servlet.ServletException e) {
+            throw new RuntimeException(e);
+        }
+        Object attr = servletContext.getAttribute(
+                "com.vaadin.flow.server.startup.ApplicationRouteRegistry$ApplicationRouteRegistryWrapper");
+        if (attr == null) {
+            throw new IllegalStateException(
+                    "RouteRegistryInitializer did not register the ApplicationRouteRegistry!");
+        }
+        ApplicationRouteRegistry registry = ApplicationRouteRegistry
+                .getInstance(sc);
+        Set<Class<? extends Component>> errorNavTargets = errorRoutes.stream()
+                .map(c -> (Class<? extends Component>) c)
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+        registry.setErrorNavigationTargets(errorNavTargets);
+        if (skipPwaInit) {
+            clearPwaClass(registry);
+        }
+    }
+
+    /**
+     * Auto-discovers everything, registers it into `this` and returns `this`. *
+     * {@link Route}-annotated views go into {@code routes} *
+     * {@link HasErrorParameter} error views go into {@code errorRoutes} After
+     * this function finishes, you can still modify the {@code routes} and
+     * {@code errorRoutes} sets, for example you can clear the
+     * {@code errorRoutes} if there is some kind of misdetection.
+     * 
+     * @param packageNames
+     *            set the package name for the detector to be faster; or provide
+     *            null to scan the whole classpath, but this is quite slow.
+     * @return this
+     */
+    @SuppressWarnings("unchecked")
+    public Routes autoDiscoverViews(String... packageNames) {
+        String[] effectivePackages = new String[packageNames.length];
+        for (int i = 0; i < packageNames.length; i++) {
+            effectivePackages[i] = packageNames[i] != null ? packageNames[i]
+                    : "";
+        }
+        ClassGraph classGraph = new ClassGraph().enableClassInfo()
+                .enableAnnotationInfo().ignoreClassVisibility()
+                .acceptPackages(effectivePackages);
+        try (ScanResult scanResult = classGraph.scan()) {
+            for (ClassInfo info : scanResult
+                    .getClassesWithAnnotation(Route.class.getName())) {
+                routes.add(scanResult.loadClass(info.getName(), Component.class,
+                        false));
+            }
+            for (ClassInfo info : scanResult.getClassesImplementing(
+                    HasErrorParameter.class.getName())) {
+                @SuppressWarnings("rawtypes")
+                Class<? extends HasErrorParameter> raw = scanResult.loadClass(
+                        info.getName(), HasErrorParameter.class, false);
+                errorRoutes.add((Class<? extends HasErrorParameter<?>>) raw);
+            }
+            for (ClassInfo info : scanResult
+                    .getClassesWithAnnotation(Layout.class.getName())) {
+                if (info.implementsInterface(RouterLayout.class.getName())) {
+                    layouts.add(scanResult.loadClass(info.getName(),
+                            RouterLayout.class, false));
+                }
+            }
+        }
+
+        cleanupErrorRoutes();
+
+        LOG.debug("Auto-discovered views: {}", this);
+        return this;
+    }
+
+    public Routes merge(Routes other) {
+        Routes result = new Routes(new LinkedHashSet<>(this.routes),
+                new LinkedHashSet<>(this.errorRoutes),
+                new LinkedHashSet<>(this.layouts), this.skipPwaInit);
+        result.routes.addAll(other.routes);
+        result.errorRoutes.addAll(other.errorRoutes);
+        result.layouts.addAll(other.layouts);
+        result.cleanupErrorRoutes();
+        return result;
+    }
+
+    private void cleanupErrorRoutes() {
+        // https://github.com/mvysny/karibu-testing/issues/50
+        // if the app defines its own NotFoundException handler, remove
+        // MockRouteNotFoundError
+        boolean hasCustomNotFoundHandler = false;
+        for (Class<? extends HasErrorParameter<?>> c : errorRoutes) {
+            if (c != MockRouteNotFoundError.class && Utils.isRouteNotFound(c)) {
+                hasCustomNotFoundHandler = true;
+                break;
+            }
+        }
+        if (hasCustomNotFoundHandler) {
+            errorRoutes.remove(MockRouteNotFoundError.class);
+        }
+
+        // Replace default InternalServeError exception handler with an
+        // implementation that exposes error details for PrettyPrinter
+        errorRoutes.remove(InternalServerError.class);
+        errorRoutes.add(MockInternalSeverError.class);
+    }
+
+    /**
+     * Creates a copy of this Routes with optional field overrides. Mirrors the
+     * Kotlin data-class `copy(...)` method.
+     */
+    public Routes copy(Set<Class<? extends Component>> routes,
+            Set<Class<? extends HasErrorParameter<?>>> errorRoutes,
+            Set<Class<? extends RouterLayout>> layouts, boolean skipPwaInit) {
+        return new Routes(routes, errorRoutes, layouts, skipPwaInit);
+    }
+
+    @Override
+    public String toString() {
+        return "Routes(routes=" + joinSimpleNames(routes) + ", errorRoutes="
+                + joinSimpleNames(errorRoutes) + ", layouts="
+                + joinSimpleNames(layouts) + ")";
+    }
+
+    private static String joinSimpleNames(Set<? extends Class<?>> classes) {
+        StringBuilder sb = new StringBuilder();
+        Iterator<? extends Class<?>> it = classes.iterator();
+        while (it.hasNext()) {
+            sb.append(it.next().getSimpleName());
+            if (it.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof Routes)) {
+            return false;
+        }
+        Routes other = (Routes) o;
+        return skipPwaInit == other.skipPwaInit
+                && Objects.equals(routes, other.routes)
+                && Objects.equals(errorRoutes, other.errorRoutes)
+                && Objects.equals(layouts, other.layouts);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(routes, errorRoutes, layouts, skipPwaInit);
+    }
+
+    /**
+     * Clears the PWA class config from this registry.
+     */
+    @SuppressWarnings("unchecked")
+    public static void clearPwaClass(ApplicationRouteRegistry registry) {
+        try {
+            Field pwaClassField = ApplicationRouteRegistry.class
+                    .getDeclaredField("pwaConfigurationClass");
+            pwaClassField.setAccessible(true);
+            AtomicReference<Class<?>> ref = (AtomicReference<Class<?>>) pwaClassField
+                    .get(registry);
+            ref.set(null);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+        if (registry.getPwaConfigurationClass() != null) {
+            throw new AssertionError(
+                    "PWA configuration class should have been removed");
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/flow/component/gridpro/GridProTester.java b/shared/src/main/java/com/vaadin/flow/component/gridpro/GridProTester.java
index 7c079d53..140dcea9 100644
--- a/shared/src/main/java/com/vaadin/flow/component/gridpro/GridProTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/gridpro/GridProTester.java
@@ -18,7 +18,7 @@
 import tools.jackson.databind.node.ObjectNode;
 
 import com.vaadin.browserless.Tests;
-import com.vaadin.browserless.internal.PrettyPrintTreeKt;
+import com.vaadin.browserless.internal.PrettyPrintTree;
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.ComponentUtil;
 import com.vaadin.flow.component.grid.GridTester;
@@ -80,7 +80,7 @@ public void setValue(int rowIndex, int columnIndex, Object value) {
                 var field = editColumn.getEditorField();
                 ensureComponentIsUsable((Component) field, f -> isUsable(f));
                 if (field.isReadOnly()) {
-                    throw new IllegalStateException(PrettyPrintTreeKt
+                    throw new IllegalStateException(PrettyPrintTree
                             .toPrettyString((Component) field)
                             + " is not usable because it is read only.");
                 }
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt b/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
index e1482fa7..60c061d7 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
@@ -61,7 +61,7 @@ import com.vaadin.browserless.internal.BasicUtils.checkEditableByUser
 import com.vaadin.browserless.internal.filterNotBlank
 import com.vaadin.browserless.internal.size
 import com.vaadin.browserless.internal.Renderers.template
-import com.vaadin.browserless.internal.toPrettyString
+import com.vaadin.browserless.internal.PrettyPrintTree.toPrettyString
 import java.lang.reflect.Method
 import java.lang.reflect.Field
 import java.util.stream.Stream
@@ -273,7 +273,7 @@ public fun Grid<*>._size(): Int {
  * @throws AssertionError if no such column exists.
  */
 public fun <T> Grid<T>._getColumnByKey(columnKey: String): Grid.Column<T> = getColumnByKey(columnKey)
-        ?: throw AssertionError("${toPrettyString()}: No such column with key '$columnKey'; available columns: ${columns.mapNotNull { it.key }}")
+        ?: throw AssertionError("${toPrettyString(this)}: No such column with key '$columnKey'; available columns: ${columns.mapNotNull { it.key }}")
 
 /**
  * Performs a click on a [ClickableRenderer] in given [Grid] cell. Only supports the following scenarios:
@@ -302,10 +302,10 @@ public fun <T> Grid<T>._getColumnByKey(columnKey: String): Grid.Column<T> = getC
 //        } else {
 //            // don't try to do anything smart here since things will break silently for the customer as they upgrade Vaadin version
 //            // https://github.com/mvysny/karibu-testing/issues/67
-//            fail("${this.toPrettyString()} column $columnKey: ComponentRenderer produced ${component.toPrettyString()} which is not a button nor a ClickNotifier - please use _getCellComponent() instead")
+//            fail("${toPrettyString(this)} column $columnKey: ComponentRenderer produced ${toPrettyString(component)} which is not a button nor a ClickNotifier - please use _getCellComponent() instead")
 //        }
 //    } else {
-//        fail("${this.toPrettyString()} column $columnKey has renderer $renderer which is not supported by this method")
+//        fail("${toPrettyString(this)} column $columnKey has renderer $renderer which is not supported by this method")
 //    }
 //}
 
@@ -323,10 +323,10 @@ public fun <T : Any> Grid<T>._getCellComponent(
     val column: Grid.Column<T> = _getColumnByKey(columnKey)
     val renderer: Renderer<T>? = column.renderer
     if (renderer !is ComponentRenderer<*, *>) {
-        throw java.lang.IllegalArgumentException("${this.toPrettyString()} column $columnKey uses renderer $renderer but we expect a ComponentRenderer here")
+        throw java.lang.IllegalArgumentException("${toPrettyString(this)} column $columnKey uses renderer $renderer but we expect a ComponentRenderer here")
     }
     if (renderer is NativeButtonRenderer<*>) {
-        throw java.lang.IllegalArgumentException("${this.toPrettyString()} column $columnKey uses NativeButtonRenderer which is not supported by this function")
+        throw java.lang.IllegalArgumentException("${toPrettyString(this)} column $columnKey uses NativeButtonRenderer which is not supported by this function")
     }
     val item: T = _get(rowIndex)
     val component: Component = (renderer as ComponentRenderer<*, T>).createComponent(item)
@@ -467,7 +467,7 @@ public fun <T : Any> Grid<T>._dump(rows: IntRange = 0..9): String = buildString
 public fun Grid<*>.expectRows(count: Int) {
     val actual = _size()
     if (actual != count) {
-        throw AssertionError("${this.toPrettyString()}: expected $count rows but got $actual\n${_dump()}")
+        throw AssertionError("${toPrettyString(this)}: expected $count rows but got $actual\n${_dump()}")
     }
 }
 
@@ -479,7 +479,7 @@ public fun Grid<*>.expectRow(rowIndex: Int, vararg row: String) {
     val expected: List<String> = row.toList()
     val actual: List<String> = _getFormattedRow(rowIndex)
     if (expected != actual) {
-        throw AssertionError("${this.toPrettyString()} at $rowIndex: expected $expected but got $actual\n${_dump()}")
+        throw AssertionError("${toPrettyString(this)} at $rowIndex: expected $expected but got $actual\n${_dump()}")
     }
 }
 
@@ -787,7 +787,7 @@ public val Component.dataProvider: DataProvider<*, *>? get() = when (this) {
  * mocked properly, calls the editor bindings, and fires the editor-open-event.
  */
 public fun <T> Editor<T>._editItem(item: T) {
-//    expect(true, "${grid.toPrettyString()} is not attached, editItem() would do nothing. Make sure the Grid is attached to an UI") {
+//    expect(true, "${toPrettyString(grid)} is not attached, editItem() would do nothing. Make sure the Grid is attached to an UI") {
 //        grid.isAttached()
 //    }
     if(!grid.isAttached()) throw java.lang.IllegalStateException("Grid is not attached so can not edit")
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
index 0c6347b3..32b3b747 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
@@ -32,6 +32,8 @@ import com.vaadin.browserless.internal.ComponentUtils.isPolymerTemplate
 import com.vaadin.browserless.internal.ComponentUtils.placeholder
 import com.vaadin.browserless.internal.Utils.currentUI
 import com.vaadin.browserless.internal.Utils.hasPolymerTemplates
+import com.vaadin.browserless.internal.PrettyPrintTree.toPrettyString
+import com.vaadin.browserless.internal.PrettyPrintTree.toPrettyTree
 
 /**
  * A criterion for matching components. The component must match all of non-null fields.
@@ -201,7 +203,7 @@ fun <T: Component> Component._find(clazz: Class<T>, block: SearchSpec<T>.()->Uni
             result.size < spec.count.first -> "/$loc: Too few (${result.size}) visible ${clazz.simpleName}s"
             else -> "/$loc: Too many visible ${clazz.simpleName}s (${result.size})"
         }
-        message = "$message in ${toPrettyString()} matching $spec: [${result.joinToString { it.toPrettyString() }}]. Component tree:\n${toPrettyTree()}"
+        message = "$message in ${toPrettyString(this)} matching $spec: [${result.joinToString { toPrettyString(it) }}]. Component tree:\n${toPrettyTree(this)}"
 
         // if there's a PolymerTemplate, warn that Browserless Testing can't really locate components in there:
         // https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#polymer-templates
@@ -245,7 +247,7 @@ private fun Component.find(predicate: (Component)->Boolean): List<Component> {
     TestingLifecycleHooks.getCurrent().awaitAfterLookup()
     val error: InternalServerError? = descendants.filterIsInstance<InternalServerError>().firstOrNull()
     if (error != null) {
-        throw AssertionError("An internal server error occurred; please check log for the actual stack-trace. Error text: ${errorMessage(error)}\n${currentUI().toPrettyTree()}")
+        throw AssertionError("An internal server error occurred; please check log for the actual stack-trace. Error text: ${errorMessage(error)}\n${toPrettyTree(currentUI())}")
     }
     return descendants.filter { isEffectivelyVisible(it) && predicate(it) }
 }
@@ -420,10 +422,10 @@ fun _expectInternalServerError(expectedErrorMessage: String = "") {
     TestingLifecycleHooks.getCurrent().awaitAfterLookup()
     val error: InternalServerError? = descendants.filterIsInstance<InternalServerError>().firstOrNull()
     if (error == null) {
-        throw AssertionError("Expected an internal server error but none happened. Component tree:\n${currentUI().toPrettyTree()}")
+        throw AssertionError("Expected an internal server error but none happened. Component tree:\n${toPrettyTree(currentUI())}")
     }
     if (!errorMessage(error).contains(expectedErrorMessage)) {
-        throw AssertionError("Expected InternalServerError with message '$expectedErrorMessage' but was '${errorMessage(error)}'. Component tree:\n${currentUI().toPrettyTree()}")
+        throw AssertionError("Expected InternalServerError with message '$expectedErrorMessage' but was '${errorMessage(error)}'. Component tree:\n${toPrettyTree(currentUI())}")
     }
 }
 
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt
deleted file mode 100644
index 473c70a5..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-
-import java.lang.reflect.AccessibleObject
-import java.lang.reflect.Field
-import java.lang.reflect.Method
-import java.util.*
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.HasValidation
-import com.vaadin.flow.component.HasValue
-import com.vaadin.flow.component.Html
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.grid.Grid
-import com.vaadin.flow.component.html.Anchor
-import com.vaadin.flow.component.icon.Icon
-import com.vaadin.browserless.internal.BasicUtils._isVisible
-import com.vaadin.browserless.internal.BasicUtils._text
-import com.vaadin.browserless.internal.ComponentUtils.caption
-import com.vaadin.browserless.internal.ComponentUtils.dataProvider
-import com.vaadin.browserless.internal.ComponentUtils.label
-import com.vaadin.browserless.internal.Utils.ellipsize
-import com.vaadin.browserless.internal.Utils.hasCustomToString
-import com.vaadin.browserless.internal.PrettyPrintTree.Companion.ofVaadin
-
-
-/**
- * If true, [PrettyPrintTree] will use `\--` instead of `└──` which tend to render on some terminals as `???`.
- */
-var prettyPrintUseAscii: Boolean = false
-
-/**
- * Utility class to create a pretty-printed ASCII tree of arbitrary nodes that can be printed to the console.
- * You can build the tree out of any tree structure, just fill in this node [name] and its [children].
- *
- * To create a pretty tree dump of a Vaadin component, just use [ofVaadin].
- */
-class PrettyPrintTree(val name: String, val children: MutableList<PrettyPrintTree>) {
-
-    private val pipe = if (!prettyPrintUseAscii) '│' else '|'
-    private val branchTail = if (!prettyPrintUseAscii) "└── " else "\\-- "
-    private val branch = if (!prettyPrintUseAscii) "├── " else "|-- "
-
-    fun print(): String {
-        val sb = StringBuilder()
-        print(sb, "", true)
-        return sb.toString()
-    }
-
-    private fun print(sb: StringBuilder, prefix: String, isTail: Boolean) {
-        sb.append(prefix + (if (isTail) branchTail else branch) + name + "\n")
-        for (i in 0 until children.size - 1) {
-            children[i].print(sb, prefix + if (isTail) "    " else "$pipe   ", false)
-        }
-        if (children.size > 0) {
-            children[children.size - 1]
-                    .print(sb, prefix + if (isTail) "    " else "$pipe   ", true)
-        }
-    }
-
-    companion object {
-
-        fun ofVaadin(root: Component): PrettyPrintTree {
-            val result = PrettyPrintTree(root.toPrettyString(), mutableListOf())
-            for (child: Component in TestingLifecycleHooks.getCurrent().getAllChildren(root)) {
-                result.children.add(ofVaadin(child))
-            }
-            return result
-        }
-    }
-}
-
-fun Component.toPrettyTree(): String = PrettyPrintTree.ofVaadin(this).print()
-
-/**
- * Returns the most basic properties of the component, formatted as a concise string:
- * * The component class
- * * The [Component.getId]
- * * Whether the component is [Component.isVisible]
- * * Whether it is a [HasValue] that is read-only
- * * the styles
- * * The [Component.label] and text
- * * The [HasValue.getValue]
- */
-@Suppress("UNCHECKED_CAST")
-fun Component.toPrettyString(): String {
-    val list = LinkedList<String>()
-    if (id.isPresent) {
-        list.add("#${id.get()}")
-    }
-    if (!_isVisible(this)) {
-        list.add("INVIS")
-    }
-    if (this is HasValue<*, *> && (this as HasValue<HasValue.ValueChangeEvent<Any?>, Any?>).isReadOnly) {
-        list.add("RO")
-    }
-    if (!element.isEnabled) {
-        list.add("DISABLED")
-    }
-    if (label(this).isNotBlank()) {
-        list.add("label='${label(this)}'")
-    }
-    if (label(this) != caption(this) && caption(this).isNotBlank()) {
-        list.add("caption='${caption(this)}'")
-    }
-    if (!_text(this).isNullOrBlank() && _text(this) != caption(this)) {
-        list.add("text='${_text(this)}'")
-    }
-    if (this is HasValue<*, *>) {
-        list.add("value='${(this as HasValue<HasValue.ValueChangeEvent<Any?>, Any?>).value}'")
-    }
-    if (this is HasValidation) {
-        if (this.isInvalid) {
-            list.add("INVALID")
-        }
-        if (!this.errorMessage.isNullOrBlank()) {
-            list.add("errorMessage='$errorMessage'")
-        }
-    }
-    /* TODO: uncomment when importing Grid stuff
-    if (this is Grid.Column<*>) {
-        if (this.header2.isNotBlank()) {
-            list.add("header='${this.header2}'")
-        }
-        if (!this.key.isNullOrBlank()) {
-            list.add("key='${this.key}'")
-        }
-    }
-     */
-    // TODO: add a system property to allow verbose pretty print with ignored attributes
-    val ignoredAttr = mutableListOf("value", "invalid", "openOn", "label", "errorMessage", "innerHTML", "i18n","error", "stackTrace")
-    this.element.propertyNames.forEach {
-        val propertyValue = this.element.getProperty(it)
-        if(propertyValue != null && !ignoredAttr.contains(it) && propertyValue.isNotEmpty() && !it.startsWith("_")) {
-            list.add("${it}='${propertyValue}'")
-        }
-    }
-    // Any component with href should output it not only Anchor
-    hrefValue()?.let {
-        list.add("href='$it'")
-    }
-    if (this is Button && icon is Icon) {
-        list.add("icon='${(icon as Icon).element.getAttribute("icon")}'")
-    }
-    if (this is Html) {
-        val outerHtml: String = this.element.outerHTML.trim().replace(Regex("\\s+"), " ")
-        list.add(ellipsize(outerHtml, 100))
-    }
-    if (this is Grid<*> && this.beanType != null) {
-        list.add("<${this.beanType.simpleName}>")
-    }
-    if (dataProvider(this) != null) {
-        list.add("dataprovider='${dataProvider(this)}'")
-    }
-    element.attributeNames
-        .filter { !dontDumpAttributes.contains(it) }
-        .sorted() // the attributes may come in arbitrary order; make sure to sort them, in order to have predictable order and repeatable tests.
-        .forEach { attributeName ->
-            val value = element.getAttribute(attributeName)
-            if (!value.isNullOrBlank()) {
-                list.add("@$attributeName='$value'")
-            }
-        }
-    if (this !is Html && !element.getProperty("innerHTML").isNullOrBlank()) {
-        val innerHTML =
-            element.getProperty("innerHTML").trim().replace(Regex("\\s+"), " ")
-        list.add("innerHTML='$innerHTML'")
-    }
-    if (hasCustomToString(this.javaClass)) {
-        // by default Vaadin components do not introduce toString() at all;
-        // toString() therefore defaults to Object's toString() which is useless. However,
-        // if a component does introduce a toString() then use it - it could provide
-        // valuable information.
-        list.add(this.toString())
-    }
-    prettyStringHook(this, list)
-    var name: String = javaClass.simpleName
-    if (name.isEmpty()) {
-        // anonymous classes
-        name = javaClass.name
-    }
-    return name + list
-}
-
-/**
- * Reads the `href` value of this component, so that [toPrettyString] can dump it for
- * any component declaring it, not just [Anchor].
- *
- * The first member holding a non-blank value wins, looked up in this order: a no-arg
- * `href()` method or an `href` field declared anywhere in the class hierarchy, at any
- * visibility - that is also what a Kotlin `href` property with a backing field
- * compiles to - and finally the public no-arg `href()` and `getHref()` methods, which
- * covers bean getters, Kotlin properties without a backing field and members
- * inherited from an interface.
- *
- * The Java reflection API is used on purpose since it resolves member metadata lazily:
- * some components have methods referencing classes (e.g. Spring ones) which may not be
- * present in all projects, and eagerly scanning all metadata (parameters, generics, ...)
- * would fail for those.
- *
- * @return the `href` value, or null if this component has none.
- */
-private fun Component.hrefValue(): Any? {
-    // members declared by the component classes themselves, at any visibility:
-    // Anchor.href e.g. is a private field
-    var clazz: Class<*>? = javaClass
-    while (clazz != null) {
-        clazz.declaredMethods
-            .firstOrNull { it.name == "href" && it.parameterCount == 0 }
-            ?.let { method -> readHref(method)?.let { return it } }
-        clazz.declaredFields
-            .firstOrNull { it.name == "href" }
-            ?.let { field -> readHref(field)?.let { return it } }
-        clazz = clazz.superclass
-    }
-    // bean getters, e.g. RouterLink.getHref(), and members inherited from an
-    // interface. getMethods() only gets consulted here, since it is the more
-    // expensive call and most components declare no href member at all
-    javaClass.methods
-        .filter { (it.name == "href" || it.name == "getHref") && it.parameterCount == 0 }
-        .forEach { method -> readHref(method)?.let { return it } }
-    return null
-}
-
-/**
- * Reads the value the given `href` [member] holds for this component.
- *
- * @return the value, or null if there is none or it is blank - a getter typically
- * reports a missing `href` as an empty string, e.g. [Anchor.getHref].
- */
-private fun Component.readHref(member: AccessibleObject): Any? {
-    member.isAccessible = true
-    val value: Any? = when (member) {
-        is Method -> member.invoke(this)
-        is Field -> member.get(this)
-        else -> null
-    }
-    return value?.takeIf { it.toString().isNotBlank() }
-}
-
-/**
- * Invoked by [toPrettyString] to add additional properties for your custom component.
- * Add additional properties to the `list` provided, e.g. `list.add("icon='$icon'")`.
- *
- * By default does nothing.
- */
-var prettyStringHook: (component: Component, list: LinkedList<String>) -> Unit = { _, _ -> }
-
-/**
- * Never dump these attributes in [toPrettyString]. By default these attributes are ignored:
- *
- * * `disabled` - dumped separately as "DISABLED" string.
- * * `id` - dumped as Component.id
- * * `href` - there's special processing for [Anchor._href].
- */
-var dontDumpAttributes: MutableSet<String> = mutableSetOf("disabled", "id", "href")
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt
deleted file mode 100644
index 33fa1eb7..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.io.Serializable
-import java.lang.reflect.Field
-import java.util.concurrent.atomic.AtomicReference
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.Tag
-import com.vaadin.flow.router.BeforeEnterEvent
-import com.vaadin.flow.router.ErrorParameter
-import com.vaadin.flow.router.HasErrorParameter
-import com.vaadin.flow.router.InternalServerError
-import com.vaadin.flow.router.NotFoundException
-import com.vaadin.flow.router.Layout
-import com.vaadin.flow.router.Route
-import com.vaadin.flow.router.RouteData
-import com.vaadin.flow.router.RouteNotFoundError
-import com.vaadin.flow.router.RouterLayout
-import com.vaadin.flow.router.internal.DefaultErrorHandler
-import com.vaadin.flow.server.HttpStatusCode
-import com.vaadin.flow.server.VaadinContext
-import com.vaadin.browserless.internal.Utils.getContext
-import com.vaadin.browserless.internal.Utils.isRouteNotFound
-import com.vaadin.flow.server.startup.ApplicationRouteRegistry
-import com.vaadin.flow.server.startup.RouteRegistryInitializer
-import io.github.classgraph.ClassGraph
-import io.github.classgraph.ClassInfo
-import io.github.classgraph.ScanResult
-import org.slf4j.LoggerFactory
-
-/**
- * A configuration object of all routes and error routes in the application. Simply use [autoDiscoverViews] to discover everything.
- *
- * To speed up the tests, you can create one instance of this class only, then reuse that instance in every
- * call to [MockVaadin.setup].
- * @property routes a list of all route views in your application. Vaadin will ignore any routes not present here.
- * @property errorRoutes a list of all route views in your application. Vaadin will ignore any routes not present here.
- * @property layouts a list of all [Layout]-annotated [RouterLayout] classes. These are automatically applied to routes
- * that do not explicitly specify a layout in their [Route] annotation.
- * @property skipPwaInit if true, the PWA initialization code is skipped in Vaadin, which dramatically speeds up
- * the [MockVaadin.setup] from 2 seconds to 50ms. Since that's usually what you want to do, this defaults to true.
- */
-data class Routes(
-        val routes: MutableSet<Class<out Component>> = mutableSetOf(),
-        val errorRoutes: MutableSet<Class<out HasErrorParameter<*>>> = mutableSetOf(MockRouteNotFoundError::class.java),
-        val layouts: MutableSet<Class<out RouterLayout>> = mutableSetOf(),
-        var skipPwaInit: Boolean = true
-) : Serializable {
-
-    /**
-     * Registers all routes to Vaadin 15 registry. Automatically called from [MockVaadin.setup].
-     */
-    @Suppress("UNCHECKED_CAST")
-    fun register(sc: VaadinContext) {
-        val classSet: Set<Class<*>> = routes.toSet<Class<*>>() + layouts
-        RouteRegistryInitializer().onStartup(classSet, getContext(sc))
-        checkNotNull(getContext(sc).getAttribute("com.vaadin.flow.server.startup.ApplicationRouteRegistry${'$'}ApplicationRouteRegistryWrapper")) {
-            "RouteRegistryInitializer did not register the ApplicationRouteRegistry!"
-        }
-        val registry: ApplicationRouteRegistry = ApplicationRouteRegistry.getInstance(sc)
-        registry.setErrorNavigationTargets(errorRoutes.map { it as Class<out Component> }.toSet())
-        if (skipPwaInit) {
-            registry.clearPwaClass()
-        }
-    }
-
-    /**
-     * Auto-discovers everything, registers it into `this` and returns `this`.
-     * * [Route]-annotated views go into [routes]
-     * * [HasErrorParameter] error views go into [errorRoutes]
-     * After this function finishes, you can still modify the [routes] and [errorRoutes] sets,
-     * for example you can clear the [errorRoutes] if there is some kind of misdetection.
-     * @param packageNames set the package name for the detector to be faster; or provide null to scan the whole classpath, but this is quite slow.
-     * @return this
-     */
-    @JvmOverloads
-    fun autoDiscoverViews(vararg packageNames: String? = arrayOf()): Routes = apply {
-        val classGraph: ClassGraph = ClassGraph().enableClassInfo()
-                .enableAnnotationInfo()
-                .ignoreClassVisibility()
-                .acceptPackages(*(packageNames.map { it ?: "" }.toTypedArray()))
-        classGraph.scan().use { scanResult: ScanResult ->
-            scanResult.getClassesWithAnnotation(Route::class.java.name).mapTo(routes) { info: ClassInfo ->
-                scanResult.loadClass(info.name,Component::class.java, false)
-            }
-            scanResult.getClassesImplementing(HasErrorParameter::class.java.name).mapTo(errorRoutes) { info: ClassInfo ->
-                scanResult.loadClass(info.name,HasErrorParameter::class.java, false)
-            }
-            scanResult.getClassesWithAnnotation(Layout::class.java.name)
-                    .filter { it.implementsInterface(RouterLayout::class.java.name) }
-                    .mapTo(layouts) { info: ClassInfo ->
-                        scanResult.loadClass(info.name,RouterLayout::class.java, false)
-                    }
-        }
-
-        cleanupErrorRoutes()
-
-        log.debug("Auto-discovered views: {}", this)
-    }
-
-    fun merge(other: Routes): Routes {
-        return Routes(LinkedHashSet(this.routes), LinkedHashSet(this.errorRoutes), LinkedHashSet(this.layouts), this.skipPwaInit).apply {
-            routes.addAll(other.routes)
-            errorRoutes.addAll(other.errorRoutes)
-            layouts.addAll(other.layouts)
-            cleanupErrorRoutes()
-        }
-    }
-
-    override fun toString(): String =
-            "Routes(routes=${routes.joinToString { it.simpleName }}, errorRoutes=${errorRoutes.joinToString { it.simpleName }}, layouts=${layouts.joinToString { it.simpleName }})"
-
-
-    companion object {
-        private val log = LoggerFactory.getLogger(Routes::class.java)
-    }
-
-    private fun cleanupErrorRoutes() {
-        // https://github.com/mvysny/karibu-testing/issues/50
-        // if the app defines its own NotFoundException handler, remove MockRouteNotFoundError
-        if (errorRoutes.any { it != MockRouteNotFoundError::class.java && isRouteNotFound(it) }) {
-            errorRoutes.remove(MockRouteNotFoundError::class.java)
-        }
-
-        // Replace default InternalServeError exception handler with an
-        // implementation that exposes error details for PrettyPrinter
-        errorRoutes.remove(InternalServerError::class.java)
-        errorRoutes.add(MockInternalSeverError::class.java)
-    }
-}
-
-/**
- * Clears the PWA class config from this registry.
- */
-@Suppress("UNCHECKED_CAST")
-fun ApplicationRouteRegistry.clearPwaClass() {
-    val pwaClassField: Field = ApplicationRouteRegistry::class.java.getDeclaredField("pwaConfigurationClass").apply { isAccessible = true }
-    val ref: AtomicReference<Class<*>> = pwaClassField.get(this) as AtomicReference<Class<*>>
-    ref.set(null)
-    if (pwaConfigurationClass != null) {
-        throw AssertionError("PWA configuration class should have been removed")
-    }
-}
-
-/**
- * This route gets registered by default in [Routes], so that Karibu-Testing can catch
- * any navigation to a missing route and can respond with an informative exception.
- */
-@Tag(Tag.DIV)
-@DefaultErrorHandler
-open class MockRouteNotFoundError : RouteNotFoundError() {
-
-    var cause: NotFoundException? = null;
-
-    override fun setErrorParameter(event: BeforeEnterEvent, parameter: ErrorParameter<NotFoundException>): Int {
-
-        val message: String = buildString {
-            val path: String = event.location.path
-            append("No route found for '").append(path).append("'")
-            if (parameter.hasCustomMessage()) {
-                append(": ").append(parameter.customMessage)
-            }
-            append("\nAvailable routes: ")
-            val routes: List<RouteData> = event.source.registry.registeredRoutes
-            append(routes.map { it.toPrettyString() })
-            append("\nIf you'd like to revert back to the original Vaadin RouteNotFoundError, please remove the ${MockRouteNotFoundError::class.java} from Routes.errorRoutes")
-        }
-        cause = NotFoundException(message).apply { initCause(parameter.caughtException) }
-        return super.setErrorParameter(event, parameter)
-    }
-
-    private fun RouteData.toPrettyString(): String {
-        val template = template
-        val path: String = if (template.isNullOrBlank()) "<root>" else "/$template"
-        return "${navigationTarget.simpleName} at '$path'"
-    }
-}
-
-@DefaultErrorHandler
-open class MockInternalSeverError : InternalServerError() {
-
-    override fun setErrorParameter(event: BeforeEnterEvent, parameter: ErrorParameter<Exception>): Int {
-        element.setProperty("targetView", event.location.path)
-        if (parameter.hasCustomMessage()) {
-            element.setProperty("failureMessage", parameter.customMessage)
-        } else {
-            element.setProperty("failureMessage", parameter.exception.message)
-        }
-        element.setProperty("exceptionType", parameter.exception::class.java.name)
-        element.setProperty("stackTrace", parameter.exception.stackTraceToString())
-        return super.setErrorParameter(event, parameter)
-    }
-}

From f90d06c7e52686c9e15012bdd5c251d24c2056a3 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 12:18:50 +0000
Subject: [PATCH 05/13] refactor!: port Locator and MockVaadin from Kotlin to
 Java
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fourth phase of removing Kotlin from `shared`; only `Grid.kt` and the two
helpers it still needs are left. See `de-kotlin-plan.md`.

`Locator.kt` becomes `Locator` plus `SearchSpec`, and `MockVaadin.kt` becomes
`MockVaadin` plus `SessionObjects`, `UIFactory`, `MockRequestCustomizer` and a
nested `MockPage`. A new `CountRange` replaces `kotlin.ranges.IntRange` in the
search spec, so no Java source in any module references a Kotlin type any more.

`MockVaadin` now fires session-init, service-destroy and UI-init through
`VaadinService.getEventBus()` with a handler that rethrows, so a listener
throwing during a test fails that test instead of only logging. It previously
reflected into the private listener collections.

The Kotlin `_get<Reified> { … }` syntax moves to a test-scope `LocatorDsl.kt` in
`junit6`, since Java has no equivalent of a reified type parameter or a receiver
lambda.

Breaking changes:

* `LocatorKt` and `MockVaadinKt` are gone; their functions are statics on
  `Locator` and `MockVaadin`, taking a `Class<T>` and a
  `Consumer<SearchSpec<T>>` in place of the reified type and the Kotlin block.
* `MockPage` moves from a top-level class to `MockVaadin.MockPage`.
* `SearchSpec` loses the all-argument constructor the Kotlin default arguments
  produced; construct with `new SearchSpec(clazz)` and set what you need. Its
  fields are behind accessors, `toPredicate()` returns a `Predicate`, and
  `count` is a `CountRange`.
* `MockVaadin.userAgent` and `mockRequestFactory` are behind accessors, and the
  factory is a `java.util.function.Function`.
* `MockVaadin.setup` and `setupServlet` take `Set<Class<?>>` rather than
  `Set<? extends Class<?>>`, since Java has no declaration-site variance.
* The three `@Deprecated(forRemoval = true)` constructors taking
  `Function0<UI>` are removed from `MockSpringServlet`,
  `MockSpringServletService` and `MockSpringVaadinSession`. With a plain Java
  `UIFactory` they are ambiguous against the `UIFactory` overload at any
  `MockedUI::new` call site.
---
 de-kotlin-plan.md                             |  27 +-
 .../vaadin/browserless/internal/LocatorDsl.kt | 139 +++
 .../browserless/internal/MockVaadinTest.kt    |  10 +-
 .../browserless/internal/SearchSpecTest.kt    | 110 +-
 .../browserless/BrowserlessUIContext.java     |   7 +-
 .../vaadin/browserless/ComponentQuery.java    |  33 +-
 .../browserless/internal/CountRange.java      | 124 +++
 .../vaadin/browserless/internal/Locator.java  | 441 ++++++++
 .../internal/MockRequestCustomizer.java       |  33 +
 .../browserless/internal/MockVaadin.java      | 971 ++++++++++++++++++
 .../vaadin/browserless/internal/Routes.java   |   2 -
 .../browserless/internal/SearchSpec.java      | 415 ++++++++
 .../browserless/internal/SessionObjects.java  |  95 ++
 .../browserless/internal/UIFactory.java       |  41 +
 .../com/vaadin/browserless/component/Grid.kt  |   2 -
 .../Matches.kt => component/GridSupport.kt}   |  22 +-
 .../vaadin/browserless/internal/Locator.kt    | 438 --------
 .../vaadin/browserless/internal/MockVaadin.kt | 726 -------------
 .../browserless/mocks/MockSpringServlet.java  |  11 -
 .../mocks/MockSpringServletService.java       |  10 -
 .../mocks/MockSpringVaadinSession.java        |   9 -
 21 files changed, 2371 insertions(+), 1295 deletions(-)
 create mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/Locator.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
 create mode 100644 shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
 rename shared/src/main/kotlin/com/vaadin/browserless/{internal/Matches.kt => component/GridSupport.kt} (52%)
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt

diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index e9a3c041..ad0460ea 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -140,9 +140,11 @@ suite does not catch it.
 `kotlin-reflect` was already dropped on `main` by `df099d0`, so this phase has
 no dependency change.
 
-### Phase 4 — `Locator` + `MockVaadin`
+### Phase 4 — `Locator` + `MockVaadin` — done
 
-The behaviorally sensitive phase.
+On `refactor/no-kotlin-locator-mockvaadin`. All five suites match the `main`
+baseline: shared 42, junit6 1406, junit6-cdi-tests 4, spring 41, quarkus 31.
+After this phase no Java source in any module references a Kotlin type.
 
 - `Locator.kt` → `Locator` + `SearchSpec`.
 - `MockVaadin.kt` → `MockVaadin` + `SessionObjects` + `UIFactory` +
@@ -152,6 +154,27 @@ The behaviorally sensitive phase.
   throwables where Java cannot.
 - Keep `UIFactory`'s SAM method named `invoke()` so `MockedUI::new` call sites
   and the Spring / Quarkus constructors keep binding.
+- `CountRange` replaces `kotlin.ranges.IntRange` here rather than in Phase 5, so
+  `SearchSpec` and `ComponentQuery.LocatorSpec` are edited once instead of
+  twice.
+- The Kotlin DSL shim goes straight to `junit6/src/test/kotlin` as
+  `LocatorDsl.kt`, skipping the prior effort's intermediate stop in
+  `shared/src/main/kotlin`. Nothing in `shared/src/test` uses the locator DSL.
+- The three `@Deprecated(forRemoval = true)` Spring constructors taking
+  `Function0<UI>` are removed, as agreed: with a plain Java `UIFactory` they are
+  ambiguous against the `UIFactory` overload at any `MockedUI::new` call site.
+- `MockVaadin` fires session-init, service-destroy and UI-init through
+  `VaadinService.getEventBus()` with a rethrowing failure handler, as `main`
+  does. The prior port reflected into `VaadinService`'s private listener
+  collections and swallowed the rethrow, which both
+  [`CONVENTIONS.md`](CONVENTIONS.md) and
+  [`guidelines/architecture.md`](guidelines/architecture.md) argue against.
+
+Two things the drift check caught. `SearchSpec` had no `testId` at all, because
+that field postdates the prior port — it would have broken the public
+`ComponentQuery.withTestId(…)`. And `MockPage.reload()` was missing the
+logout-idiom early return, the wrong-UI guard and the
+`recordReloadReplacement(…)` call, which six reload tests caught.
 
 ### Phase 5 — `Grid.kt` and the kotlin-stdlib drop
 
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt
new file mode 100644
index 00000000..9a28aba3
--- /dev/null
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+@file:Suppress("FunctionName")
+
+package com.vaadin.browserless.internal
+
+import java.util.function.Consumer
+import com.vaadin.flow.component.Component
+
+/**
+ * Kotlin DSL conveniences over the Java [Locator] engine, preserving the
+ * `_get<Reified> { id = "foo" }` syntax for the Kotlin tests in this module.
+ *
+ * Java has no equivalent of `inline fun <reified T>` or of a receiver lambda,
+ * so this is test-scope sugar rather than published API: the engine itself
+ * takes a `Class<T>` and a `Consumer<SearchSpec<T>>`.
+ */
+
+/**
+ * Checks whether this component matches given spec. All rules are matched except the [SearchSpec.count] rule. The
+ * rules are matched against given component only (not against its children).
+ */
+public fun Component.matches(spec: SearchSpec<Component>.() -> Unit): Boolean =
+    SearchSpec(Component::class.java).apply(spec).toPredicate().test(this)
+
+/**
+ * Removes nulls and blank strings from this iterable. Used by the Grid pretty-tree
+ * dumper; mirrors the helper that used to live in `Locator.kt`.
+ */
+public fun Iterable<String?>.filterNotBlank(): List<String> =
+    filterNotNull().filter { it.isNotBlank() }
+
+// ---------------------------------------------------------------------------
+// Inline reified + DSL block conveniences over the Java [Locator] engine.
+// ---------------------------------------------------------------------------
+
+public inline fun <reified T : Component> Component._get(noinline block: SearchSpec<T>.() -> Unit = {}): T =
+    Locator._get(this, T::class.java, Consumer { it.block() })
+
+public inline fun <reified T : Component> _get(noinline block: SearchSpec<T>.() -> Unit = {}): T =
+    Locator._get(T::class.java, Consumer { it.block() })
+
+public inline fun <reified T : Component> Component._find(noinline block: SearchSpec<T>.() -> Unit = {}): List<T> =
+    Locator._find(this, T::class.java, Consumer { it.block() })
+
+public inline fun <reified T : Component> _find(noinline block: SearchSpec<T>.() -> Unit = {}): List<T> =
+    Locator._find(T::class.java, Consumer { it.block() })
+
+public inline fun <reified T : Component> Component._expectNone(noinline block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectNone(this, T::class.java, Consumer { it.block() })
+}
+
+public inline fun <reified T : Component> _expectNone(noinline block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectNone(T::class.java, Consumer { it.block() })
+}
+
+public inline fun <reified T : Component> Component._expectOne(noinline block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectOne(this, T::class.java, Consumer { it.block() })
+}
+
+public inline fun <reified T : Component> _expectOne(noinline block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectOne(T::class.java, Consumer { it.block() })
+}
+
+public inline fun <reified T : Component> Component._expect(count: Int = 1, noinline block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expect(this, T::class.java, count, Consumer { it.block() })
+}
+
+public inline fun <reified T : Component> _expect(count: Int = 1, noinline block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expect(T::class.java, count, Consumer { it.block() })
+}
+
+// ---------------------------------------------------------------------------
+// Non-reified Class-receiving extension overloads. These mirror the original
+// Kotlin signatures so existing Kotlin callers like `button._get(Button::class.java)`
+// keep compiling.
+// ---------------------------------------------------------------------------
+
+public fun <T : Component> Component._get(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): T =
+    Locator._get(this, clazz, Consumer { it.block() })
+
+public fun <T : Component> _get(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): T =
+    Locator._get(clazz, Consumer { it.block() })
+
+public fun <T : Component> Component._find(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): List<T> =
+    Locator._find(this, clazz, Consumer { it.block() })
+
+public fun <T : Component> _find(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): List<T> =
+    Locator._find(clazz, Consumer { it.block() })
+
+public fun <T : Component> Component._expectNone(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectNone(this, clazz, Consumer { it.block() })
+}
+
+public fun <T : Component> _expectNone(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectNone(clazz, Consumer { it.block() })
+}
+
+public fun <T : Component> Component._expectOne(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectOne(this, clazz, Consumer { it.block() })
+}
+
+public fun <T : Component> _expectOne(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expectOne(clazz, Consumer { it.block() })
+}
+
+public fun <T : Component> Component._expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expect(this, clazz, count, Consumer { it.block() })
+}
+
+public fun <T : Component> _expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T>.() -> Unit = {}) {
+    Locator._expect(clazz, count, Consumer { it.block() })
+}
+
+/**
+ * Re-exports a few non-reified helpers under their familiar names so that
+ * Kotlin callers don't need to import `Locator`.
+ */
+public fun _expectNoDialogs(): Unit = Locator._expectNoDialogs()
+
+public fun _expectInternalServerError(expectedErrorMessage: String = ""): Unit =
+    Locator._expectInternalServerError(expectedErrorMessage)
+
+public val currentPath: String? get() = Locator.currentPath()
+
+public fun Component._walkAll(): Iterable<Component> = Locator._walkAll(this)
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
index 43e3ba36..3cfe1bf1 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
@@ -371,9 +371,9 @@ internal fun DynaNodeGroup.mockVaadinTest() {
 
     test("Reusing UI fails with helpful message") {
         val ui = MockedUI()
-        MockVaadin.setup(uiFactory = { ui })
+        MockVaadin.setup(UIFactory { ui })
         expectThrows(IllegalArgumentException::class, "which is already attached to a Session") {
-            MockVaadin.setup(uiFactory = { ui })
+            MockVaadin.setup(UIFactory { ui })
         }
     }
 
@@ -410,7 +410,7 @@ internal fun DynaNodeGroup.mockVaadinTest() {
         test("cookies in UI.init()") {
             MockVaadin.tearDown()
             var initCalled = false
-            MockVaadin.setup(uiFactory = {
+            MockVaadin.setup(UIFactory {
                 mock(currentRequest()).addCookie(Cookie("foo", "bar"))
                 object : UI() {
                     override fun init(request: VaadinRequest) {
@@ -548,7 +548,7 @@ internal fun DynaNodeGroup.mockVaadinTest() {
                 override fun createVaadinSession(request: VaadinRequest): VaadinSession = MockVaadinSession(this) { MockedUI() }
             }
             MockVaadin.tearDown()
-            MockVaadin.setup(servlet = object : MockVaadinServlet(routes) {
+            MockVaadin.setup(object : MockVaadinServlet(routes) {
                 override fun createServletService(deploymentConfiguration: DeploymentConfiguration): VaadinServletService {
                     val service = MyMockService(this, deploymentConfiguration)
                     service.init()
@@ -563,7 +563,7 @@ internal fun DynaNodeGroup.mockVaadinTest() {
             var uiInitListenerInvocationCount = 0
             var sessionDestroyListenerInvocationCount = 0
             var serviceDestroyListenerInvocationCount = 0
-            MockVaadin.setup(servlet = object : MockVaadinServlet(routes) {
+            MockVaadin.setup(object : MockVaadinServlet(routes) {
                 override fun createServletService(deploymentConfiguration: DeploymentConfiguration): VaadinServletService {
                     val service = MockService(this, deploymentConfiguration)
                     service.init()
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
index 7475e2a9..19a85be1 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
+++ b/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
@@ -43,117 +43,117 @@ internal fun DynaNodeGroup.searchSpecTest() {
 
     test("clazz") {
         val spec = SearchSpec(Button::class.java)
-        expect(true) { spec.toPredicate()(Button()) }
-        expect(false) { spec.toPredicate()(Span()) }
+        expect(true) { spec.toPredicate().test(Button()) }
+        expect(false) { spec.toPredicate().test(Span()) }
     }
 
     test("id") {
-        val spec = SearchSpec(Component::class.java, id = "25")
-        expect(true) { spec.toPredicate()(Button().apply { setId("25") }) }
-        expect(false) { spec.toPredicate()(Button().apply { setId("42") }) }
-        expect(false) { spec.toPredicate()(Button()) }
+        val spec = SearchSpec(Component::class.java).apply { id = "25" }
+        expect(true) { spec.toPredicate().test(Button().apply { setId("25") }) }
+        expect(false) { spec.toPredicate().test(Button().apply { setId("42") }) }
+        expect(false) { spec.toPredicate().test(Button()) }
     }
 
     test("caption") {
-        val spec = SearchSpec(Component::class.java, caption = "foo")
-        expect(true) { spec.toPredicate()(Button("foo")) }
-        expect(false) { spec.toPredicate()(Button("bar")) }
-        expect(false) { spec.toPredicate()(Button()) }
-        expect(true) { spec.toPredicate()(Checkbox("foo")) }
-        expect(false) { spec.toPredicate()(Checkbox("bar")) }
-        expect(false) { spec.toPredicate()(Checkbox()) }
+        val spec = SearchSpec(Component::class.java).apply { caption = "foo" }
+        expect(true) { spec.toPredicate().test(Button("foo")) }
+        expect(false) { spec.toPredicate().test(Button("bar")) }
+        expect(false) { spec.toPredicate().test(Button()) }
+        expect(true) { spec.toPredicate().test(Checkbox("foo")) }
+        expect(false) { spec.toPredicate().test(Checkbox("bar")) }
+        expect(false) { spec.toPredicate().test(Checkbox()) }
         expect(true) {
-            spec.toPredicate()(CheckboxGroup<Int>().apply {
+            spec.toPredicate().test(CheckboxGroup<Int>().apply {
                 label = "foo"
             })
         }
         expect(false) {
-            spec.toPredicate()(CheckboxGroup<Int>().apply {
+            spec.toPredicate().test(CheckboxGroup<Int>().apply {
                 label = "bar"
             })
         }
-        expect(false) { spec.toPredicate()(CheckboxGroup<Int>()) }
+        expect(false) { spec.toPredicate().test(CheckboxGroup<Int>()) }
         expect(true) {
-            spec.toPredicate()(Select<Int>().apply {
+            spec.toPredicate().test(Select<Int>().apply {
                 label = "foo"
             })
         }
         expect(false) {
-            spec.toPredicate()(Select<Int>().apply {
+            spec.toPredicate().test(Select<Int>().apply {
                 label = "bar"
             })
         }
-        expect(false) { spec.toPredicate()(Select<Int>()) }
+        expect(false) { spec.toPredicate().test(Select<Int>()) }
         expect(true) {
-            spec.toPredicate()(ListBox<Int>().also {
+            spec.toPredicate().test(ListBox<Int>().also {
                 ComponentUtils.label(it, "foo")
             })
         }
         expect(false) {
-            spec.toPredicate()(ListBox<Int>().also {
+            spec.toPredicate().test(ListBox<Int>().also {
                 ComponentUtils.label(it, "bar")
             })
         }
-        expect(false) { spec.toPredicate()(ListBox<Int>()) }
+        expect(false) { spec.toPredicate().test(ListBox<Int>()) }
         expect(true) {
-            spec.toPredicate()(RadioButtonGroup<Int>().apply {
+            spec.toPredicate().test(RadioButtonGroup<Int>().apply {
                 label = "foo"
             })
         }
         expect(false) {
-            spec.toPredicate()(RadioButtonGroup<Int>().apply {
+            spec.toPredicate().test(RadioButtonGroup<Int>().apply {
                 label = "bar"
             })
         }
-        expect(false) { spec.toPredicate()(RadioButtonGroup<Int>()) }
+        expect(false) { spec.toPredicate().test(RadioButtonGroup<Int>()) }
         // tests CustomField
         expect(true) {
-            spec.toPredicate()(DateRangePopup().apply {
+            spec.toPredicate().test(DateRangePopup().apply {
                 label = "foo"
             })
         }
         expect(false) {
-            spec.toPredicate()(DateRangePopup().apply {
+            spec.toPredicate().test(DateRangePopup().apply {
                 label = "bar"
             })
         }
-        expect(false) { spec.toPredicate()(DateRangePopup()) }
+        expect(false) { spec.toPredicate().test(DateRangePopup()) }
 
-        expect(true) { spec.toPredicate()(Input().also { ComponentUtils.label(it, "foo") }) }
-        expect(false) { spec.toPredicate()(Input().also { ComponentUtils.label(it, "bar") }) }
-        expect(false) { spec.toPredicate()(Input()) }
-        expect(true) { spec.toPredicate()(TextField("foo")) }
-        expect(false) { spec.toPredicate()(TextField("bar")) }
-        expect(false) { spec.toPredicate()(TextField()) }
-        expect(true) { spec.toPredicate()(TextArea("foo")) }
-        expect(false) { spec.toPredicate()(TextArea("bar")) }
-        expect(false) { spec.toPredicate()(TextArea()) }
-        expect(true) { spec.toPredicate()(TimePicker("foo")) }
-        expect(false) { spec.toPredicate()(TimePicker("bar")) }
-        expect(false) { spec.toPredicate()(TimePicker()) }
-        expect(true) { spec.toPredicate()(DatePicker("foo")) }
-        expect(false) { spec.toPredicate()(DatePicker("bar")) }
-        expect(false) { spec.toPredicate()(DatePicker()) }
-        expect(true) { spec.toPredicate()(ComboBox<Int>("foo")) }
-        expect(false) { spec.toPredicate()(ComboBox<Int>("bar")) }
-        expect(false) { spec.toPredicate()(ComboBox<Int>()) }
+        expect(true) { spec.toPredicate().test(Input().also { ComponentUtils.label(it, "foo") }) }
+        expect(false) { spec.toPredicate().test(Input().also { ComponentUtils.label(it, "bar") }) }
+        expect(false) { spec.toPredicate().test(Input()) }
+        expect(true) { spec.toPredicate().test(TextField("foo")) }
+        expect(false) { spec.toPredicate().test(TextField("bar")) }
+        expect(false) { spec.toPredicate().test(TextField()) }
+        expect(true) { spec.toPredicate().test(TextArea("foo")) }
+        expect(false) { spec.toPredicate().test(TextArea("bar")) }
+        expect(false) { spec.toPredicate().test(TextArea()) }
+        expect(true) { spec.toPredicate().test(TimePicker("foo")) }
+        expect(false) { spec.toPredicate().test(TimePicker("bar")) }
+        expect(false) { spec.toPredicate().test(TimePicker()) }
+        expect(true) { spec.toPredicate().test(DatePicker("foo")) }
+        expect(false) { spec.toPredicate().test(DatePicker("bar")) }
+        expect(false) { spec.toPredicate().test(DatePicker()) }
+        expect(true) { spec.toPredicate().test(ComboBox<Int>("foo")) }
+        expect(false) { spec.toPredicate().test(ComboBox<Int>("bar")) }
+        expect(false) { spec.toPredicate().test(ComboBox<Int>()) }
     }
 
     test("text") {
-        val spec = SearchSpec(Component::class.java, text = "foo")
-        expect(true) { spec.toPredicate()(Button("foo")) }
-        expect(false) { spec.toPredicate()(Button("bar")) }
-        expect(false) { spec.toPredicate()(Button()) }
-        expect(true) { spec.toPredicate()(Text("foo")) }
-        expect(false) { spec.toPredicate()(Text("bar")) }
-        expect(false) { spec.toPredicate()(Text("")) }
+        val spec = SearchSpec(Component::class.java).apply { text = "foo" }
+        expect(true) { spec.toPredicate().test(Button("foo")) }
+        expect(false) { spec.toPredicate().test(Button("bar")) }
+        expect(false) { spec.toPredicate().test(Button()) }
+        expect(true) { spec.toPredicate().test(Text("foo")) }
+        expect(false) { spec.toPredicate().test(Text("bar")) }
+        expect(false) { spec.toPredicate().test(Text("")) }
     }
 
     test("predicates") {
         var spec = SearchSpec(Component::class.java).apply {
             predicates.add(Predicate { it is Button })
         }
-        expect(true) { spec.toPredicate()(Button()) }
-        expect(false) { spec.toPredicate()(Span()) }
+        expect(true) { spec.toPredicate().test(Button()) }
+        expect(false) { spec.toPredicate().test(Span()) }
     }
 }
diff --git a/shared/src/main/java/com/vaadin/browserless/BrowserlessUIContext.java b/shared/src/main/java/com/vaadin/browserless/BrowserlessUIContext.java
index f4ddd451..a16725e8 100644
--- a/shared/src/main/java/com/vaadin/browserless/BrowserlessUIContext.java
+++ b/shared/src/main/java/com/vaadin/browserless/BrowserlessUIContext.java
@@ -21,7 +21,6 @@
 import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;
 
-import com.vaadin.browserless.internal.MockPage;
 import com.vaadin.browserless.internal.MockVaadin;
 import com.vaadin.browserless.locator.Locators;
 import com.vaadin.flow.component.Component;
@@ -548,7 +547,7 @@ public boolean runPendingSignalsTasks(long maxWaitTime, TimeUnit unit) {
      */
     public String getExternalNavigationURL() {
         activate();
-        if (ui.getPage() instanceof MockPage mockPage) {
+        if (ui.getPage() instanceof MockVaadin.MockPage mockPage) {
             return mockPage.getLastExternalNavigationURL();
         }
         return null;
@@ -566,7 +565,7 @@ public String getExternalNavigationURL() {
      */
     public String getExternalNavigationURL(String windowName) {
         activate();
-        if (ui.getPage() instanceof MockPage mockPage) {
+        if (ui.getPage() instanceof MockVaadin.MockPage mockPage) {
             return mockPage.getExternalNavigationURL(windowName);
         }
         return null;
@@ -588,7 +587,7 @@ public String getExternalNavigationURL(String windowName) {
      */
     public Map<String, List<String>> getOpenedWindows() {
         activate();
-        if (ui.getPage() instanceof MockPage mockPage) {
+        if (ui.getPage() instanceof MockVaadin.MockPage mockPage) {
             return mockPage.getOpenedWindows();
         }
         return Map.of();
diff --git a/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java b/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java
index 6a9d55de..df0cb446 100644
--- a/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java
+++ b/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java
@@ -25,10 +25,8 @@
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 
-import kotlin.Unit;
-import kotlin.ranges.IntRange;
-
-import com.vaadin.browserless.internal.LocatorKt;
+import com.vaadin.browserless.internal.CountRange;
+import com.vaadin.browserless.internal.Locator;
 import com.vaadin.browserless.internal.SearchSpec;
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.shared.ThemeVariant;
@@ -122,7 +120,7 @@ public <V> ComponentQuery<T> withValue(V expectedValue) {
     public ComponentQuery<T> withId(String id) {
         locatorSpec.id = id;
         // At most one element with given id is expected
-        locatorSpec.count = new IntRange(0, 1);
+        locatorSpec.count = new CountRange(0, 1);
         return this;
     }
 
@@ -142,7 +140,7 @@ public ComponentQuery<T> withId(String id) {
     public ComponentQuery<T> withTestId(String testId) {
         locatorSpec.testId = testId;
         // At most one element with given test-id is expected
-        locatorSpec.count = new IntRange(0, 1);
+        locatorSpec.count = new CountRange(0, 1);
         return this;
     }
 
@@ -464,7 +462,7 @@ public ComponentQuery<T> withResultsSize(int count) {
                     "count must be greater or equal than zero, but was "
                             + count);
         }
-        locatorSpec.count = new IntRange(count, count);
+        locatorSpec.count = CountRange.exactly(count);
         return this;
     }
 
@@ -495,7 +493,7 @@ public ComponentQuery<T> withResultsSize(int min, int max) {
                     "max must be greater or equal than min, but was min=" + min
                             + ", max=" + max + "");
         }
-        locatorSpec.count = new IntRange(min, max);
+        locatorSpec.count = new CountRange(min, max);
         return this;
     }
 
@@ -924,10 +922,9 @@ public boolean exists() {
      */
     public List<T> all() {
         if (context != null) {
-            return LocatorKt._find(context, componentType,
-                    locatorSpec::populate);
+            return Locator._find(context, componentType, locatorSpec::populate);
         }
-        return LocatorKt._find(componentType, locatorSpec::populate);
+        return Locator._find(componentType, locatorSpec::populate);
     }
 
     /**
@@ -949,14 +946,14 @@ protected T find() {
         // Snapshot and restore so resolution's "expect exactly one"
         // constraint doesn't leak into the persistent spec and
         // pollute later chain steps.
-        IntRange savedCount = locatorSpec.count;
-        locatorSpec.count = new IntRange(1, 1);
+        CountRange savedCount = locatorSpec.count;
+        locatorSpec.count = CountRange.ONE;
         try {
             if (context != null) {
-                return LocatorKt._get(context, componentType,
+                return Locator._get(context, componentType,
                         locatorSpec::populate);
             }
-            return LocatorKt._get(componentType, locatorSpec::populate);
+            return Locator._get(componentType, locatorSpec::populate);
         } catch (AssertionError e) {
             // Happens when found component(s) are not of the expected type
             throw new NoSuchElementException(e.getMessage());
@@ -980,7 +977,7 @@ private static class LocatorSpec<T extends Component> {
         String placeholder;
         String text;
         boolean textExactMatch = true;
-        IntRange count = new IntRange(0, Integer.MAX_VALUE);
+        CountRange count = CountRange.ANY;
         Object value;
         final Set<String> classes = new HashSet<>();
         final Set<String> withoutClasses = new HashSet<>();
@@ -988,7 +985,7 @@ private static class LocatorSpec<T extends Component> {
         String withoutThemes;
         List<Predicate<T>> predicates = new ArrayList<>(0);
 
-        public Unit populate(SearchSpec<T> spec) {
+        public void populate(SearchSpec<T> spec) {
             if (id != null)
                 spec.setId(id);
             if (testId != null)
@@ -1015,8 +1012,6 @@ else if (text != null)
                 spec.setWithoutThemes(withoutThemes);
             spec.setCount(count);
             spec.getPredicates().addAll(predicates);
-
-            return Unit.INSTANCE;
         }
 
     }
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java b/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
new file mode 100644
index 00000000..f47d92c1
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * An inclusive range of component counts a lookup will accept.
+ * <p>
+ * Replaces the {@code kotlin.ranges.IntRange} the Kotlin locator used, so that
+ * nothing on the published API carries a Kotlin type.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class CountRange implements Serializable {
+
+    /**
+     * Accepts any number of components, which is what a lookup expects unless
+     * it is told otherwise.
+     */
+    public static final CountRange ANY = new CountRange(0, Integer.MAX_VALUE);
+
+    /**
+     * Accepts exactly one component.
+     */
+    public static final CountRange ONE = new CountRange(1, 1);
+
+    private final int start;
+
+    private final int endInclusive;
+
+    /**
+     * Creates a range. An empty range, i.e. one whose end is below its start,
+     * accepts nothing.
+     *
+     * @param start
+     *            the lowest accepted count
+     * @param endInclusive
+     *            the highest accepted count
+     */
+    public CountRange(int start, int endInclusive) {
+        this.start = start;
+        this.endInclusive = endInclusive;
+    }
+
+    /**
+     * Creates a range accepting exactly the given count.
+     *
+     * @param count
+     *            the only accepted count
+     * @return the range
+     */
+    public static CountRange exactly(int count) {
+        return new CountRange(count, count);
+    }
+
+    /**
+     * Returns the lowest accepted count.
+     *
+     * @return the start of the range
+     */
+    public int getStart() {
+        return start;
+    }
+
+    /**
+     * Returns the highest accepted count.
+     *
+     * @return the end of the range, inclusive
+     */
+    public int getEndInclusive() {
+        return endInclusive;
+    }
+
+    /**
+     * Tells whether the given count falls in this range.
+     *
+     * @param count
+     *            the count to check
+     * @return {@code true} if the count is accepted
+     */
+    public boolean contains(int count) {
+        return count >= start && count <= endInclusive;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof CountRange other)) {
+            return false;
+        }
+        return start == other.start && endInclusive == other.endInclusive;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(start, endInclusive);
+    }
+
+    /**
+     * Formats the range the way the Kotlin one did, e.g. {@code 1..5}, since
+     * lookup failure messages quote it.
+     */
+    @Override
+    public String toString() {
+        return start + ".." + endInclusive;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Locator.java b/shared/src/main/java/com/vaadin/browserless/internal/Locator.java
new file mode 100644
index 00000000..fa7afd07
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Locator.java
@@ -0,0 +1,441 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.dialog.Dialog;
+import com.vaadin.flow.router.InternalServerError;
+import com.vaadin.flow.router.Location;
+
+/**
+ * Java port of the original Kotlin {@code Locator.kt}. Java callers should
+ * invoke these static methods directly; Kotlin callers may continue to use the
+ * conveniences in {@code LocatorDsl.kt}.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class Locator {
+
+    private static final Consumer<?> NOOP = spec -> {
+    };
+
+    @SuppressWarnings("unchecked")
+    private static <T extends Component> Consumer<SearchSpec<T>> noop() {
+        return (Consumer<SearchSpec<T>>) NOOP;
+    }
+
+    private Locator() {
+    }
+
+    /**
+     * Finds a VISIBLE component of given {@code clazz} which matches given
+     * {@code block}. This component and all of its descendants are searched.
+     *
+     * @param container
+     *            the root component to search under.
+     * @param clazz
+     *            the component must be of this class.
+     * @param block
+     *            the search specification
+     * @return the only matching component, never null.
+     * @throws AssertionError
+     *             if no component matched, or if more than one component
+     *             matches.
+     */
+    public static <T extends Component> T _get(Component container,
+            Class<T> clazz, Consumer<SearchSpec<T>> block) {
+        final CountRange one = CountRange.ONE;
+        List<T> result = _find(container, clazz, spec -> {
+            spec.setCount(one);
+            block.accept(spec);
+            if (!spec.getCount().equals(one)) {
+                throw new IllegalStateException(
+                        "You're calling _get which is supposed to return exactly 1 component, yet you tried to specify the count of "
+                                + spec.getCount());
+            }
+        });
+        if (result.size() != 1) {
+            throw new IllegalStateException(
+                    "Expected exactly 1 result, got " + result.size());
+        }
+        return clazz.cast(result.get(0));
+    }
+
+    /**
+     * Finds a VISIBLE component of given {@code clazz}; see
+     * {@link #_get(Component, Class, Consumer)}.
+     */
+    public static <T extends Component> T _get(Component container,
+            Class<T> clazz) {
+        return _get(container, clazz, Locator.<T> noop());
+    }
+
+    /**
+     * Finds a VISIBLE component in the current UI of given {@code clazz} which
+     * matches given {@code block}. The current UI and all of its descendants
+     * are searched.
+     */
+    public static <T extends Component> T _get(Class<T> clazz,
+            Consumer<SearchSpec<T>> block) {
+        return _get(Utils.currentUI(), clazz, block);
+    }
+
+    /**
+     * Finds a VISIBLE component in the current UI of given {@code clazz}.
+     */
+    public static <T extends Component> T _get(Class<T> clazz) {
+        return _get(Utils.currentUI(), clazz, Locator.<T> noop());
+    }
+
+    /**
+     * Finds a list of VISIBLE components of given {@code clazz} which matches
+     * {@code block}. This component and all of its descendants are searched.
+     *
+     * @return the list of matching components, may be empty.
+     */
+    public static <T extends Component> List<T> _find(Component container,
+            Class<T> clazz, Consumer<SearchSpec<T>> block) {
+        SearchSpec<T> spec = new SearchSpec<>(clazz);
+        block.accept(spec);
+        List<Component> result = find(container, spec.toPredicate());
+        CountRange count = spec.getCount();
+        int size = result.size();
+        if (size < count.getStart() || size > count.getEndInclusive()) {
+            String loc = currentPath();
+            if (loc == null) {
+                loc = "?";
+            }
+            String message;
+            if (result.isEmpty()) {
+                message = "/" + loc + ": No visible " + clazz.getSimpleName();
+            } else if (size < count.getStart()) {
+                message = "/" + loc + ": Too few (" + size + ") visible "
+                        + clazz.getSimpleName() + "s";
+            } else {
+                message = "/" + loc + ": Too many visible "
+                        + clazz.getSimpleName() + "s (" + size + ")";
+            }
+            String matched = result.stream()
+                    .map(PrettyPrintTree::toPrettyString)
+                    .collect(Collectors.joining(", "));
+            message = message + " in "
+                    + PrettyPrintTree.toPrettyString(container) + " matching "
+                    + spec + ": [" + matched + "]. Component tree:\n"
+                    + PrettyPrintTree.toPrettyTree(container);
+
+            // if there's a PolymerTemplate, warn that Browserless Testing can't
+            // really locate components in there:
+            // https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#polymer-templates
+            // fixes https://github.com/mvysny/karibu-testing/issues/35
+            boolean hasPolymerTemplates = Utils.hasPolymerTemplates()
+                    && containsPolymerTemplate(container);
+            if (hasPolymerTemplates) {
+                message = message
+                        + "\nWarning: Browserless Testing is not able to look up components from inside of PolymerTemplate."
+                        + " Please see https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#polymer-templates for more details.";
+            }
+
+            // find() used to fail with IllegalArgumentException which makes
+            // sense for a general-purpose utility method. However,
+            // since find() is used in tests overwhelmingly, not finding the
+            // correct set of components is generally treated as an assertion
+            // error.
+            throw new AssertionError(message);
+        }
+        List<T> filtered = new ArrayList<>(result.size());
+        for (Component c : result) {
+            if (clazz.isInstance(c)) {
+                filtered.add(clazz.cast(c));
+            }
+        }
+        return filtered;
+    }
+
+    /**
+     * Finds a list of VISIBLE components of given {@code clazz}; see
+     * {@link #_find(Component, Class, Consumer)}.
+     */
+    public static <T extends Component> List<T> _find(Component container,
+            Class<T> clazz) {
+        return _find(container, clazz, Locator.<T> noop());
+    }
+
+    /**
+     * Finds a list of VISIBLE components in the current UI of given
+     * {@code clazz} which matches {@code block}.
+     */
+    public static <T extends Component> List<T> _find(Class<T> clazz,
+            Consumer<SearchSpec<T>> block) {
+        return _find(Utils.currentUI(), clazz, block);
+    }
+
+    /**
+     * Finds a list of VISIBLE components in the current UI of given
+     * {@code clazz}.
+     */
+    public static <T extends Component> List<T> _find(Class<T> clazz) {
+        return _find(Utils.currentUI(), clazz, Locator.<T> noop());
+    }
+
+    private static List<Component> find(Component root,
+            Predicate<Component> predicate) {
+        TestingLifecycleHooks.getCurrent().awaitBeforeLookup();
+        List<Component> descendants = new ArrayList<>();
+        for (Component c : _walkAll(root)) {
+            descendants.add(c);
+        }
+        TestingLifecycleHooks.getCurrent().awaitAfterLookup();
+        InternalServerError error = firstInternalServerError(descendants);
+        if (error != null) {
+            throw new AssertionError(
+                    "An internal server error occurred; please check log for the actual stack-trace. Error text: "
+                            + BasicUtils.errorMessage(error) + "\n"
+                            + PrettyPrintTree.toPrettyTree(Utils.currentUI()));
+        }
+        List<Component> result = new ArrayList<>();
+        for (Component c : descendants) {
+            if (BasicUtils.isEffectivelyVisible(c) && predicate.test(c)) {
+                result.add(c);
+            }
+        }
+        return result;
+    }
+
+    private static InternalServerError firstInternalServerError(
+            List<Component> components) {
+        for (Component c : components) {
+            if (c instanceof InternalServerError) {
+                return (InternalServerError) c;
+            }
+        }
+        return null;
+    }
+
+    private static boolean containsPolymerTemplate(Component root) {
+        for (Component c : _walkAll(root)) {
+            if (ComponentUtils.isPolymerTemplate(c)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Walks the component child/descendant tree, depth-first: first the
+     * component, then its descendants, then its next sibling.
+     */
+    public static Iterable<Component> _walkAll(final Component root) {
+        return new Iterable<Component>() {
+            @Override
+            public Iterator<Component> iterator() {
+                return new DepthFirstTreeIterator<>(root,
+                        component -> TestingLifecycleHooks.getCurrent()
+                                .getAllChildren(component));
+            }
+        };
+    }
+
+    /**
+     * Expects that there are no VISIBLE components of given {@code clazz} which
+     * matches {@code block}. This component and all of its descendants are
+     * searched.
+     *
+     * @throws AssertionError
+     *             if one or more components matched.
+     */
+    public static <T extends Component> void _expectNone(Component container,
+            Class<T> clazz, Consumer<SearchSpec<T>> block) {
+        final CountRange zero = CountRange.exactly(0);
+        List<T> result = _find(container, clazz, spec -> {
+            spec.setCount(zero);
+            block.accept(spec);
+            if (!spec.getCount().equals(zero)) {
+                throw new IllegalStateException(
+                        "You're calling _expectNone which expects 0 component, yet you tried to specify the count of "
+                                + spec.getCount());
+            }
+        });
+        if (!result.isEmpty()) {
+            // safety check that _find works as expected
+            throw new IllegalStateException(
+                    "_find returned non-empty result: " + result);
+        }
+    }
+
+    public static <T extends Component> void _expectNone(Component container,
+            Class<T> clazz) {
+        _expectNone(container, clazz, Locator.<T> noop());
+    }
+
+    /**
+     * Expects that there are no VISIBLE components in the current UI of given
+     * {@code clazz} which matches {@code block}.
+     */
+    public static <T extends Component> void _expectNone(Class<T> clazz,
+            Consumer<SearchSpec<T>> block) {
+        _expectNone(Utils.currentUI(), clazz, block);
+    }
+
+    public static <T extends Component> void _expectNone(Class<T> clazz) {
+        _expectNone(Utils.currentUI(), clazz, Locator.<T> noop());
+    }
+
+    /**
+     * Expects that there are no dialogs shown.
+     */
+    public static void _expectNoDialogs() {
+        _expectNone(Dialog.class);
+    }
+
+    /**
+     * Expects that there is exactly one VISIBLE component of given
+     * {@code clazz} which matches {@code block}.
+     */
+    public static <T extends Component> void _expectOne(Component container,
+            Class<T> clazz, Consumer<SearchSpec<T>> block) {
+        // technically _expectOne is the same as _get, but the semantics differ
+        // - with _get() we're "just" doing a lookup (and asserting on
+        // the component later). _expectOne() explicitly declares in the test
+        // sources that we want to check that there is exactly one such
+        // component.
+        _get(container, clazz, block);
+    }
+
+    public static <T extends Component> void _expectOne(Component container,
+            Class<T> clazz) {
+        _expectOne(container, clazz, Locator.<T> noop());
+    }
+
+    public static <T extends Component> void _expectOne(Class<T> clazz,
+            Consumer<SearchSpec<T>> block) {
+        _expectOne(Utils.currentUI(), clazz, block);
+    }
+
+    public static <T extends Component> void _expectOne(Class<T> clazz) {
+        _expectOne(Utils.currentUI(), clazz, Locator.<T> noop());
+    }
+
+    /**
+     * Expects that there are exactly {@code count} VISIBLE components of given
+     * {@code clazz} match {@code block}. This component and all of its
+     * descendants are searched.
+     */
+    public static <T extends Component> void _expect(Component container,
+            Class<T> clazz, int count, Consumer<SearchSpec<T>> block) {
+        // technically _expect is the same as _find, but the semantics differ -
+        // with _find() we're "just" doing a lookup (and asserting on
+        // the components later). _expect() explicitly declares in the test
+        // sources that we want to check that there are exactly x components
+        // that match given spec.
+        _find(container, clazz, spec -> {
+            spec.setCount(CountRange.exactly(count));
+            block.accept(spec);
+        });
+    }
+
+    public static <T extends Component> void _expect(Component container,
+            Class<T> clazz, int count) {
+        _expect(container, clazz, count, Locator.<T> noop());
+    }
+
+    public static <T extends Component> void _expect(Component container,
+            Class<T> clazz) {
+        _expect(container, clazz, 1, Locator.<T> noop());
+    }
+
+    public static <T extends Component> void _expect(Class<T> clazz, int count,
+            Consumer<SearchSpec<T>> block) {
+        _expect(Utils.currentUI(), clazz, count, block);
+    }
+
+    public static <T extends Component> void _expect(Class<T> clazz,
+            int count) {
+        _expect(Utils.currentUI(), clazz, count, Locator.<T> noop());
+    }
+
+    public static <T extends Component> void _expect(Class<T> clazz) {
+        _expect(Utils.currentUI(), clazz, 1, Locator.<T> noop());
+    }
+
+    /**
+     * Asserts that the {@link InternalServerError} page is currently being
+     * shown, optionally with given {@code expectedErrorMessage}.
+     */
+    public static void _expectInternalServerError(String expectedErrorMessage) {
+        TestingLifecycleHooks.getCurrent().awaitBeforeLookup();
+        List<Component> descendants = new ArrayList<>();
+        for (Component c : _walkAll(Utils.currentUI())) {
+            descendants.add(c);
+        }
+        TestingLifecycleHooks.getCurrent().awaitAfterLookup();
+        InternalServerError error = firstInternalServerError(descendants);
+        if (error == null) {
+            throw new AssertionError(
+                    "Expected an internal server error but none happened. Component tree:\n"
+                            + PrettyPrintTree.toPrettyTree(Utils.currentUI()));
+        }
+        if (!BasicUtils.errorMessage(error).contains(expectedErrorMessage)) {
+            throw new AssertionError(
+                    "Expected InternalServerError with message '"
+                            + expectedErrorMessage + "' but was '"
+                            + BasicUtils.errorMessage(error)
+                            + "'. Component tree:\n"
+                            + PrettyPrintTree.toPrettyTree(Utils.currentUI()));
+        }
+    }
+
+    public static void _expectInternalServerError() {
+        _expectInternalServerError("");
+    }
+
+    /**
+     * Returns the browser's current path. Returns null if there is no current
+     * UI.
+     */
+    public static String currentPath() {
+        UI ui = UI.getCurrent();
+        if (ui == null) {
+            return null;
+        }
+        Location loc = ui.getInternals().getActiveViewLocation();
+        if (loc == null) {
+            return null;
+        }
+        return loc.getPathWithQueryParameters();
+    }
+
+    /**
+     * Filters out nulls and blank strings, returning a list of non-blank
+     * strings.
+     */
+    static List<String> filterNotBlank(Iterable<String> source) {
+        List<String> result = new ArrayList<>();
+        for (String s : source) {
+            if (s != null && !s.isBlank()) {
+                result.add(s);
+            }
+        }
+        return result;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java b/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
new file mode 100644
index 00000000..12351a03
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import com.vaadin.browserless.mocks.MockRequest;
+
+/**
+ * Applies last-minute customisations to a freshly created {@link MockRequest},
+ * before it is wrapped in a {@code VaadinRequest} and the session is created.
+ * <p>
+ * The environment resolves an implementation through the Vaadin {@code Lookup},
+ * so registering one as a lookup service is how a request gains details the
+ * mock cannot know by itself. That is how the Spring and Quarkus integrations
+ * inject the authenticated principal and its roles, and it is the extension
+ * point to implement for a container the framework does not cover.
+ */
+@FunctionalInterface
+public interface MockRequestCustomizer {
+    void apply(MockRequest request);
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
new file mode 100644
index 00000000..77fe46ce
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
@@ -0,0 +1,971 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import jakarta.servlet.ServletContext;
+import jakarta.servlet.ServletException;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EventObject;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Function;
+
+import com.vaadin.browserless.BrowserlessConfiguration;
+import com.vaadin.browserless.BrowserlessTestSetupException;
+import com.vaadin.browserless.mocks.MockHttpSession;
+import com.vaadin.browserless.mocks.MockRequest;
+import com.vaadin.browserless.mocks.MockResponse;
+import com.vaadin.browserless.mocks.MockServletConfig;
+import com.vaadin.browserless.mocks.MockVaadinHelper;
+import com.vaadin.browserless.mocks.MockVaadinServlet;
+import com.vaadin.browserless.mocks.MockedUI;
+import com.vaadin.flow.component.ComponentUtil;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.page.ExtendedClientDetails;
+import com.vaadin.flow.component.page.Page;
+import com.vaadin.flow.di.Lookup;
+import com.vaadin.flow.function.SerializableBiConsumer;
+import com.vaadin.flow.internal.CurrentInstance;
+import com.vaadin.flow.router.Location;
+import com.vaadin.flow.router.NavigationTrigger;
+import com.vaadin.flow.server.DefaultErrorHandler;
+import com.vaadin.flow.server.ErrorHandler;
+import com.vaadin.flow.server.InitParameters;
+import com.vaadin.flow.server.ServiceDestroyEvent;
+import com.vaadin.flow.server.SessionInitEvent;
+import com.vaadin.flow.server.UIInitEvent;
+import com.vaadin.flow.server.VaadinRequest;
+import com.vaadin.flow.server.VaadinResponse;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinServlet;
+import com.vaadin.flow.server.VaadinServletContext;
+import com.vaadin.flow.server.VaadinServletService;
+import com.vaadin.flow.server.VaadinSession;
+import com.vaadin.flow.server.WrappedHttpSession;
+import com.vaadin.flow.shared.communication.PushMode;
+
+/**
+ * Builds and tears down the mocked Vaadin environment.
+ * <p>
+ * {@link #setup()} creates the servlet, service, session, request, response and
+ * UI a deployed application would have, and installs them as the thread-locals
+ * Flow reads. {@link #tearDown()} takes them down again and fires the lifecycle
+ * events a container would. Strong references to the session, UI, request and
+ * response are held in thread-locals, because Flow only soft-references them
+ * and they would otherwise be collected mid-test.
+ * <p>
+ * It also stands in for the browser where Flow expects one to act:
+ * {@link #clientRoundtrip()} runs what a client response would have triggered,
+ * and {@link MockPage} recreates the UI on {@code Page.reload()} the way a
+ * browser refresh does.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class MockVaadin {
+
+    private MockVaadin() {
+    }
+
+    // prevent GC on Vaadin Session and Vaadin UI as they are only
+    // soft-referenced from the Vaadin itself.
+    // use ThreadLocals so that multiple threads may initialize fresh Vaadin
+    // instances at the same time.
+    private static final ThreadLocal<VaadinSession> strongRefSession = new ThreadLocal<>();
+    private static final ThreadLocal<UI> strongRefUI = new ThreadLocal<>();
+    private static final ThreadLocal<VaadinRequest> strongRefReq = new ThreadLocal<>();
+    private static final ThreadLocal<VaadinResponse> strongRefRes = new ThreadLocal<>();
+    private static final ThreadLocal<Location> lastNavigation = new ThreadLocal<>();
+
+    // The window name to assign to the next UI created by createUI. A reload
+    // records the closing UI's window name here so the recreated UI reuses it
+    // (see closeCurrentUI); a brand-new window leaves it unset and gets a
+    // fresh unique name. Mirrors the lastNavigation hand-off.
+    private static final ThreadLocal<String> lastWindowName = new ThreadLocal<>();
+
+    private static final AtomicLong windowNameCounter = new AtomicLong();
+
+    // Maps a UI detached by a page reload to the UI that replaced it. A reload
+    // can be triggered by application code calling Page.reload(), so anything
+    // holding on to a UI (notably BrowserlessUIContext) needs a way to follow
+    // its window to the live UI. Weakly keyed, so an entry disappears as soon
+    // as the detached UI is no longer referenced.
+    private static final Map<UI, UI> reloadReplacements = Collections
+            .synchronizedMap(new WeakHashMap<>());
+
+    private static final ThreadLocal<Boolean> currentlyClosingSession = ThreadLocal
+            .withInitial(() -> Boolean.FALSE);
+
+    private static String userAgent = "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:94.0) Gecko/20100101 Firefox/94.0";
+
+    private static Function<MockHttpSession, MockRequest> mockRequestFactory = MockRequest::new;
+
+    /**
+     * Returns the {@code User-Agent} every mocked request reports. Defaults to
+     * Firefox 94 on Ubuntu Linux.
+     *
+     * @return the user agent string
+     */
+    public static String getUserAgent() {
+        return userAgent;
+    }
+
+    /**
+     * Sets the {@code User-Agent} every mocked request reports. Call before
+     * {@link #setup()}, since the value is read while the session is created.
+     *
+     * @param userAgent
+     *            the user agent string
+     */
+    public static void setUserAgent(String userAgent) {
+        MockVaadin.userAgent = userAgent;
+    }
+
+    /**
+     * Returns the factory creating the {@link MockRequest} of each session.
+     *
+     * @return the request factory
+     */
+    public static Function<MockHttpSession, MockRequest> getMockRequestFactory() {
+        return mockRequestFactory;
+    }
+
+    /**
+     * Sets the factory creating the {@link MockRequest} of each session.
+     * Override when a test needs a subclass of {@link MockRequest}.
+     *
+     * @param mockRequestFactory
+     *            the request factory
+     */
+    public static void setMockRequestFactory(
+            Function<MockHttpSession, MockRequest> mockRequestFactory) {
+        MockVaadin.mockRequestFactory = mockRequestFactory;
+    }
+
+    /**
+     * Records that {@code detached} was replaced by {@code created} during a
+     * page reload, so that {@link #liveUI(UI)} can map the old UI to the new
+     * one.
+     *
+     * @param detached
+     *            the UI the reload tore down
+     * @param created
+     *            the UI that replaced it
+     */
+    public static void recordReloadReplacement(UI detached, UI created) {
+        reloadReplacements.put(detached, created);
+    }
+
+    /**
+     * Follows the reload chain starting at {@code ui} and returns the UI that
+     * is live now: a reload detaches a UI and creates a fresh one for the same
+     * window, so a caller holding the detached UI must be redirected to its
+     * replacement.
+     *
+     * @param ui
+     *            the UI to follow
+     * @return the live UI, or {@code ui} itself if it was never replaced
+     */
+    public static UI liveUI(UI ui) {
+        UI live = ui;
+        UI next = reloadReplacements.get(live);
+        while (next != null && next != live) {
+            live = next;
+            next = reloadReplacements.get(live);
+        }
+        return live;
+    }
+
+    /**
+     * Mocks Vaadin for the current test method:
+     * 
+     * <pre>
+     * MockVaadin.setup(Routes().autoDiscoverViews("com.myapp"))
+     * </pre>
+     *
+     * The UI factory <em>must</em> provide a new, fresh instance of the UI, so
+     * that the tests start from a pre-known state. If you're using Spring and
+     * you're getting UI from the injector, you must reconfigure Spring to use
+     * prototype scope, otherwise an old UI from the UI scope or Session Scope
+     * will be provided.
+     *
+     * Sometimes you wish to provide a specific {@link VaadinServletService},
+     * e.g. to override {@link VaadinServletService#loadInstantiators} and
+     * provide your own way of instantiating Views, e.g. via Spring or Guice.
+     * Please do that by extending {@link MockVaadinServlet} and overriding
+     * {@link MockVaadinServlet#createServletService}
+     * `createServletService(DeploymentConfiguration)`. Please consult
+     * {@link MockService} on what methods you must override in your custom
+     * service. Alternatively, see `MockSpringServlet` (in the
+     * `browserless-test-spring` module) on how to extend your custom servlet
+     * and provide all necessary mocking code.
+     *
+     * @param routes
+     *            all classes annotated with
+     *            {@code com.vaadin.flow.router.Route}; use
+     *            {@link Routes#autoDiscoverViews} to auto-discover all such
+     *            classes.
+     * @param uiFactory
+     *            produces {@link UI} instances and sets them as current, by
+     *            default simply instantiates {@link MockedUI} class.
+     * @param lookupServices
+     *            service classes to be provided to the lookup initializer
+     */
+    public static void setup(Routes routes, UIFactory uiFactory,
+            Set<Class<?>> lookupServices,
+            BrowserlessConfiguration configuration) {
+        // init servlet
+        MockVaadinServlet servlet = new MockVaadinServlet(routes);
+        setup(uiFactory, servlet, lookupServices, configuration);
+    }
+
+    public static void setup(Routes routes, UIFactory uiFactory,
+            Set<Class<?>> lookupServices) {
+        setup(routes, uiFactory, lookupServices,
+                BrowserlessConfiguration.empty());
+    }
+
+    public static void setup(Routes routes, UIFactory uiFactory) {
+        setup(routes, uiFactory, Collections.emptySet());
+    }
+
+    public static void setup(Routes routes) {
+        setup(routes, MockedUI::new, Collections.emptySet());
+    }
+
+    public static void setup() {
+        setup(new Routes(), MockedUI::new, Collections.emptySet());
+    }
+
+    /**
+     * Equivalent to
+     * {@code setup(new Routes(), uiFactory, Collections.emptySet())}.
+     */
+    public static void setup(UIFactory uiFactory) {
+        setup(new Routes(), uiFactory, Collections.emptySet());
+    }
+
+    /**
+     * Use this method when you need to provide a completely custom servlet
+     * (e.g. `SpringServlet`). Do not forget to create a specialized service
+     * which works in mocked environment.
+     *
+     * @param uiFactory
+     *            produces {@link UI} instances and sets them as current.
+     * @param servlet
+     *            allows you to provide your own implementation of
+     *            {@link VaadinServlet}.
+     * @param lookupServices
+     *            service classes to be provided to the lookup initializer
+     */
+    public static void setup(UIFactory uiFactory, VaadinServlet servlet,
+            Set<Class<?>> lookupServices,
+            BrowserlessConfiguration configuration) {
+        VaadinServletService service = setupServlet(servlet, lookupServices,
+                configuration);
+        VaadinService.setCurrent(service);
+
+        // init Vaadin Session
+        createSession(servlet.getServletContext(), uiFactory);
+    }
+
+    public static void setup(UIFactory uiFactory, VaadinServlet servlet,
+            Set<Class<?>> lookupServices) {
+        setup(uiFactory, servlet, lookupServices,
+                BrowserlessConfiguration.empty());
+    }
+
+    public static void setup(UIFactory uiFactory, VaadinServlet servlet) {
+        setup(uiFactory, servlet, Collections.emptySet());
+    }
+
+    public static void setup(VaadinServlet servlet) {
+        setup((UIFactory) MockedUI::new, servlet, Collections.emptySet());
+    }
+
+    public static void setup(VaadinServlet servlet,
+            Set<Class<?>> lookupServices) {
+        setup((UIFactory) MockedUI::new, servlet, lookupServices);
+    }
+
+    /**
+     * Initializes the given {@code servlet} and its service, but does NOT
+     * create a session, UI, or set any thread-locals. Call this when you need
+     * to share a single service across multiple independent sessions
+     * (multi-user testing).
+     *
+     * @return the initialized {@link VaadinServletService}
+     */
+    public static VaadinServletService setupServlet(VaadinServlet servlet,
+            Set<Class<?>> lookupServices,
+            BrowserlessConfiguration configuration) {
+        if (!Utils.isInitialized(servlet)) {
+            // Lookup services can be given both explicitly and through the
+            // configuration (e.g. by a @BrowserlessTestConfig annotation);
+            // they accumulate.
+            Set<Class<?>> allLookupServices = new LinkedHashSet<>(
+                    lookupServices);
+            allLookupServices.addAll(configuration.getLookupServices());
+            ServletContext ctx = MockVaadinHelper
+                    .createMockContext(allLookupServices);
+            // Context init parameters are read by ApplicationConfiguration,
+            // which is created and cached on first access, so they must be set
+            // before anything else touches the context.
+            configuration.getApplicationProperties()
+                    .forEach(ctx::setInitParameter);
+            // Installed before the servlet is initialized, so that feature
+            // flags read during startup (e.g. by a VaadinServiceInitListener)
+            // already observe the test configuration. Installed even without
+            // overrides, so that tests toggling feature flags at runtime don't
+            // write them into the project resources folder, from where other
+            // tests would then read them.
+            BrowserlessFeatureFlags.install(new VaadinServletContext(ctx),
+                    configuration.getFeatureFlags());
+            MockServletConfig config = new MockServletConfig(ctx);
+            config.getServletInitParams()
+                    .putAll(configuration.getApplicationProperties());
+            // Enforced by the browserless environment, so it wins over test
+            // configuration
+            config.getServletInitParams().put(InitParameters.BROWSERLESS,
+                    "true");
+            try {
+                servlet.init(config);
+            } catch (ServletException e) {
+                throw new RuntimeException(e);
+            }
+        } else if (!configuration.isEmpty()) {
+            // Application properties, feature flags and lookup services are all
+            // read while the servlet is initialized, so there is no way to
+            // apply them afterwards. Failing here beats silently running the
+            // test against an environment that never saw its own configuration.
+            throw new BrowserlessTestSetupException(
+                    "Cannot apply a custom Vaadin configuration to "
+                            + servlet.getClass().getName()
+                            + ", because the servlet has already been initialized. The configuration "
+                            + "is read while the servlet initializes, so it must be provided to the "
+                            + "setup creating the servlet. Provide a servlet factory returning a new, "
+                            + "uninitialized servlet instance, or move the configuration to the setup "
+                            + "that initializes it. Discarded configuration: "
+                            + configuration);
+        }
+        VaadinServletService service = MockVaadinServlet.serviceSafe(servlet);
+        if (service == null) {
+            throw new IllegalStateException("Service is null");
+        }
+        if (service.getRouter() == null) {
+            throw new IllegalStateException(servlet
+                    + " failed to call VaadinServletService.init() in createServletService()");
+        }
+        return service;
+    }
+
+    public static VaadinServletService setupServlet(VaadinServlet servlet,
+            Set<Class<?>> lookupServices) {
+        return setupServlet(servlet, lookupServices,
+                BrowserlessConfiguration.empty());
+    }
+
+    public static VaadinServletService setupServlet(VaadinServlet servlet) {
+        return setupServlet(servlet, Collections.emptySet(),
+                BrowserlessConfiguration.empty());
+    }
+
+    /**
+     * Properly closes the current UI and fire the detach event on it. Does
+     * nothing if there is no current UI.
+     */
+    public static void closeCurrentUI(boolean fireUIDetach) {
+        UI ui = UI.getCurrent();
+        if (ui == null) {
+            return;
+        }
+        lastNavigation.set(ui.getInternals().getActiveViewLocation());
+        // Preserve the window name so a following createUI (reload / session
+        // recreation) reuses it, keeping @PreserveOnRefresh's cache key stable.
+        lastWindowName.set(
+                ui.getInternals().getExtendedClientDetails().getWindowName());
+        if (ui.isClosing() && ui.getInternals().getSession() != null) {
+            BasicUtils._close(ui);
+        }
+        if (fireUIDetach) {
+            ComponentUtil.onComponentDetach(ui);
+        }
+        UI.setCurrent(null);
+        strongRefUI.remove();
+    }
+
+    /**
+     * Cleans up and removes the Vaadin UI and Vaadin Session. You can call this
+     * function in `afterEach{}` block, to clean up after the test. This comes
+     * handy when you want to be extra-sure that the next test won't
+     * accidentally reuse old UI, should you forget to call {@code setup}
+     * properly.
+     *
+     * You don't have to call this function though; {@code setup} will overwrite
+     * any current UI/Session instances with a fresh ones.
+     */
+    public static void tearDown() {
+        clearVaadinInstances(false);
+        VaadinService service = VaadinService.getCurrent();
+        if (service != null) {
+            fireServiceDestroyListeners(service,
+                    new ServiceDestroyEvent(service));
+            VaadinService.setCurrent(null);
+        }
+        lastNavigation.remove();
+    }
+
+    private static void clearVaadinInstances(boolean fireUIDetach) {
+        closeCurrentUI(fireUIDetach);
+        closeCurrentSession();
+        CurrentInstance.set(VaadinRequest.class, null);
+        CurrentInstance.set(VaadinResponse.class, null);
+        strongRefReq.remove();
+        strongRefRes.remove();
+    }
+
+    private static void closeCurrentSession() {
+        VaadinSession session = VaadinSession.getCurrent();
+        if (session != null) {
+            fireSessionDestroyAndDrain(session);
+        }
+        strongRefSession.remove();
+    }
+
+    /**
+     * Fires session-destroy listeners on {@code session} and drains pending
+     * {@link VaadinSession#access} tasks scheduled during destruction. The
+     * `currentlyClosingSession` flag is set for the duration so the
+     * `afterSessionClose` recreation hook (used by single-user `setup`) is
+     * suppressed — multi-user callers manage their own session lifecycle.
+     */
+    public static void fireSessionDestroyAndDrain(VaadinSession session) {
+        VaadinService service = session.getService();
+        service.fireSessionDestroy(session);
+        VaadinSession.setCurrent(null);
+        // service destroys session via session.access(); we need to run that
+        // action now.
+        currentlyClosingSession.set(Boolean.TRUE);
+        try {
+            runUIQueue(false, session);
+        } finally {
+            currentlyClosingSession.set(Boolean.FALSE);
+        }
+    }
+
+    /**
+     * Creates a new session, request and response for the given
+     * {@code service}, but does NOT set any thread-locals or create a UI.
+     */
+    public static SessionObjects createSessionObjects(
+            VaadinServletService service) {
+        MockHttpSession httpSession = MockHttpSession
+                .create(service.getServlet().getServletContext());
+
+        // init Vaadin Request
+        MockRequest mockRequest = mockRequestFactory.apply(httpSession);
+        mockRequest.getHeaders().put("User-Agent",
+                Collections.singletonList(userAgent));
+        MockRequestCustomizer customizer = (MockRequestCustomizer) service
+                .getContext().getAttribute(Lookup.class)
+                .lookup(MockRequestCustomizer.class);
+        if (customizer != null) {
+            customizer.apply(mockRequest);
+        }
+        com.vaadin.flow.server.VaadinServletRequest request = MockVaadinServlet
+                .createVaadinServletRequest(mockRequest, service);
+
+        // init Session.
+        VaadinSession session = MockVaadinServlet.createVaadinSession(service,
+                request);
+        ReentrantLock lock = new ReentrantLock();
+        lock.lock();
+        httpSession.setAttribute(service.getServiceName() + ".lock", lock);
+        httpSession.setAttribute(
+                VaadinSession.class.getName() + "." + service.getServiceName(),
+                session);
+        session.refreshTransients(new WrappedHttpSession(httpSession), service);
+        if (session.getLockInstance() == null) {
+            throw new IllegalStateException(session + " created from " + service
+                    + " has null lock. See the MockSession class on how to mock locks properly");
+        }
+        if (!((ReentrantLock) session.getLockInstance()).isLocked()) {
+            throw new IllegalStateException(session + " created from " + service
+                    + ": lock must be locked!");
+        }
+
+        session.setBrowser(MockVaadinServlet.createWebBrowser(request));
+        if (session.getBrowser().getBrowserApplication() == null) {
+            throw new IllegalStateException(
+                    "The WebBrowser has not been mocked properly");
+        }
+
+        // init Vaadin Response
+        com.vaadin.flow.server.VaadinServletResponse response = MockVaadinServlet
+                .createVaadinServletResponse(new MockResponse(), service);
+
+        return new SessionObjects(session, request, response, httpSession);
+    }
+
+    private static void createSession(ServletContext ctx, UIFactory uiFactory) {
+        VaadinServletService service = (VaadinServletService) VaadinService
+                .getCurrent();
+        if (service == null) {
+            throw new IllegalStateException("No current VaadinService");
+        }
+        SessionObjects objs = createSessionObjects(service);
+
+        // install thread-locals
+        strongRefReq.set(objs.request);
+        CurrentInstance.set(VaadinRequest.class, objs.request);
+        VaadinSession.setCurrent(objs.session);
+        strongRefSession.set(objs.session);
+        strongRefRes.set(objs.response);
+        CurrentInstance.set(VaadinResponse.class, objs.response);
+
+        // fire session init listeners
+        fireSessionInitListeners(service,
+                new SessionInitEvent(service, objs.session, objs.request));
+
+        // create UI
+        createUI(uiFactory, objs.session);
+    }
+
+    public static void createUI(UIFactory uiFactory, VaadinSession session) {
+        VaadinRequest request = VaadinRequest.getCurrent();
+        if (request == null) {
+            throw new IllegalStateException("No current request");
+        }
+        UI ui = uiFactory.invoke();
+        if (ui.getSession() != null) {
+            throw new IllegalArgumentException("uiFactory produced UI " + ui
+                    + " which is already attached to a Session, "
+                    + "yet we expect the UI to be a fresh new instance, not yet attached to a Session, so that the tests"
+                    + " are able to always start with a fresh UI with a pre-known state. Perhaps you're "
+                    + "using Spring which reuses a scoped instance of the UI?");
+        }
+
+        // hook into Page.reload() and recreate the UI
+        try {
+            Field pageField = UI.class.getDeclaredField("page");
+            pageField.setAccessible(true);
+            pageField.set(ui, new MockPage(ui, uiFactory, session));
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+        ui.getInternals().setSession(session);
+
+        // Assign a stable, non-null window name via ExtendedClientDetails so
+        // @PreserveOnRefresh works. Flow keys its preserved-component cache on
+        // window.name, and the name must (a) be non-null and (b) stay constant
+        // across reloads of the same window. A reload carries the previous UI's
+        // name in lastWindowName; a brand-new window gets a fresh unique name.
+        // The name is consumed before the UI is initialized, so a failing
+        // initialization cannot leak it into the next createUI on this thread.
+        // Every other detail stays at its placeholder default, exactly as in
+        // the instance Flow would have created lazily: the window name is all
+        // the router reads, so the mock does not fabricate a screen or
+        // viewport geometry it has no way to know.
+        String windowName = lastWindowName.get();
+        if (windowName == null) {
+            windowName = "window-" + windowNameCounter.incrementAndGet();
+        }
+        lastWindowName.remove();
+        ui.getInternals()
+                .setExtendedClientDetails(new ExtendedClientDetails(ui, null,
+                        null, null, null, null, null, null, null, null, null,
+                        null, null, null, null, windowName, null, null, null));
+
+        UI.setCurrent(ui);
+        ui.doInit(request, 1, "ROOT");
+        strongRefUI.set(ui);
+
+        session.addUI(ui);
+        session.getService().getEventBus().fireEvent(
+                new UIInitEvent(ui, session.getService()),
+                rethrowListenerFailure);
+
+        // navigate to the initial page
+        if (lastNavigation.get() != null) {
+            UI.getCurrent().getInternals().getRouter().navigate(UI.getCurrent(),
+                    lastNavigation.get(), NavigationTrigger.PROGRAMMATIC);
+            lastNavigation.remove();
+        } else {
+            if (UI.getCurrent().getInternals().getRouter().getRegistry()
+                    .getNavigationTarget("").isPresent()) {
+                UI.getCurrent().navigate("");
+            }
+        }
+
+        // make sure that UI.getCurrent().push() can be called.
+        // https://github.com/mvysny/karibu-testing/issues/80
+        ui.getPushConfiguration().setPushMode(PushMode.AUTOMATIC);
+    }
+
+    /**
+     * Since Browserless Testing runs in the same JVM as the server and there is
+     * no browser, the boundaries between the client and the server become
+     * unclear.
+     *
+     * Calls the following:
+     * <ul>
+     * <li>{@code runUIQueue}
+     * <li>{@link StateTree#runExecutionsBeforeClientResponse} which runs all
+     * blocks scheduled via {@link UI#beforeClientResponse}
+     * <li>{@link #cleanupDialogs}
+     * </ul>
+     *
+     * If you'd like to test your {@link ErrorHandler} then take a look at
+     * {@code runUIQueue} instead.
+     *
+     * @throws IllegalStateException
+     *             if the environment is not mocked
+     */
+    public static void clientRoundtrip() {
+        if (VaadinSession.getCurrent() == null) {
+            throw new IllegalStateException("No VaadinSession");
+        }
+        runUIQueue();
+        UI.getCurrent().getInternals().getStateTree()
+                .runExecutionsBeforeClientResponse();
+        TestingLifecycleHooks.cleanupDialogs();
+    }
+
+    /**
+     * Runs all tasks scheduled by {@link UI#access}.
+     *
+     * If {@link VaadinSession#errorHandler} is not set or
+     * {@code propagateExceptionToHandler} is false, any exceptions thrown from
+     * {@link Command}s scheduled via the {@link UI#access} will make this
+     * function fail. The exceptions will be wrapped in
+     * {@link ExecutionException}.
+     *
+     * @param propagateExceptionToHandler
+     *            defaults to false. If true and
+     *            {@link VaadinSession#errorHandler} is set, any exceptions
+     *            thrown from {@link Command}s scheduled via the
+     *            {@link UI#access} will be redirected to
+     *            {@link VaadinSession#errorHandler} and will not be re-thrown
+     *            from this method.
+     * @throws IllegalStateException
+     *             if the environment is not mocked
+     */
+    public static void runUIQueue(boolean propagateExceptionToHandler,
+            VaadinSession session) {
+        // we need to set up UI error handler which will be notified for every
+        // exception thrown out of the access{} block
+        // otherwise the exceptions would simply be logged but unlock() wouldn't
+        // fail.
+        final List<Throwable> errors = new ArrayList<>();
+        ErrorHandler oldErrorHandler = session.getErrorHandler();
+        if (oldErrorHandler == null
+                || oldErrorHandler instanceof DefaultErrorHandler
+                || !propagateExceptionToHandler) {
+            session.setErrorHandler(e -> {
+                Throwable t = e.getThrowable();
+                if (!(t instanceof ExecutionException)) {
+                    // for some weird reason t may not be ExecutionException
+                    // when it originates from a coroutine :confused:
+                    // the stacktrace would point someplace random. Wrap it in
+                    // ExecutionException whose stacktrace will point to the
+                    // test
+                    t = new ExecutionException(t.getMessage(), t);
+                }
+                errors.add(t);
+            });
+        }
+
+        try {
+            // make sure the lock is held exactly once, otherwise the
+            // session.unlock() won't
+            // process all Runnables registered via ui.access()
+            int lockCount = ((ReentrantLock) session.getLockInstance())
+                    .getHoldCount();
+            if (lockCount != 1) {
+                throw new AssertionError(
+                        "Expected 1 lock, actual " + lockCount);
+            }
+
+            session.unlock(); // this will process all Runnables registered via
+                              // ui.access()
+            // lock the session back, so that the test can continue running
+            // as-if in the UI thread.
+            session.lock();
+        } finally {
+            session.setErrorHandler(oldErrorHandler);
+        }
+
+        if (!errors.isEmpty()) {
+            Throwable first = errors.get(0);
+            for (int i = 1; i < errors.size(); i++) {
+                first.addSuppressed(errors.get(i));
+            }
+            sneakyThrow(first);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T extends Throwable> void sneakyThrow(Throwable t)
+            throws T {
+        throw (T) t;
+    }
+
+    public static void runUIQueue(boolean propagateExceptionToHandler) {
+        runUIQueue(propagateExceptionToHandler, VaadinSession.getCurrent());
+    }
+
+    public static void runUIQueue() {
+        runUIQueue(false, VaadinSession.getCurrent());
+    }
+
+    /**
+     * Internal function, do not call directly.
+     *
+     * Only usable when you are providing your own implementation of
+     * {@link VaadinSession}. See {@link MockVaadinSession} on how to call this
+     * properly.
+     */
+    public static void afterSessionClose(VaadinSession session,
+            UIFactory uiFactory) {
+        // We need to simulate the actual browser + servlet container behavior
+        // here.
+        // Imagine that we want a test scenario where the user logs out, and we
+        // want to check that a login prompt appears.
+
+        // To log out the user, the code typically closes the session and tells
+        // the browser to reload
+        // the page (Page.getCurrent().reload() or similar).
+        // Thus the page is reloaded by the browser, and since the session is
+        // gone, the servlet container
+        // will create a new, fresh session.
+
+        // That's exactly what we need to do here. We need to close the current
+        // UI and eradicate it,
+        // then we need to close the current session and eradicate it, and then
+        // we need to create a completely fresh
+        // new UI and Session.
+
+        // A problem appears when the uiFactory accidentally doesn't create a
+        // new, fresh instance of UI. Say that
+        // we call Spring injector to provide us an instance of the UI, but we
+        // accidentally scoped the UI to Session.
+        // Spring doesn't know that (since we haven't told Spring that the
+        // Session scope is gone) and provides
+        // the previous UI instance which is still attached to the session. And
+        // it blows.
+
+        if (!currentlyClosingSession.get()) {
+            // Vaadin 20.0.5+: closing session also clears the wrapped
+            // VaadinSession.getSession().
+            // Acquire the wrapped session beforehand.
+            MockHttpSession mockSession = Utils.mock(session);
+            clearVaadinInstances(true);
+            mockSession.destroy();
+            createSession(mockSession.getServletContext(), uiFactory);
+        }
+    }
+
+    /**
+     * Fires session init listeners on the given service. Java-friendly static
+     * wrapper for the internal extension function.
+     */
+    public static void fireSessionInit(VaadinService service,
+            VaadinSession session, VaadinRequest request) {
+        fireSessionInitListeners(service,
+                new SessionInitEvent(service, session, request));
+    }
+
+    /**
+     * Fires service destroy listeners on the given service. Java-friendly
+     * static wrapper for the internal extension function.
+     */
+    public static void fireServiceDestroy(VaadinService service) {
+        fireServiceDestroyListeners(service, new ServiceDestroyEvent(service));
+    }
+
+    /**
+     * Clears the current UI from thread-locals without firing detach events.
+     * Useful for multi-user context where UIs are managed independently.
+     */
+    public static void clearCurrentUI() {
+        UI.setCurrent(null);
+        strongRefUI.remove();
+    }
+
+    /**
+     * Clears the `lastNavigation` ThreadLocal recorded by
+     * {@code closeCurrentUI}.
+     */
+    public static void clearLastNavigation() {
+        lastNavigation.remove();
+        lastWindowName.remove();
+    }
+
+    // ---------------------------------------------------------------
+    // Service lifecycle events
+    // ---------------------------------------------------------------
+
+    /**
+     * Hands a listener failure back to the caller instead of logging it, which
+     * is what {@code VaadinServiceEventBus.fireEvent} does by default. A
+     * listener that throws during a test should fail that test rather than only
+     * leave a line in the log.
+     */
+    private static final SerializableBiConsumer<EventObject, Exception> rethrowListenerFailure = (
+            event, error) -> {
+        sneakyThrow(error);
+    };
+
+    static void fireSessionInitListeners(VaadinService service,
+            SessionInitEvent event) {
+        service.getEventBus().fireEvent(event, rethrowListenerFailure);
+    }
+
+    static void fireServiceDestroyListeners(VaadinService service,
+            ServiceDestroyEvent event) {
+        service.getEventBus().fireEvent(event, rethrowListenerFailure);
+    }
+
+    // ---------------------------------------------------------------
+    // Nested types
+    // ---------------------------------------------------------------
+
+    /**
+     * A Vaadin Session-recreate aware {@link Page} that recreates the UI on
+     * reload (simulating the browser pressing F5) and records outbound
+     * navigation calls so tests can assert on them.
+     */
+    public static class MockPage extends Page {
+
+        private static final Set<String> SELF_NAMES = new HashSet<>(
+                Arrays.asList("_self", "_parent", "_top", ""));
+
+        private final UI ui;
+        private final UIFactory uiFactory;
+        private final VaadinSession session;
+        private final Map<String, List<String>> navigations = new LinkedHashMap<>();
+
+        public MockPage(UI ui, UIFactory uiFactory, VaadinSession session) {
+            super(ui);
+            this.ui = ui;
+            this.uiFactory = uiFactory;
+            this.session = session;
+        }
+
+        public String getLastExternalNavigationURL() {
+            List<String> list = navigations.get("_self");
+            if (list == null || list.isEmpty()) {
+                return null;
+            }
+            return list.get(list.size() - 1);
+        }
+
+        public String getExternalNavigationURL(String windowName) {
+            List<String> list = navigations
+                    .get(normalizeWindowName(windowName));
+            if (list == null || list.isEmpty()) {
+                return null;
+            }
+            return list.get(list.size() - 1);
+        }
+
+        public Map<String, List<String>> getOpenedWindows() {
+            Map<String, List<String>> result = new LinkedHashMap<>();
+            for (Map.Entry<String, List<String>> e : navigations.entrySet()) {
+                if (!"_self".equals(e.getKey())) {
+                    result.put(e.getKey(), new ArrayList<>(e.getValue()));
+                }
+            }
+            return result;
+        }
+
+        @Override
+        public void open(String url, String windowName) {
+            String normalized = normalizeWindowName(windowName);
+            if ("_blank".equals(normalized)) {
+                navigations.computeIfAbsent(normalized, k -> new ArrayList<>())
+                        .add(url);
+            } else {
+                List<String> list = new ArrayList<>();
+                list.add(url);
+                navigations.put(normalized, list);
+            }
+            super.open(url, windowName);
+        }
+
+        @Override
+        public void reload() {
+            UI current = UI.getCurrent();
+            if (current != ui) {
+                if (ui.getSession() == null) {
+                    // This UI lost its session, so it is the logout idiom -
+                    // capture the UI, close its session, then ask its page to
+                    // reload. Closing the session already tore this UI down and
+                    // rendered a fresh one for its window, which is what the
+                    // reload is asking for, so there is nothing left to do. Not
+                    // even the superclass call, which would fail: it schedules
+                    // JavaScript on a UI whose session is gone.
+                    return;
+                }
+                // A live UI, but not the current one. Recreating the UI runs on
+                // the thread-locals of the current UI, so going on would detach
+                // and recreate whichever window is current. Fail before
+                // anything
+                // is changed.
+                throw new IllegalStateException("Cannot reload the page of UI "
+                        + ui + ", because the current UI is "
+                        + (current != null ? current.toString() : "not set")
+                        + ". Reloading recreates the current UI, so the "
+                        + "reloaded window must be the current one. Either this "
+                        + "UI belongs to another window - activate it first, "
+                        + "e.g. through its BrowserlessUIContext or "
+                        + "UI.access() - or an earlier reload already replaced "
+                        + "it, in which case reload the current UI instead.");
+            }
+
+            // recreate the UI on reload(), to simulate browser's F5
+            super.reload();
+            MockVaadin.closeCurrentUI(true);
+            MockVaadin.createUI(uiFactory, session);
+            // Record the swap so holders of the detached UI
+            // (BrowserlessUIContext) can follow the window to the new UI. This
+            // path is also taken when application code calls Page.reload()
+            // itself, not only from the reload() DSL.
+            UI created = UI.getCurrent();
+            if (created != null && created != ui) {
+                MockVaadin.recordReloadReplacement(ui, created);
+            }
+        }
+
+        private String normalizeWindowName(String windowName) {
+            if (windowName == null || SELF_NAMES.contains(windowName)) {
+                return "_self";
+            }
+            return windowName;
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Routes.java b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
index 93e1fcad..3ba256fd 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
@@ -53,8 +53,6 @@
  * <p>
  * Scanning is the slow part of setting a test up, so build one instance and
  * reuse it across setups.
- * <p>
- * For internal use only. May be renamed or removed in a future release.
  */
 public class Routes implements Serializable {
 
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java b/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
new file mode 100644
index 00000000..da01be33
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
@@ -0,0 +1,415 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.HasStyle;
+import com.vaadin.flow.component.HasValue;
+
+/**
+ * A criterion for matching components. The component must match all of non-null
+ * fields.
+ *
+ * You can add more properties, simply by creating a write-only property which
+ * will register a new predicate on write. See <a href=
+ * "https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#adding-support-for-custom-search-criteria">Adding
+ * support for custom search criteria</a> for more details.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public class SearchSpec<T extends Component> {
+
+    /**
+     * The class of the component we are searching for.
+     */
+    private final Class<T> clazz;
+
+    /**
+     * The required {@link Component#getId()}; if null, no particular id is
+     * matched.
+     */
+    private String id;
+
+    /**
+     * The required test id, i.e. the {@code data-testid} attribute; if null, no
+     * particular test id is matched.
+     */
+    private String testId;
+
+    /**
+     * The required {@code caption}; if null, no particular caption is matched.
+     */
+    private String caption;
+
+    /**
+     * The required {@code placeholder}; if null, no particular placeholder is
+     * matched.
+     */
+    private String placeholder;
+
+    /**
+     * The {@code com.vaadin.flow.dom.Element.getText}
+     */
+    private String text;
+
+    /**
+     * Expected count of matching components, defaults to
+     * {@code 0..Int.MAX_VALUE}.
+     */
+    private CountRange count = CountRange.ANY;
+
+    /**
+     * Expected {@code com.vaadin.flow.component.HasValue.getValue}; if
+     * {@code null}, no particular value is matched.
+     */
+    private Object value;
+
+    /**
+     * If not null, the component must match all of these class names.
+     * Space-separated.
+     */
+    private String classes;
+
+    /**
+     * If not null, the component must NOT match any of these class names.
+     * Space-separated.
+     */
+    private String withoutClasses;
+
+    /**
+     * The predicates the component needs to match, not null. May be empty - in
+     * such case it is ignored. By default empty.
+     */
+    private List<Predicate<T>> predicates = new ArrayList<>();
+
+    /**
+     * If not null, the component must have all theme names defined.
+     * Space-separated.
+     */
+    private String themes;
+
+    /**
+     * If not null, the component must NOT have any of the theme names defined.
+     * Space-separated.
+     */
+    private String withoutThemes;
+
+    public SearchSpec(Class<T> clazz) {
+        this.clazz = clazz;
+    }
+
+    // Accessor methods, kept for Java-style usage and to preserve the Kotlin
+    // `is`/getter/setter shape that other code relied on.
+
+    public Class<T> getClazz() {
+        return clazz;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getTestId() {
+        return testId;
+    }
+
+    public void setTestId(String testId) {
+        this.testId = testId;
+    }
+
+    public String getCaption() {
+        return caption;
+    }
+
+    public void setCaption(String caption) {
+        this.caption = caption;
+    }
+
+    public String getPlaceholder() {
+        return placeholder;
+    }
+
+    public void setPlaceholder(String placeholder) {
+        this.placeholder = placeholder;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public CountRange getCount() {
+        return count;
+    }
+
+    public void setCount(CountRange count) {
+        this.count = count;
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    public void setValue(Object value) {
+        this.value = value;
+    }
+
+    public String getClasses() {
+        return classes;
+    }
+
+    public void setClasses(String classes) {
+        this.classes = classes;
+    }
+
+    public String getWithoutClasses() {
+        return withoutClasses;
+    }
+
+    public void setWithoutClasses(String withoutClasses) {
+        this.withoutClasses = withoutClasses;
+    }
+
+    public List<Predicate<T>> getPredicates() {
+        return predicates;
+    }
+
+    public void setPredicates(List<Predicate<T>> predicates) {
+        this.predicates = predicates;
+    }
+
+    public String getThemes() {
+        return themes;
+    }
+
+    public void setThemes(String themes) {
+        this.themes = themes;
+    }
+
+    public String getWithoutThemes() {
+        return withoutThemes;
+    }
+
+    public void setWithoutThemes(String withoutThemes) {
+        this.withoutThemes = withoutThemes;
+    }
+
+    /**
+     * Makes sure that the component's caption contains given {@code substring}.
+     */
+    public void captionContains(String substring) {
+        predicates.add(new CaptionContainsPredicate<>(substring));
+    }
+
+    @Override
+    public String toString() {
+        List<String> list = new ArrayList<>();
+        list.add(clazz.getSimpleName().isBlank() ? clazz.getName()
+                : clazz.getSimpleName());
+        if (id != null) {
+            list.add("id='" + id + "'");
+        }
+        if (testId != null) {
+            list.add("testId='" + testId + "'");
+        }
+        if (caption != null) {
+            list.add("caption='" + caption + "'");
+        }
+        if (placeholder != null) {
+            list.add("placeholder='" + placeholder + "'");
+        }
+        if (text != null) {
+            list.add("text='" + text + "'");
+        }
+        if (classes != null && !classes.isBlank()) {
+            list.add("classes='" + classes + "'");
+        }
+        if (withoutClasses != null && !withoutClasses.isBlank()) {
+            list.add("withoutClasses='" + withoutClasses + "'");
+        }
+        if (themes != null && !themes.isBlank()) {
+            list.add("themes='" + themes + "'");
+        }
+        if (withoutThemes != null && !withoutThemes.isBlank()) {
+            list.add("withoutThemes='" + withoutThemes + "'");
+        }
+        if (value != null) {
+            list.add("value=" + value);
+        }
+        CountRange any = CountRange.ANY;
+        CountRange one = CountRange.ONE;
+        if (!count.equals(any) && !count.equals(one)) {
+            list.add("count=" + count);
+        }
+        for (Predicate<T> p : predicates) {
+            list.add(p.toString());
+        }
+        return String.join(" and ", list);
+    }
+
+    /**
+     * Returns a predicate which matches components based on this spec. All
+     * rules are matched except the count rule. The rules are matched against
+     * given component only (not against its children).
+     */
+    @SuppressWarnings("unchecked")
+    public Predicate<Component> toPredicate() {
+        List<Predicate<Component>> p = new ArrayList<>();
+        p.add(clazz::isInstance);
+        if (id != null) {
+            p.add(component -> java.util.Objects
+                    .equals(BasicUtils.id_(component), id));
+        }
+        if (testId != null) {
+            p.add(component -> java.util.Objects.equals(component.getTestId(),
+                    testId));
+        }
+        if (caption != null) {
+            p.add(component -> java.util.Objects
+                    .equals(ComponentUtils.caption(component), caption));
+        }
+        if (placeholder != null) {
+            p.add(component -> java.util.Objects.equals(
+                    ComponentUtils.placeholder(component), placeholder));
+        }
+        if (classes != null && !classes.isBlank()) {
+            final String required = classes;
+            p.add(component -> hasAllClasses(component, required));
+        }
+        if (withoutClasses != null && !withoutClasses.isBlank()) {
+            final String forbidden = withoutClasses;
+            p.add(component -> doesntHaveAnyClasses(component, forbidden));
+        }
+        if (themes != null && !themes.isBlank()) {
+            final String required = themes;
+            p.add(component -> hasAllThemes(component, required));
+        }
+        if (withoutThemes != null && !withoutThemes.isBlank()) {
+            final String forbidden = withoutThemes;
+            p.add(component -> notContainsThemes(component, forbidden));
+        }
+        if (text != null) {
+            p.add(component -> java.util.Objects
+                    .equals(component.getElement().getText(), text));
+        }
+        if (value != null) {
+            p.add(component -> {
+                if (component instanceof HasValue<?, ?>) {
+                    return java.util.Objects.equals(
+                            ((HasValue<?, ?>) component).getValue(), value);
+                }
+                return false;
+            });
+        }
+        for (final Predicate<T> predicate : predicates) {
+            p.add(component -> clazz.isInstance(component)
+                    && predicate.test((T) component));
+        }
+        return component -> {
+            for (Predicate<Component> pred : p) {
+                if (!pred.test(component)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+    }
+
+    private static boolean hasAllClasses(Component component, String classes) {
+        if (classes.contains(" ")) {
+            for (String single : Locator
+                    .filterNotBlank(Arrays.asList(classes.split(" ")))) {
+                if (!hasAllClasses(component, single)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (!(component instanceof HasStyle)) {
+            return false;
+        }
+        return ((HasStyle) component).getClassNames().contains(classes);
+    }
+
+    private static boolean doesntHaveAnyClasses(Component component,
+            String classes) {
+        if (classes.contains(" ")) {
+            for (String single : Locator
+                    .filterNotBlank(Arrays.asList(classes.split(" ")))) {
+                if (hasAllClasses(component, single)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (!(component instanceof HasStyle)) {
+            return true;
+        }
+        return !((HasStyle) component).getClassNames().contains(classes);
+    }
+
+    private static boolean hasAllThemes(Component component, String themes) {
+        for (String t : Locator
+                .filterNotBlank(Arrays.asList(themes.split(" ")))) {
+            if (!component.getElement().getThemeList().contains(t)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean notContainsThemes(Component component,
+            String themes) {
+        for (String t : Locator
+                .filterNotBlank(Arrays.asList(themes.split(" ")))) {
+            if (component.getElement().getThemeList().contains(t)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static final class CaptionContainsPredicate<T extends Component>
+            implements Predicate<T> {
+        private final String substring;
+
+        CaptionContainsPredicate(String substring) {
+            this.substring = substring;
+        }
+
+        @Override
+        public boolean test(T t) {
+            return ComponentUtils.caption(t).contains(substring);
+        }
+
+        @Override
+        public String toString() {
+            return "captionContains('" + substring + "')";
+        }
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java b/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
new file mode 100644
index 00000000..7c83926e
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.Objects;
+
+import com.vaadin.browserless.mocks.MockHttpSession;
+import com.vaadin.flow.server.VaadinRequest;
+import com.vaadin.flow.server.VaadinResponse;
+import com.vaadin.flow.server.VaadinSession;
+
+/**
+ * Holds the objects created during session initialization, before they are
+ * installed as thread-locals. Used by {@link MockVaadin#createSessionObjects}
+ * to allow callers (e.g. multi-user context) to manage thread-locals
+ * themselves.
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ */
+public final class SessionObjects {
+
+    public final VaadinSession session;
+    public final VaadinRequest request;
+    public final VaadinResponse response;
+    public final MockHttpSession httpSession;
+
+    public SessionObjects(VaadinSession session, VaadinRequest request,
+            VaadinResponse response, MockHttpSession httpSession) {
+        this.session = session;
+        this.request = request;
+        this.response = response;
+        this.httpSession = httpSession;
+    }
+
+    public VaadinSession getSession() {
+        return session;
+    }
+
+    public VaadinRequest getRequest() {
+        return request;
+    }
+
+    public VaadinResponse getResponse() {
+        return response;
+    }
+
+    public MockHttpSession getHttpSession() {
+        return httpSession;
+    }
+
+    public SessionObjects copy(VaadinSession session, VaadinRequest request,
+            VaadinResponse response, MockHttpSession httpSession) {
+        return new SessionObjects(session, request, response, httpSession);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof SessionObjects)) {
+            return false;
+        }
+        SessionObjects other = (SessionObjects) o;
+        return Objects.equals(session, other.session)
+                && Objects.equals(request, other.request)
+                && Objects.equals(response, other.response)
+                && Objects.equals(httpSession, other.httpSession);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(session, request, response, httpSession);
+    }
+
+    @Override
+    public String toString() {
+        return "SessionObjects(session=" + session + ", request=" + request
+                + ", response=" + response + ", httpSession=" + httpSession
+                + ")";
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java b/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
new file mode 100644
index 00000000..d1e4d827
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.io.Serializable;
+
+import com.vaadin.flow.component.UI;
+
+/**
+ * Creates the {@link UI} of a Vaadin session.
+ * <p>
+ * The factory <em>must</em> return a fresh instance every time. A UI already
+ * attached to a session carries that session's state into the next test, which
+ * is why {@code MockVaadin.createUI} refuses one.
+ * <p>
+ * Pass an implementation to
+ * {@code BrowserlessApplicationContext.Builder.withUIFactory(UIFactory)} to
+ * have tests run against a {@link UI} subclass of your own, or to
+ * {@code withServletFactory(…)} alongside the routes.
+ * <p>
+ * The single abstract method is named {@code invoke()} to match the bytecode
+ * shape of the Kotlin {@code () -> UI} interface it replaces, so that existing
+ * lambdas and method references such as {@code MockedUI::new} keep binding.
+ */
+@FunctionalInterface
+public interface UIFactory extends Serializable {
+    UI invoke();
+}
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt b/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
index 60c061d7..c42daf5c 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
@@ -58,8 +58,6 @@ import com.vaadin.browserless.internal.BasicUtils._fireEvent
 import com.vaadin.browserless.internal.Renderers._getPresentationValue
 import com.vaadin.browserless.internal.BasicUtils._saneFetchLimit
 import com.vaadin.browserless.internal.BasicUtils.checkEditableByUser
-import com.vaadin.browserless.internal.filterNotBlank
-import com.vaadin.browserless.internal.size
 import com.vaadin.browserless.internal.Renderers.template
 import com.vaadin.browserless.internal.PrettyPrintTree.toPrettyString
 import java.lang.reflect.Method
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Matches.kt b/shared/src/main/kotlin/com/vaadin/browserless/component/GridSupport.kt
similarity index 52%
rename from shared/src/main/kotlin/com/vaadin/browserless/internal/Matches.kt
rename to shared/src/main/kotlin/com/vaadin/browserless/component/GridSupport.kt
index 8e54ae82..062eaf77 100644
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Matches.kt
+++ b/shared/src/main/kotlin/com/vaadin/browserless/component/GridSupport.kt
@@ -13,22 +13,20 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.vaadin.browserless.internal
-
-import com.vaadin.flow.component.Component
+package com.vaadin.browserless.component
 
 /**
- * Checks whether this component matches given spec. All rules are matched except the [count] rule. The
- * rules are matched against given component only (not against its children).
- *
- * Stays Kotlin until [SearchSpec] is ported, since it takes a Kotlin DSL block.
+ * The last Kotlin-only helpers `Grid.kt` still needs. Both go away with it in
+ * the final phase of the port.
  */
-fun Component.matches(spec: SearchSpec<Component>.() -> Unit): Boolean =
-    SearchSpec(Component::class.java).apply { spec() }.toPredicate().invoke(this)
 
 /**
  * Size of the [IntRange], used by the `Grid._dump()` implementation.
- *
- * Stays Kotlin until `Grid.kt` is ported.
  */
-val IntRange.size: Int get() = (endInclusive + 1 - start).coerceAtLeast(0)
+internal val IntRange.size: Int get() = (endInclusive + 1 - start).coerceAtLeast(0)
+
+/**
+ * Removes nulls and blank strings from this iterable.
+ */
+internal fun Iterable<String?>.filterNotBlank(): List<String> =
+    filterNotNull().filter { it.isNotBlank() }
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
deleted file mode 100644
index 32b3b747..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
+++ /dev/null
@@ -1,438 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-@file:Suppress("FunctionName")
-
-package com.vaadin.browserless.internal
-
-import java.util.function.Predicate
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.HasStyle
-import com.vaadin.flow.component.HasValue
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.dialog.Dialog
-import com.vaadin.flow.router.InternalServerError
-import com.vaadin.browserless.internal.BasicUtils.errorMessage
-import com.vaadin.browserless.internal.BasicUtils.id_
-import com.vaadin.browserless.internal.BasicUtils.isEffectivelyVisible
-import com.vaadin.browserless.internal.ComponentUtils.caption
-import com.vaadin.browserless.internal.ComponentUtils.isPolymerTemplate
-import com.vaadin.browserless.internal.ComponentUtils.placeholder
-import com.vaadin.browserless.internal.Utils.currentUI
-import com.vaadin.browserless.internal.Utils.hasPolymerTemplates
-import com.vaadin.browserless.internal.PrettyPrintTree.toPrettyString
-import com.vaadin.browserless.internal.PrettyPrintTree.toPrettyTree
-
-/**
- * A criterion for matching components. The component must match all of non-null fields.
- *
- * You can add more properties, simply by creating a write-only property which will register a new [predicate] on write. See
- * [Adding support for custom search criteria](https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#adding-support-for-custom-search-criteria)
- * for more details.
- * @property clazz the class of the component we are searching for.
- * @property id the required [Component.getId]; if null, no particular id is matched.
- * @property testId the required [Component.getTestId] (i.e. the `data-testid` attribute); if null, no particular test id is matched.
- * @property caption the required [Component.caption]; if null, no particular caption is matched.
- * @property placeholder the required [Component.placeholder]; if null, no particular placeholder is matched.
- * @property text the [com.vaadin.flow.dom.Element.getText]
- * @property count expected count of matching components, defaults to `0..Int.MAX_VALUE`
- * @property value expected [com.vaadin.flow.component.HasValue.getValue]; if `null`, no particular value is matched.
- * @property classes if not null, the component must match all of these class names. Space-separated.
- * @property withoutClasses if not null, the component must NOT match any of these class names. Space-separated.
- * @property predicates the predicates the component needs to match, not null. May be empty - in such case it is ignored. By default empty.
- * @property themes if not null, the component must have all theme names defined. Space-separated
- * @property withoutThemes if not null, the component must NOT have any of the theme names defined. Space-separated
- */
-class SearchSpec<T : Component>(
-        val clazz: Class<T>,
-        var id: String? = null,
-        var testId: String? = null,
-        var caption: String? = null,
-        var placeholder: String? = null,
-        var text: String? = null,
-        var count: IntRange = 0..Int.MAX_VALUE,
-        var value: Any? = null,
-        var classes: String? = null,
-        var withoutClasses: String? = null,
-        var predicates: MutableList<Predicate<T>> = mutableListOf(),
-        var themes: String? = null,
-        var withoutThemes: String? = null
-) {
-
-    override fun toString(): String {
-        val list = mutableListOf<String>(if (clazz.simpleName.isBlank()) clazz.name else clazz.simpleName)
-        if (id != null) list.add("id='$id'")
-        if (testId != null) list.add("testId='$testId'")
-        if (caption != null) list.add("caption='$caption'")
-        if (placeholder != null) list.add("placeholder='$placeholder'")
-        if (text != null) list.add("text='$text'")
-        if (!classes.isNullOrBlank()) list.add("classes='$classes'")
-        if (!withoutClasses.isNullOrBlank()) list.add("withoutClasses='$withoutClasses'")
-        if (!themes.isNullOrBlank()) list.add("themes='$themes'")
-        if (!withoutThemes.isNullOrBlank()) list.add("withoutThemes='$withoutThemes'")
-        if (value != null) list.add("value=$value")
-        if (count != (0..Int.MAX_VALUE) && count != 1..1) list.add("count=$count")
-        list.addAll(predicates.map { it.toString() })
-        return list.joinToString(" and ")
-    }
-
-    /**
-     * Makes sure that the component's [Component.caption] contains given [substring].
-     */
-    fun captionContains(substring: String) {
-        predicates.add(CaptionContainsPredicate(substring))
-    }
-
-    /**
-     * Returns a predicate which matches components based on this spec. All rules are matched except the [count] rule. The
-     * rules are matched against given component only (not against its children).
-     */
-    @Suppress("UNCHECKED_CAST")
-    fun toPredicate(): (Component) -> Boolean {
-        val p = mutableListOf<(Component)->Boolean>()
-        p.add { component -> clazz.isInstance(component)}
-        if (id != null) p.add { component -> id_(component) == id }
-        if (testId != null) p.add { component -> component.testId == testId }
-        if (caption != null) p.add { component -> caption(component) == caption }
-        if (placeholder != null) p.add { component -> placeholder(component) == placeholder }
-        if (!classes.isNullOrBlank()) p.add { component -> component.hasAllClasses(classes!!) }
-        if (!withoutClasses.isNullOrBlank()) p.add { component -> component.doesntHaveAnyClasses(withoutClasses!!) }
-        if (!themes.isNullOrBlank()) p.add { component -> component.hasAllThemes(themes!!) }
-        if (!withoutThemes.isNullOrBlank()) p.add { component -> component.notContainsThemes(withoutThemes!!) }
-        if (text != null) p.add { component -> component.element.text == text }
-        if (value != null) p.add { component -> (component as? HasValue<*, *>)?.getValue() == value }
-        p.addAll(predicates.map { predicate -> { component: Component -> clazz.isInstance(component) && predicate.test(component as T) } })
-        return p.and()
-    }
-}
-
-
-private data class CaptionContainsPredicate<T : Component>(val substring: String) : Predicate<T> {
-    override fun test(t: T): Boolean = caption(t).contains(substring)
-    override fun toString() = "captionContains('$substring')"
-}
-
-fun Iterable<String?>.filterNotBlank(): List<String> = filterNotNull().filter { it.isNotBlank() }
-
-private fun Component.hasAllClasses(classes: String): Boolean {
-    if (classes.contains(' ')) return classes.split(' ').filterNotBlank().all { hasAllClasses(it) }
-    if (this !is HasStyle) return false
-    return classNames.contains(classes)
-}
-private fun Component.doesntHaveAnyClasses(classes: String): Boolean {
-    if (classes.contains(' ')) return classes.split(' ').filterNotBlank().all { !hasAllClasses(it) }
-    if (this !is HasStyle) return true
-    return !classNames.contains(classes)
-}
-
-private fun Component.hasAllThemes(themes: String): Boolean {
-    return themes.split(' ').filterNotBlank().all { element.themeList.contains(it) }
-}
-
-private fun Component.notContainsThemes(themes: String): Boolean {
-    return themes.split(' ').filterNotBlank().all { !element.themeList.contains(it) }
-}
-
-/**
- * Finds a VISIBLE component of given type which matches given [block]. This component and all of its descendants are searched.
- * @param block the search specification
- * @return the only matching component, never null.
- * @throws IllegalArgumentException if no component matched, or if more than one component matches.
- */
-inline fun <reified T: Component> Component._get(noinline block: SearchSpec<T>.()->Unit = {}): T = this._get(T::class.java, block)
-
-/**
- * Finds a VISIBLE component of given [clazz] which matches given [block]. This component and all of its descendants are searched.
- * @param clazz the component must be of this class.
- * @param block the search specification
- * @return the only matching component, never null.
- * @throws IllegalArgumentException if no component matched, or if more than one component matches.
- */
-fun <T: Component> Component._get(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}): T {
-    val result: List<T> = _find(clazz) {
-        count = 1..1
-        block()
-        check(count == 1..1) { "You're calling _get which is supposed to return exactly 1 component, yet you tried to specify the count of $count" }
-    }
-    return clazz.cast(result.single())
-}
-
-/**
- * Finds a VISIBLE component in the current UI of given type which matches given [block]. The [currentUI] and all of its descendants are searched.
- * @return the only matching component, never null.
- * @throws IllegalArgumentException if no component matched, or if more than one component matches.
- */
-inline fun <reified T: Component> _get(noinline block: SearchSpec<T>.()->Unit = {}): T =
-    _get(T::class.java, block)
-
-/**
- * Finds a VISIBLE component in the current UI of given [clazz] which matches given [block]. The [currentUI] and all of its descendants are searched.
- * @param clazz the component must be of this class.
- * @param block the search specification
- * @return the only matching component, never null.
- * @throws IllegalArgumentException if no component matched, or if more than one component matches.
- */
-fun <T: Component> _get(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}): T = currentUI()._get(clazz, block)
-
-/**
- * Finds a list of VISIBLE components of given [clazz] which matches [block]. This component and all of its descendants are searched.
- * @return the list of matching components, may be empty.
- */
-fun <T: Component> Component._find(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}): List<T> {
-    val spec: SearchSpec<T> = SearchSpec(clazz)
-    spec.block()
-    val result: List<Component> = find(spec.toPredicate())
-    if (result.size !in spec.count) {
-
-        val loc: String = currentPath ?: "?"
-
-        var message: String = when {
-            result.isEmpty() -> "/$loc: No visible ${clazz.simpleName}"
-            result.size < spec.count.first -> "/$loc: Too few (${result.size}) visible ${clazz.simpleName}s"
-            else -> "/$loc: Too many visible ${clazz.simpleName}s (${result.size})"
-        }
-        message = "$message in ${toPrettyString(this)} matching $spec: [${result.joinToString { toPrettyString(it) }}]. Component tree:\n${toPrettyTree(this)}"
-
-        // if there's a PolymerTemplate, warn that Browserless Testing can't really locate components in there:
-        // https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#polymer-templates
-        // fixes https://github.com/mvysny/karibu-testing/issues/35
-        val hasPolymerTemplates: Boolean = hasPolymerTemplates() && _walkAll().any { isPolymerTemplate(it) }
-        if (hasPolymerTemplates) {
-            message = "$message\nWarning: Browserless Testing is not able to look up components from inside of PolymerTemplate. Please see https://github.com/mvysny/karibu-testing/tree/master/karibu-testing-v10#polymer-templates for more details."
-        }
-
-        // find() used to fail with IllegalArgumentException which makes sense for a general-purpose utility method. However,
-        // since find() is used in tests overwhelmingly, not finding the correct set of components is generally treated as an assertion error.
-        throw AssertionError(message)
-    }
-    return result.filterIsInstance(clazz)
-}
-
-/**
- * Finds a list of VISIBLE components of given type which matches [block]. This component and all of its descendants are searched.
- * @return the list of matching components, may be empty.
- */
-inline fun <reified T: Component> Component._find(noinline block: SearchSpec<T>.()->Unit = {}): List<T> = this._find(T::class.java, block)
-
-/**
- * Finds a list of VISIBLE components in the current UI of given type which matches given [block]. The [UI.getCurrent] and all of its descendants are searched.
- * @param block the search specification
- * @return the list of matching components, may be empty.
- */
-inline fun <reified T: Component> _find(noinline block: SearchSpec<T>.()->Unit = {}): List<T> =
-    _find(T::class.java, block)
-
-/**
- * Finds a list of VISIBLE components of given [clazz] which matches [block]. The [UI.getCurrent] and all of its descendants are searched.
- * @return the list of matching components, may be empty.
- */
-fun <T: Component> _find(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}): List<T> =
-        currentUI()._find(clazz, block)
-
-private fun Component.find(predicate: (Component)->Boolean): List<Component> {
-    TestingLifecycleHooks.getCurrent().awaitBeforeLookup()
-    val descendants: List<Component> = _walkAll().toList()
-    TestingLifecycleHooks.getCurrent().awaitAfterLookup()
-    val error: InternalServerError? = descendants.filterIsInstance<InternalServerError>().firstOrNull()
-    if (error != null) {
-        throw AssertionError("An internal server error occurred; please check log for the actual stack-trace. Error text: ${errorMessage(error)}\n${toPrettyTree(currentUI())}")
-    }
-    return descendants.filter { isEffectivelyVisible(it) && predicate(it) }
-}
-
-/**
- * `AND`s all predicates.
- */
-private fun <T> Iterable<(T) -> Boolean>.and(): (T) -> Boolean =
-    { component -> all { it(component) } }
-
-/**
- * Walks the component child/descendant tree, depth-first: first the component, then its descendants,
- * then its next sibling.
- */
-fun Component._walkAll(): Iterable<Component> = Iterable {
-    DepthFirstTreeIterator(this) { component: Component -> TestingLifecycleHooks.getCurrent().getAllChildren(component) }
-}
-
-/**
- * Expects that there are no VISIBLE components of given type which matches [block]. This component and all of its descendants are searched.
- * @throws IllegalArgumentException if one or more components matched.
- */
-inline fun <reified T: Component> Component._expectNone(noinline block: SearchSpec<T>.()->Unit = {}) {
-    this._expectNone(T::class.java, block)
-}
-
-/**
- * Expects that there are no VISIBLE components of given [clazz] which matches [block]. This component and all of its descendants are searched.
- * @throws IllegalArgumentException if one or more components matched.
- */
-fun <T: Component> Component._expectNone(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}) {
-    val result: List<T> = _find(clazz) {
-        count = 0..0
-        block()
-        check(count == 0..0) { "You're calling _expectNone which expects 0 component, yet you tried to specify the count of $count" }
-    }
-    check(result.isEmpty()) // safety check that _find works as expected
-}
-
-/**
- * Expects that there are no dialogs shown.
- */
-fun _expectNoDialogs() {
-    _expectNone<Dialog>()
-}
-
-/**
- * Expects that there are no VISIBLE components in the current UI of given type which matches [block]. The [currentUI] and all of its descendants are searched.
- * @throws IllegalArgumentException if one or more components matched.
- */
-inline fun <reified T: Component> _expectNone(noinline block: SearchSpec<T>.()->Unit = {}) {
-    _expectNone(T::class.java, block)
-}
-
-/**
- * Expects that there are no VISIBLE components in the current UI of given [clazz] which matches [block]. The [currentUI] and all of its descendants are searched.
- * @throws IllegalArgumentException if one or more components matched.
- */
-fun <T: Component> _expectNone(clazz: Class<T>, block: SearchSpec<T>.()->Unit = {}) {
-    currentUI()._expectNone(clazz, block)
-}
-
-/**
- * Expects that there is exactly one VISIBLE components of given type which matches [block]. This component and all of its descendants are searched.
- * @throws AssertionError if none, or more than one components matched.
- */
-inline fun <reified T : Component> Component._expectOne(noinline block: SearchSpec<T>.() -> Unit = {}) {
-    this._expectOne(T::class.java, block)
-}
-
-/**
- * Expects that there is exactly one VISIBLE components of given [clazz] which matches [block]. This component and all of its descendants are searched.
- * @throws AssertionError if none, or more than one components matched.
- */
-fun <T : Component> Component._expectOne(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
-    // technically _expectOne is the same as _get, but the semantics differ - with _get() we're "just" doing a lookup (and asserting on
-    // the component later). _expectOne() explicitly declares in the test sources that we want to check that there is exactly one such component.
-    _get(clazz, block)
-}
-
-/**
- * Expects that there is exactly one VISIBLE components in the current UI of given type which matches [block]. The [currentUI] and all of its descendants are searched.
- * @throws AssertionError if none, or more than one components matched.
- */
-inline fun <reified T : Component> _expectOne(noinline block: SearchSpec<T>.() -> Unit = {}) {
-    _expectOne(T::class.java, block)
-}
-
-/**
- * Expects that there is exactly one VISIBLE components in the current UI of given [clazz] which matches [block]. The [currentUI] and all of its descendants are searched.
- * @throws AssertionError if none, or more than one components matched.
- */
-fun <T : Component> _expectOne(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
-    currentUI()._expectOne(clazz, block)
-}
-
-/**
- * Expects that there are exactly [count] VISIBLE components matching [block]. This component and all of its descendants are searched. Examples:
- * ```
- * // check that there are 5 buttons in a button bar
- * buttonBar._expect<Button>(5..5)
- * // check that there are either 3, 4 or 5 vertical layouts in the UI with given class
- * _expect<VerticalLayout>{ count = 3..5; styles = "menubar" }
- * ```
- * Special cases: for asserting one component use [_expectOne]. For asserting no components use [_expectNone].
- * @throws AssertionError if incorrect count of component matched.
- */
-inline fun <reified T : Component> Component._expect(count: Int = 1, noinline block: SearchSpec<T>.() -> Unit = {}) {
-    this._expect(T::class.java, count, block)
-}
-
-/**
- * Expects that there are exactly [count] VISIBLE components of given [clazz] match [block]. This component and all of its descendants are searched. Examples:
- * ```
- * // check that there are 5 buttons in a button bar
- * buttonBar._expect<Button>(5)
- * // check that there are either 3, 4 or 5 vertical layouts in the UI with given class
- * _expect<VerticalLayout>{ count = 3..5; styles = "menubar" }
- * ```
- * Special cases: for asserting one component use [_expectOne]. For asserting no components use [_expectNone].
- * @throws AssertionError if incorrect count of component matched.
- */
-fun <T : Component> Component._expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T>.() -> Unit = {}) {
-    // technically _expect is the same as _find, but the semantics differ - with _find() we're "just" doing a lookup (and asserting on
-    // the components later). _expect() explicitly declares in the test sources that we want to check that there are exactly x components that match given spec.
-    _find(clazz) {
-        this.count = count..count
-        block()
-    }
-}
-
-/**
- * Expects that there are exactly [count] VISIBLE components in the current UI match [block]. The [currentUI] and all of its descendants are searched. Examples:
- * ```
- * // check that there are 5 buttons in a button bar
- * buttonBar._expect<Button>(5..5)
- * // check that there are either 3, 4 or 5 vertical layouts in the UI with given class
- * _expect<VerticalLayout>{ count = 3..5; styles = "menubar" }
- * ```
- * Special cases: for asserting one component use [_expectOne]. For asserting no components use [_expectNone].
- * @throws AssertionError if incorrect count of component matched.
- */
-inline fun <reified T : Component> _expect(count: Int = 1, noinline block: SearchSpec<T>.() -> Unit = {}) {
-    _expect(T::class.java, count, block)
-}
-
-/**
- * Expects that there are exactly [count] VISIBLE components in the current UI with given [clazz] match [block]. The [currentUI] and all of its descendants are searched. Examples:
- * ```
- * // check that there are 5 buttons in a button bar
- * buttonBar._expect<Button>(5)
- * // check that there are either 3, 4 or 5 vertical layouts in the UI with given class
- * _expect<VerticalLayout>{ count = 3..5; styles = "menubar" }
- * ```
- * Special cases: for asserting one component use [_expectOne]. For asserting no components use [_expectNone].
- * They provide
- * a better error message in case of a failure, and also communicate your intent
- * as a test writer better in the test code.
- * @throws AssertionError if incorrect count of component matched.
- */
-fun <T : Component> _expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T>.() -> Unit = {}) {
-    currentUI()._expect(clazz, count, block)
-}
-
-/**
- * Asserts that the [InternalServerError] page is currently being shown, optionally
- * with given [expectedErrorMessage].
- */
-fun _expectInternalServerError(expectedErrorMessage: String = "") {
-    TestingLifecycleHooks.getCurrent().awaitBeforeLookup()
-    val descendants: List<Component> = currentUI()._walkAll().toList()
-    TestingLifecycleHooks.getCurrent().awaitAfterLookup()
-    val error: InternalServerError? = descendants.filterIsInstance<InternalServerError>().firstOrNull()
-    if (error == null) {
-        throw AssertionError("Expected an internal server error but none happened. Component tree:\n${toPrettyTree(currentUI())}")
-    }
-    if (!errorMessage(error).contains(expectedErrorMessage)) {
-        throw AssertionError("Expected InternalServerError with message '$expectedErrorMessage' but was '${errorMessage(error)}'. Component tree:\n${toPrettyTree(currentUI())}")
-    }
-}
-
-/**
- * Returns the browser's current path. Returns null if there is no current UI.
- */
-val currentPath: String? get() {
-    return UI.getCurrent()?.internals?.activeViewLocation?.pathWithQueryParameters
-}
-
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt b/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
deleted file mode 100644
index 378d2014..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
+++ /dev/null
@@ -1,726 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.io.Serializable
-import java.util.Collections
-import java.util.EventObject
-import java.util.WeakHashMap
-import java.util.concurrent.ExecutionException
-import java.util.concurrent.atomic.AtomicLong
-import java.util.concurrent.locks.ReentrantLock
-import jakarta.servlet.ServletContext
-import com.vaadin.flow.component.ComponentUtil
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.page.ExtendedClientDetails
-import com.vaadin.flow.component.page.Page
-import com.vaadin.flow.di.Lookup
-import com.vaadin.flow.function.SerializableBiConsumer
-import com.vaadin.flow.internal.CurrentInstance
-import com.vaadin.flow.internal.StateTree
-import com.vaadin.flow.router.Location
-import com.vaadin.flow.router.NavigationTrigger
-import com.vaadin.flow.server.DefaultErrorHandler
-import com.vaadin.flow.server.ErrorHandler
-import com.vaadin.flow.server.ServiceDestroyEvent
-import com.vaadin.flow.server.SessionInitEvent
-import com.vaadin.flow.server.UIInitEvent
-import com.vaadin.flow.server.VaadinRequest
-import com.vaadin.flow.server.VaadinResponse
-import com.vaadin.flow.server.VaadinService
-import com.vaadin.flow.server.VaadinServiceEventBus
-import com.vaadin.flow.server.InitParameters
-import com.vaadin.flow.server.VaadinServlet
-import com.vaadin.flow.server.VaadinServletContext
-import com.vaadin.flow.server.VaadinServletService
-import com.vaadin.flow.server.VaadinSession
-import com.vaadin.flow.server.WrappedHttpSession
-import com.vaadin.flow.shared.communication.PushMode
-import com.vaadin.browserless.BrowserlessConfiguration
-import com.vaadin.browserless.BrowserlessTestSetupException
-import com.vaadin.browserless.internal.BasicUtils._close
-import com.vaadin.browserless.internal.Utils.isInitialized
-import com.vaadin.browserless.internal.Utils.mock
-import com.vaadin.browserless.mocks.MockHttpSession
-import com.vaadin.browserless.mocks.MockRequest
-import com.vaadin.browserless.mocks.MockResponse
-import com.vaadin.browserless.mocks.MockServletConfig
-import com.vaadin.browserless.mocks.MockVaadinHelper
-import com.vaadin.browserless.mocks.MockVaadinServlet
-import com.vaadin.browserless.mocks.MockedUI
-
-/**
- * Holds the objects created during session initialization, before they are
- * installed as thread-locals. Used by [MockVaadin.createSessionObjects] to
- * allow callers (e.g. multi-user context) to manage thread-locals themselves.
- */
-data class SessionObjects(
-    val session: VaadinSession,
-    val request: VaadinRequest,
-    val response: VaadinResponse,
-    val httpSession: MockHttpSession
-)
-
-object MockVaadin {
-    // prevent GC on Vaadin Session and Vaadin UI as they are only soft-referenced from the Vaadin itself.
-    // use ThreadLocals so that multiple threads may initialize fresh Vaadin instances at the same time.
-    private val strongRefSession = ThreadLocal<VaadinSession>()
-    private val strongRefUI = ThreadLocal<UI>()
-    private val strongRefReq = ThreadLocal<VaadinRequest>()
-    private val strongRefRes = ThreadLocal<VaadinResponse>()
-    private val lastNavigation = ThreadLocal<Location>()
-
-    // The window name to assign to the next UI created by [createUI]. A reload
-    // records the closing UI's window name here so the recreated UI reuses it
-    // (see [closeCurrentUI]); a brand-new window leaves it unset and gets a
-    // fresh unique name. Mirrors the [lastNavigation] hand-off.
-    private val lastWindowName = ThreadLocal<String>()
-    private val windowNameCounter = AtomicLong()
-
-    // Maps a UI detached by a page reload to the UI that replaced it. A reload
-    // can be triggered by application code calling Page.reload(), so anything
-    // holding on to a UI (notably BrowserlessUIContext) needs a way to follow
-    // its window to the live UI. Weakly keyed, so an entry disappears as soon
-    // as the detached UI is no longer referenced.
-    private val reloadReplacements: MutableMap<UI, UI> =
-        Collections.synchronizedMap(WeakHashMap())
-
-    /**
-     * Mocks Vaadin for the current test method:
-     * ```
-     * MockVaadin.setup(Routes().autoDiscoverViews("com.myapp"))
-     * ```
-     *
-     * The UI factory *must* provide a new, fresh instance of the UI, so that the
-     * tests start from a pre-known state. If you're using Spring and you're getting UI
-     * from the injector, you must reconfigure Spring to use prototype scope,
-     * otherwise an old UI from the UI scope or Session Scope will be provided.
-     *
-     * Sometimes you wish to provide a specific [VaadinServletService],
-     * e.g. to override
-     * [VaadinServletService.loadInstantiators] and provide your own way of instantiating Views, e.g. via Spring or Guice.
-     * Please do that by extending [MockVaadinServlet] and overriding [MockVaadinServlet.createServletService]
-     * `createServletService(DeploymentConfiguration)`.
-     * Please consult [MockService] on what methods you must override in your custom service.
-     * Alternatively, see `MockSpringServlet` (in the `browserless-test-spring` module) on how to extend your custom servlet and
-     * provide all necessary mocking code.
-     * @param routes all classes annotated with [com.vaadin.flow.router.Route]; use [Routes.autoDiscoverViews] to auto-discover all such classes.
-     * @param uiFactory produces [UI] instances and sets them as current, by default simply instantiates [MockedUI] class.
-     * @param lookupServices service classes to be provided to the lookup initializer
-     * @param configuration custom Vaadin configuration, such as application properties, feature flags
-     * and lookup services, to apply to the mocked environment.
-     */
-    @JvmStatic
-    @JvmOverloads
-    fun setup(routes: Routes = Routes(),
-              uiFactory: UIFactory = UIFactory { MockedUI() },
-              lookupServices: Set<Class<*>> = emptySet(),
-              configuration: BrowserlessConfiguration = BrowserlessConfiguration.empty()) {
-        // init servlet
-        val servlet = MockVaadinServlet(routes)
-        setup(uiFactory, servlet, lookupServices, configuration)
-    }
-
-    /**
-     * Use this method when you need to provide a completely custom servlet (e.g. `SpringServlet`). Do not forget to create a specialized service
-     * which works in mocked environment. See below for details on how to do this.
-     *
-     * The UI factory *must* provide a new, fresh instance of the UI, so that the
-     * tests start from a pre-known state. If you're using Spring and you're getting UI
-     * from the injector, you must reconfigure Spring to use prototype scope,
-     * otherwise an old UI from the UI scope or Session Scope will be provided.
-     * @param uiFactory produces [UI] instances and sets them as current, by default
-     * simply instantiates [MockedUI] class.
-     * @param servlet allows you to provide your own implementation of [VaadinServlet].
-     * You MUST override [VaadinServlet.createServletService]
-     * and construct a custom service which overrides important methods.
-     * Please consult [com.vaadin.browserless.mocks.MockService]
-     * on what methods you must override in your custom service.
-     * @param lookupServices service classes to be provided to the lookup initializer
-     * @param configuration custom Vaadin configuration, such as application properties, feature flags
-     * and lookup services, to apply to the mocked environment.
-     */
-    @JvmStatic
-    @JvmOverloads
-    fun setup(uiFactory: UIFactory = UIFactory { MockedUI() }, servlet: VaadinServlet,
-              lookupServices: Set<Class<*>> = emptySet(),
-              configuration: BrowserlessConfiguration = BrowserlessConfiguration.empty()
-    ) {
-        val service = setupServlet(servlet, lookupServices, configuration)
-        VaadinService.setCurrent(service)
-
-        // init Vaadin Session
-        createSession(servlet.servletContext, uiFactory)
-    }
-
-    /**
-     * Initializes the given [servlet] and its service, but does NOT create a
-     * session, UI, or set any thread-locals. Call this when you need to share
-     * a single service across multiple independent sessions (multi-user testing).
-     *
-     * @param configuration custom Vaadin configuration, such as application properties, feature flags
-     * and lookup services, to apply to the mocked environment. Lookup services defined by the
-     * configuration are used in addition to the ones given by [lookupServices].
-     * @return the initialized [VaadinServletService]
-     */
-    @JvmStatic
-    @JvmOverloads
-    fun setupServlet(servlet: VaadinServlet,
-                     lookupServices: Set<Class<*>> = emptySet(),
-                     configuration: BrowserlessConfiguration = BrowserlessConfiguration.empty()
-    ): VaadinServletService {
-        if (!isInitialized(servlet)) {
-            // Lookup services can be given both explicitly and through the configuration
-            // (e.g. by a @BrowserlessTestConfig annotation); they accumulate.
-            val ctx: ServletContext = MockVaadinHelper.createMockContext(
-                    lookupServices + configuration.lookupServices)
-            // Context init parameters are read by ApplicationConfiguration, which is
-            // created and cached on first access, so they must be set before anything
-            // else touches the context.
-            configuration.applicationProperties.forEach { (name, value) -> ctx.setInitParameter(name, value) }
-            // Installed before the servlet is initialized, so that feature flags read
-            // during startup (e.g. by a VaadinServiceInitListener) already observe the
-            // test configuration. Installed even without overrides, so that tests
-            // toggling feature flags at runtime don't write them into the project
-            // resources folder, from where other tests would then read them.
-            BrowserlessFeatureFlags.install(VaadinServletContext(ctx), configuration.featureFlags)
-            val config = MockServletConfig(ctx)
-            config.servletInitParams.putAll(configuration.applicationProperties)
-            // Enforced by the browserless environment, so it wins over test configuration
-            config.servletInitParams[InitParameters.BROWSERLESS] = "true"
-            servlet.init(config)
-        } else if (!configuration.isEmpty) {
-            // Application properties, feature flags and lookup services are all
-            // read while the servlet is initialized, so there is no way to apply
-            // them afterwards. Failing here beats silently running the test
-            // against an environment that never saw its own configuration.
-            throw BrowserlessTestSetupException(
-                    "Cannot apply a custom Vaadin configuration to ${servlet.javaClass.name}, " +
-                            "because the servlet has already been initialized. The configuration " +
-                            "is read while the servlet initializes, so it must be provided to the " +
-                            "setup creating the servlet. Provide a servlet factory returning a new, " +
-                            "uninitialized servlet instance, or move the configuration to the setup " +
-                            "that initializes it. Discarded configuration: $configuration")
-        }
-        val service: VaadinServletService = checkNotNull(MockVaadinServlet.serviceSafe(servlet))
-        check(service.router != null) { "$servlet failed to call VaadinServletService.init() in createServletService()" }
-        return service
-    }
-
-    /**
-     * Records that [detached] was replaced by [created] during a page reload,
-     * so that [liveUI] can map the old UI to the new one.
-     */
-    @JvmStatic
-    fun recordReloadReplacement(detached: UI, created: UI) {
-        reloadReplacements[detached] = created
-    }
-
-    /**
-     * Follows the reload chain starting at [ui] and returns the UI that is live
-     * now: a reload detaches a UI and creates a fresh one for the same window,
-     * so a caller holding the detached UI must be redirected to its
-     * replacement. Returns [ui] itself if it was never replaced.
-     */
-    @JvmStatic
-    fun liveUI(ui: UI): UI {
-        var live: UI = ui
-        var next: UI? = reloadReplacements[live]
-        while (next != null && next !== live) {
-            live = next
-            next = reloadReplacements[live]
-        }
-        return live
-    }
-
-    /**
-     * Properly closes the current UI and fire the detach event on it.
-     * Does nothing if there is no current UI.
-     */
-    @JvmStatic
-    fun closeCurrentUI(fireUIDetach: Boolean) {
-        val ui: UI = UI.getCurrent() ?: return
-        lastNavigation.set(ui.internals.activeViewLocation)
-        // Preserve the window name so a following createUI (reload / session
-        // recreation) reuses it, keeping @PreserveOnRefresh's cache key stable.
-        lastWindowName.set(ui.internals.extendedClientDetails.windowName)
-        if (ui.isClosing && ui.internals.session != null) {
-            _close(ui)
-        }
-        if (fireUIDetach) {
-            ComponentUtil.onComponentDetach(ui)
-        }
-        UI.setCurrent(null)
-        strongRefUI.remove()
-    }
-
-    /**
-     * Cleans up and removes the Vaadin UI and Vaadin Session. You can call this function in `afterEach{}` block,
-     * to clean up after the test. This comes handy when you want to be extra-sure that the next test won't accidentally reuse old UI,
-     * should you forget to call [setup] properly.
-     *
-     * You don't have to call this function though; [setup] will overwrite any current UI/Session instances with a fresh ones.
-     */
-    @JvmStatic
-    fun tearDown() {
-        clearVaadinInstances(false)
-        val service: VaadinService? = VaadinService.getCurrent()
-        if (service != null) {
-            service.fireServiceDestroyListeners(ServiceDestroyEvent(service))
-            VaadinService.setCurrent(null)
-        }
-        lastNavigation.remove()
-        lastWindowName.remove()
-    }
-
-    private fun clearVaadinInstances(fireUIDetach: Boolean) {
-        closeCurrentUI(fireUIDetach)
-        closeCurrentSession()
-        CurrentInstance.set(VaadinRequest::class.java, null)
-        CurrentInstance.set(VaadinResponse::class.java, null)
-        strongRefReq.remove()
-        strongRefRes.remove()
-    }
-
-    private fun closeCurrentSession() {
-        val session: VaadinSession? = VaadinSession.getCurrent()
-        if (session != null) {
-            fireSessionDestroyAndDrain(session)
-        }
-        strongRefSession.remove()
-    }
-
-    /**
-     * Fires session-destroy listeners on [session] and drains pending
-     * [VaadinSession.access] tasks scheduled during destruction. The
-     * `currentlyClosingSession` flag is set for the duration so the
-     * `afterSessionClose` recreation hook (used by single-user `setup`) is
-     * suppressed — multi-user callers manage their own session lifecycle.
-     */
-    @JvmStatic
-    public fun fireSessionDestroyAndDrain(session: VaadinSession) {
-        val service: VaadinService = session.service
-        service.fireSessionDestroy(session)
-        VaadinSession.setCurrent(null)
-        // service destroys session via session.access(); we need to run that action now.
-        currentlyClosingSession.set(true)
-        try {
-            runUIQueue(session = session)
-        } finally {
-            currentlyClosingSession.set(false)
-        }
-    }
-
-    private val currentlyClosingSession: ThreadLocal<Boolean> = object : ThreadLocal<Boolean>() {
-        override fun initialValue(): Boolean = false
-    }
-
-    /**
-     * Change & call [setup] to set a different browser.
-     *
-     * The default is Firefox 94 on Ubuntu Linux.
-     */
-    var userAgent: String = "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:94.0) Gecko/20100101 Firefox/94.0"
-
-    /**
-     * Creates [MockRequest]; override if you need to return a class that extends [MockRequest]
-     * and modifies its behavior.
-     */
-    var mockRequestFactory: (MockHttpSession) -> MockRequest = { MockRequest(it) }
-
-    /**
-     * Creates a new session, request and response for the given [service],
-     * but does NOT set any thread-locals or create a UI.
-     *
-     * Use this when you need to create multiple independent sessions for
-     * multi-user testing. The caller is responsible for setting thread-locals
-     * (via [VaadinSession.setCurrent], [CurrentInstance], etc.) and for
-     * creating the UI via [createUI].
-     *
-     * @param service the initialized Vaadin service (from [setupServlet])
-     * @return the created session objects
-     */
-    @JvmStatic
-    fun createSessionObjects(service: VaadinServletService): SessionObjects {
-        val httpSession: MockHttpSession = MockHttpSession.create(service.servlet.servletContext)
-
-        // init Vaadin Request
-        val mockRequest = mockRequestFactory(httpSession)
-        mockRequest.headers["User-Agent"] = listOf(userAgent)
-        service.context.getAttribute(Lookup::class.java)
-                .lookup(MockRequestCustomizer::class.java)?.apply(mockRequest)
-        val request = MockVaadinServlet.createVaadinServletRequest(mockRequest, service)
-
-        // init Session.
-        val session: VaadinSession = MockVaadinServlet.createVaadinSession(service, request)
-        httpSession.setAttribute(service.serviceName + ".lock", ReentrantLock().apply { lock() })
-        httpSession.setAttribute(VaadinSession::class.java.name + "." + service.serviceName, session)
-        session.refreshTransients(WrappedHttpSession(httpSession), service)
-        check(session.lockInstance != null) { "$session created from $service has null lock. See the MockSession class on how to mock locks properly" }
-        check((session.lockInstance as ReentrantLock).isLocked) { "$session created from $service: lock must be locked!" }
-
-        session.browser = MockVaadinServlet.createWebBrowser(request)
-        checkNotNull(session.browser.browserApplication) { "The WebBrowser has not been mocked properly" }
-
-        // init Vaadin Response
-        val response = MockVaadinServlet.createVaadinServletResponse(MockResponse(), service)
-
-        return SessionObjects(session, request, response, httpSession)
-    }
-
-    private fun createSession(ctx: ServletContext, uiFactory: UIFactory) {
-        val service: VaadinServletService = checkNotNull(VaadinService.getCurrent()) as VaadinServletService
-        val objs = createSessionObjects(service)
-
-        // install thread-locals
-        strongRefReq.set(objs.request)
-        CurrentInstance.set(VaadinRequest::class.java, objs.request)
-        VaadinSession.setCurrent(objs.session)
-        strongRefSession.set(objs.session)
-        strongRefRes.set(objs.response)
-        CurrentInstance.set(VaadinResponse::class.java, objs.response)
-
-        // fire session init listeners
-        service.fireSessionInitListeners(SessionInitEvent(service, objs.session, objs.request))
-
-        // create UI
-        createUI(uiFactory, objs.session)
-    }
-
-    @JvmStatic
-    fun createUI(uiFactory: UIFactory, session: VaadinSession) {
-        val request: VaadinRequest = checkNotNull(VaadinRequest.getCurrent())
-        val ui: UI = uiFactory()
-        require(ui.session == null) {
-            "uiFactory produced UI $ui which is already attached to a Session, " +
-                    "yet we expect the UI to be a fresh new instance, not yet attached to a Session, so that the tests" +
-                    " are able to always start with a fresh UI with a pre-known state. Perhaps you're " +
-                    "using Spring which reuses a scoped instance of the UI?"
-        }
-
-        // hook into Page.reload() and recreate the UI
-        UI::class.java.getDeclaredField("page").apply {
-            isAccessible = true
-            set(ui, MockPage(ui, uiFactory, session))
-        }
-        ui.internals.session = session
-
-        // Assign a stable, non-null window name via ExtendedClientDetails so
-        // @PreserveOnRefresh works. Flow keys its preserved-component cache on
-        // window.name, and the name must (a) be non-null and (b) stay constant
-        // across reloads of the same window. A reload carries the previous UI's
-        // name in lastWindowName; a brand-new window gets a fresh unique name.
-        // The name is consumed before the UI is initialized, so a failing
-        // initialization cannot leak it into the next createUI on this thread.
-        // Every other detail stays at its placeholder default, exactly as in
-        // the instance Flow would have created lazily: the window name is all
-        // the router reads, so the mock does not fabricate a screen or
-        // viewport geometry it has no way to know.
-        val windowName = lastWindowName.get()
-            ?: "window-${windowNameCounter.incrementAndGet()}"
-        lastWindowName.remove()
-        ui.internals.setExtendedClientDetails(
-            ExtendedClientDetails(ui, null, null, null, null, null, null,
-                null, null, null, null, null, null, null, null, windowName,
-                null, null, null))
-
-        UI.setCurrent(ui)
-        ui.doInit(request, 1, "ROOT")
-        strongRefUI.set(ui)
-
-        session.addUI(ui)
-        session.service.eventBus.fireEvent(UIInitEvent(ui, session.service), rethrowListenerFailure)
-
-        // navigate to the initial page
-        if (lastNavigation.get() != null) {
-            UI.getCurrent().internals.router.navigate(UI.getCurrent(), lastNavigation.get()!!, NavigationTrigger.PROGRAMMATIC)
-            lastNavigation.remove()
-        } else {
-            if (UI.getCurrent().internals.router.registry.getNavigationTarget("").isPresent) {
-                UI.getCurrent().navigate("")
-            }
-        }
-
-        // make sure that UI.getCurrent().push() can be called.
-        // https://github.com/mvysny/karibu-testing/issues/80
-        ui.pushConfiguration.pushMode = PushMode.AUTOMATIC
-    }
-
-    /**
-     * Since Browserless Testing runs in the same JVM as the server and there is no browser, the boundaries between the client and
-     * the server become unclear. When looking into sources of any test method, it's really hard to tell where exactly the server request ends, and
-     * where another request starts.
-     *
-     * You can establish an explicit client boundary in your test, by explicitly calling this method. However, since that
-     * would be both laborous and error-prone, the default operation is that Browserless Testing pretends as if there was a client-server
-     * roundtrip before every component lookup
-     * via the [_get]/[_find]/[_expectNone]/[_expectOne] call. See [TestingLifecycleHook] for more details.
-     *
-     * Calls the following:
-     * * [runUIQueue]
-     * * [StateTree.runExecutionsBeforeClientResponse] which runs all blocks scheduled via [UI.beforeClientResponse]
-     * * [cleanupDialogs]
-     *
-     * If you'd like to test your [ErrorHandler] then take a look at [runUIQueue] instead.
-     * @throws IllegalStateException if the environment is not mocked
-     */
-    @JvmStatic
-    fun clientRoundtrip() {
-        checkNotNull(VaadinSession.getCurrent()) { "No VaadinSession" }
-        runUIQueue()
-        UI.getCurrent().internals.stateTree.runExecutionsBeforeClientResponse()
-        TestingLifecycleHooks.cleanupDialogs()
-    }
-
-    /**
-     * Runs all tasks scheduled by [UI.access].
-     *
-     * If [VaadinSession.errorHandler] is not set or [propagateExceptionToHandler]
-     * is false, any exceptions thrown from [Command]s scheduled via the [UI.access] will make this function fail.
-     * The exceptions will be wrapped in [ExecutionException]. Generally
-     * it's best to keep [propagateExceptionToHandler] set to false to
-     * make any exceptions fail the test; however if you're testing
-     * how your own custom [VaadinSession.errorHandler] responds to exceptions then
-     * set this parameter to true.
-     *
-     * Called automatically by [clientRoundtrip] which is by default called automatically from [TestingLifecycleHook]. You generally
-     * don't need to call this method unless you need to test your [ErrorHandler].
-     *
-     * @param propagateExceptionToHandler defaults to false. If true and [VaadinSession.errorHandler]
-     * is set, any exceptions thrown from [Command]s scheduled via the [UI.access] will be
-     * redirected to [VaadinSession.errorHandler] and will not be re-thrown from this method.
-     * @throws IllegalStateException if the environment is not mocked
-     */
-    @JvmOverloads
-    @JvmStatic
-    public fun runUIQueue(propagateExceptionToHandler: Boolean = false, session: VaadinSession = VaadinSession.getCurrent()) {
-        // we need to set up UI error handler which will be notified for every exception thrown out of the acccess{} block
-        // otherwise the exceptions would simply be logged but unlock() wouldn't fail.
-        val errors: MutableList<Throwable> = mutableListOf<Throwable>()
-        val oldErrorHandler: ErrorHandler? = session.errorHandler
-        if (oldErrorHandler == null || oldErrorHandler is DefaultErrorHandler || !propagateExceptionToHandler) {
-            session.errorHandler = ErrorHandler {
-                var t: Throwable = it.throwable
-                if (t !is ExecutionException) {
-                    // for some weird reason t may not be ExecutionException when it originates from a coroutine :confused:
-                    // the stacktrace would point someplace random. Wrap it in ExecutionException whose stacktrace will point to the test
-                    t = ExecutionException(t.message, t)
-                }
-                errors.add(t)
-            }
-        }
-
-        try {
-            // make sure the lock is held exactly once, otherwise the session.unlock() won't
-            // process all Runnables registered via ui.access()
-            // expect(1) { (session.lockInstance as ReentrantLock).holdCount }
-            val lockCount = (session.lockInstance as ReentrantLock).holdCount
-            if (lockCount != 1) {
-                throw AssertionError("Expected 1 lock, actual $lockCount")
-            }
-
-            session.unlock()  // this will process all Runnables registered via ui.access()
-            // lock the session back, so that the test can continue running as-if in the UI thread.
-            session.lock()
-        } finally {
-            session.errorHandler = oldErrorHandler
-        }
-
-        if (errors.isNotEmpty()) {
-            errors.drop(1).forEach { errors[0].addSuppressed(it) }
-            throw errors[0]
-        }
-    }
-
-    /**
-     * Internal function, do not call directly.
-     *
-     * Only usable when you are providing your own implementation of [VaadinSession].
-     * See [MockVaadinSession] on how to call this properly.
-     */
-    @JvmStatic
-    public fun afterSessionClose(session: VaadinSession, uiFactory: UIFactory) {
-        // We need to simulate the actual browser + servlet container behavior here.
-        // Imagine that we want a test scenario where the user logs out, and we want to check that a login prompt appears.
-
-        // To log out the user, the code typically closes the session and tells the browser to reload
-        // the page (Page.getCurrent().reload() or similar).
-        // Thus the page is reloaded by the browser, and since the session is gone, the servlet container
-        // will create a new, fresh session.
-
-        // That's exactly what we need to do here. We need to close the current UI and eradicate it,
-        // then we need to close the current session and eradicate it, and then we need to create a completely fresh
-        // new UI and Session.
-
-        // A problem appears when the uiFactory accidentally doesn't create a new, fresh instance of UI. Say that
-        // we call Spring injector to provide us an instance of the UI, but we accidentally scoped the UI to Session.
-        // Spring doesn't know that (since we haven't told Spring that the Session scope is gone) and provides
-        // the previous UI instance which is still attached to the session. And it blows.
-
-        if (!currentlyClosingSession.get()) {
-            // Vaadin 20.0.5+: closing session also clears the wrapped VaadinSession.getSession().
-            // Acquire the wrapped session beforehand.
-            val mockSession: MockHttpSession = mock(session)
-            clearVaadinInstances(true)
-            mockSession.destroy()
-            createSession(mockSession.servletContext, uiFactory)
-        }
-    }
-
-    /**
-     * Fires session init listeners on the given service.
-     * Java-friendly static wrapper for the internal extension function.
-     */
-    @JvmStatic
-    fun fireSessionInit(service: VaadinService, session: VaadinSession, request: VaadinRequest) {
-        service.fireSessionInitListeners(SessionInitEvent(service, session, request))
-    }
-
-    /**
-     * Fires service destroy listeners on the given service.
-     * Java-friendly static wrapper for the internal extension function.
-     */
-    @JvmStatic
-    fun fireServiceDestroy(service: VaadinService) {
-        service.fireServiceDestroyListeners(ServiceDestroyEvent(service))
-    }
-
-    /**
-     * Clears the current UI from thread-locals without firing detach events.
-     * Useful for multi-user context where UIs are managed independently.
-     */
-    @JvmStatic
-    fun clearCurrentUI() {
-        UI.setCurrent(null)
-        strongRefUI.remove()
-    }
-
-    /**
-     * Clears the `lastNavigation` ThreadLocal recorded by [closeCurrentUI].
-     *
-     * [closeCurrentUI] records the closing UI's active view location into
-     * `lastNavigation` so that the immediately following [createUI] call (in
-     * the single-user reload / session-recreation flow) can restore that
-     * location on the new UI. Multi-user lifecycle close paths
-     * (`BrowserlessUIContext.close`) call [closeCurrentUI] without a matching
-     * [createUI], so this method must be invoked afterwards to prevent the
-     * recorded location from leaking into the next unrelated [createUI] on the
-     * same thread (e.g. `user.newWindow()`). Also clears the recorded window
-     * name for the same reason: a fresh window must get a new unique name, not
-     * inherit the closed window's name.
-     */
-    @JvmStatic
-    fun clearLastNavigation() {
-        lastNavigation.remove()
-        lastWindowName.remove()
-    }
-}
-
-/**
- * Hands a listener failure back to the caller instead of logging it, which is what
- * [VaadinServiceEventBus.fireEvent] does by default. A listener that throws during a
- * test should fail that test rather than only leave a line in the log.
- */
-private val rethrowListenerFailure =
-        SerializableBiConsumer<EventObject, Exception> { _, error -> throw error }
-
-internal fun VaadinService.fireSessionInitListeners(event: SessionInitEvent) {
-    eventBus.fireEvent(event, rethrowListenerFailure)
-}
-
-internal fun VaadinService.fireServiceDestroyListeners(event: ServiceDestroyEvent) {
-    eventBus.fireEvent(event, rethrowListenerFailure)
-}
-
-internal class MockPage(private val ui: UI, private val uiFactory: UIFactory, private val session: VaadinSession) : Page(ui) {
-
-    private companion object {
-        private val SELF_NAMES = setOf("_self", "_parent", "_top", "")
-    }
-
-    private val navigations: MutableMap<String, MutableList<String>> = mutableMapOf()
-
-    val lastExternalNavigationURL: String?
-        get() = navigations["_self"]?.lastOrNull()
-
-    fun getExternalNavigationURL(windowName: String): String? =
-        navigations[normalizeWindowName(windowName)]?.lastOrNull()
-
-    val openedWindows: Map<String, List<String>>
-        get() = navigations.filterKeys { it != "_self" }
-            .mapValues { (_, urls) -> urls.toList() }
-
-    override fun open(url: String, windowName: String) {
-        val normalized = normalizeWindowName(windowName)
-        if (normalized == "_blank") {
-            navigations.getOrPut(normalized) { mutableListOf() }.add(url)
-        } else {
-            navigations[normalized] = mutableListOf(url)
-        }
-        super.open(url, windowName)
-    }
-
-    override fun reload() {
-        val current: UI? = UI.getCurrent()
-        if (current !== ui) {
-            if (ui.session == null) {
-                // This UI lost its session, so it is the logout idiom -
-                // capture the UI, close its session, then ask its page to
-                // reload. Closing the session already tore this UI down and
-                // rendered a fresh one for its window, which is what the
-                // reload is asking for, so there is nothing left to do. Not
-                // even the superclass call, which would fail: it schedules
-                // JavaScript on a UI whose session is gone.
-                return
-            }
-            // A live UI, but not the current one. Recreating the UI runs on
-            // the thread-locals of the current UI, so going on would detach
-            // and recreate whichever window is current. Fail before anything
-            // is changed.
-            throw IllegalStateException(
-                "Cannot reload the page of UI $ui, because the current UI is " +
-                        (current?.let { "$it" } ?: "not set") +
-                        ". Reloading recreates the current UI, so the " +
-                        "reloaded window must be the current one. Either this " +
-                        "UI belongs to another window - activate it first, " +
-                        "e.g. through its BrowserlessUIContext or " +
-                        "UI.access() - or an earlier reload already replaced " +
-                        "it, in which case reload the current UI instead.")
-        }
-
-        // recreate the UI on reload(), to simulate browser's F5
-        super.reload()
-        MockVaadin.closeCurrentUI(true)
-        MockVaadin.createUI(uiFactory, session)
-        // Record the swap so holders of the detached UI (BrowserlessUIContext)
-        // can follow the window to the new UI. This path is also taken when
-        // application code calls Page.reload() itself, not only from the
-        // reload() DSL.
-        val created: UI? = UI.getCurrent()
-        if (created != null && created !== ui) {
-            MockVaadin.recordReloadReplacement(ui, created)
-        }
-    }
-
-    private fun normalizeWindowName(windowName: String?): String =
-        if (windowName == null || windowName in SELF_NAMES) "_self" else windowName
-}
-
-fun interface MockRequestCustomizer {
-    fun apply(request: MockRequest)
-}
-
-fun interface UIFactory : () -> UI, Serializable
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
index a2797545..363e8644 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
@@ -22,7 +22,6 @@
 import java.security.Principal;
 import java.util.function.UnaryOperator;
 
-import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.ApplicationContext;
@@ -35,7 +34,6 @@
 import com.vaadin.browserless.internal.Routes;
 import com.vaadin.browserless.internal.UIFactory;
 import com.vaadin.browserless.internal.Utils;
-import com.vaadin.flow.component.UI;
 import com.vaadin.flow.function.DeploymentConfiguration;
 import com.vaadin.flow.server.ServiceException;
 import com.vaadin.flow.server.VaadinServletRequest;
@@ -62,15 +60,6 @@ public class MockSpringServlet extends SpringServlet {
     @NotNull
     public final UIFactory uiFactory;
 
-    @Deprecated(forRemoval = true)
-    public MockSpringServlet(@NotNull Routes routes,
-            @NotNull ApplicationContext ctx, @NotNull Function0<UI> uiFactory) {
-        super(ctx, false);
-        this.ctx = ctx;
-        this.routes = routes;
-        this.uiFactory = uiFactory::invoke;
-    }
-
     public MockSpringServlet(@NotNull Routes routes,
 
             @NotNull ApplicationContext ctx, @NotNull UIFactory uiFactory) {
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
index 3a5f854c..ffb95164 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
@@ -15,12 +15,10 @@
  */
 package com.vaadin.browserless.mocks;
 
-import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.context.ApplicationContext;
 
 import com.vaadin.browserless.internal.UIFactory;
-import com.vaadin.flow.component.UI;
 import com.vaadin.flow.function.DeploymentConfiguration;
 import com.vaadin.flow.server.VaadinRequest;
 import com.vaadin.flow.server.VaadinSession;
@@ -48,14 +46,6 @@ public class MockSpringServletService extends SpringVaadinServletService {
     @NotNull
     private final UIFactory uiFactory;
 
-    @Deprecated(forRemoval = true)
-    public MockSpringServletService(@NotNull MockSpringServlet servlet,
-            @NotNull DeploymentConfiguration deploymentConfiguration,
-            @NotNull ApplicationContext ctx, @NotNull Function0<UI> uiFactory) {
-        super(servlet, deploymentConfiguration, ctx);
-        this.uiFactory = uiFactory::invoke;
-    }
-
     public MockSpringServletService(@NotNull MockSpringServlet servlet,
             @NotNull DeploymentConfiguration deploymentConfiguration,
             @NotNull ApplicationContext ctx, @NotNull UIFactory uiFactory) {
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
index a1695496..1e5cd0d3 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
@@ -15,12 +15,10 @@
  */
 package com.vaadin.browserless.mocks;
 
-import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 
 import com.vaadin.browserless.internal.MockVaadin;
 import com.vaadin.browserless.internal.UIFactory;
-import com.vaadin.flow.component.UI;
 import com.vaadin.flow.server.VaadinService;
 import com.vaadin.flow.server.VaadinSession;
 
@@ -45,13 +43,6 @@ public class MockSpringVaadinSession extends VaadinSession {
     @NotNull
     private final UIFactory uiFactory;
 
-    @Deprecated(forRemoval = true)
-    public MockSpringVaadinSession(@NotNull VaadinService service,
-            @NotNull Function0<UI> uiFactory) {
-        super(service);
-        this.uiFactory = uiFactory::invoke;
-    }
-
     public MockSpringVaadinSession(@NotNull VaadinService service,
             @NotNull UIFactory uiFactory) {
         super(service);

From 7c67121a7c9f4b84315b071493f1f53461b71449 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 13:08:18 +0000
Subject: [PATCH 06/13] refactor!: port Grid from Kotlin to Java and drop
 kotlin-stdlib

Final phase of removing Kotlin from `shared`. `shared/src/main` is now pure
Java, `kotlin-stdlib` leaves its compile classpath, and consumers of
`browserless-test-shared` pull no Kotlin runtime. See `de-kotlin-plan.md`.

`Grid.kt` becomes `GridUtils` rather than `Grid`: a utility class of statics is
not a `Grid`, and the old name shadowed
`com.vaadin.flow.component.grid.Grid`, which forced 59 fully qualified
references inside the file and 8 more in `GridTester`. The name follows the
`BasicUtils` and `ComponentUtils` precedent.

The `org.jetbrains.annotations` imports move to JSpecify, which Vaadin already
provides, since those annotations arrived transitively with `kotlin-stdlib`.

Dokka is replaced by `maven-javadoc-plugin`. Dokka validated nothing, so
doclint now sees these sources for the first time and reports roughly 200
issues across 53 files, nearly all in testers untouched by this work. The
module sets `doclint` to `none` so the port does not become a Javadoc cleanup;
that cleanup is worth its own change. The other modules keep doclint on.

Breaking changes:

* `GridKt` is gone; its functions are statics on `GridUtils`.
* `_rowSequence` returns a `Stream` in place of a Kotlin `Sequence`, still
  lazily, so `TreeGrid._size()` keeps counting without fetching every row.
* `_dump(Grid, IntRange)` becomes `_dump(Grid, int from, int to)`.
* The `KProperty1` overloads of `HeaderRow.getCell` and `FooterRow.getCell`
  are dropped; the `getCell(String)` overloads remain.
* The intermediate `_clickItem` and `_doubleClickItem` arities the Kotlin
  default arguments generated are gone; the two-argument and the
  full-argument forms remain.
* Property accessors lose their `get` prefix along with the class rename, so
  `get_internalId` becomes `_internalId` and `getDataProvider` becomes
  `dataProvider`.
---
 CLAUDE.md                                     |    4 +-
 CONVENTIONS.md                                |    5 +-
 de-kotlin-plan.md                             |   20 +-
 guidelines/architecture.md                    |    2 +-
 guidelines/repository.md                      |   11 +-
 .../quarkus/mocks/MockQuarkusServlet.java     |    4 +-
 shared/pom.xml                                |   50 +-
 .../browserless/component/GridUtils.java      | 1402 +++++++++++++++++
 .../internal/GridContextMenuSupport.java      |    4 +-
 .../component/accordion/AccordionTester.java  |    2 +-
 .../component/avatar/AvatarGroupTester.java   |    2 +-
 .../flow/component/card/CardTester.java       |    2 +-
 .../checkbox/CheckboxGroupTester.java         |    4 +-
 .../flow/component/grid/GridTester.java       |   18 +-
 .../contextmenu/GridContextMenuTester.java    |    4 +-
 .../MasterDetailLayoutTester.java             |    2 +-
 .../radiobutton/RadioButtonGroupTester.java   |    4 +-
 .../splitlayout/SplitLayoutTester.java        |    2 +-
 .../com/vaadin/browserless/component/Grid.kt  |  899 -----------
 .../browserless/component/GridSupport.kt      |   32 -
 .../browserless/mocks/MockSpringServlet.java  |   12 +-
 .../mocks/MockSpringServletService.java       |   10 +-
 .../mocks/MockSpringVaadinSession.java        |    8 +-
 23 files changed, 1491 insertions(+), 1012 deletions(-)
 create mode 100644 shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
 delete mode 100644 shared/src/main/kotlin/com/vaadin/browserless/component/GridSupport.kt

diff --git a/CLAUDE.md b/CLAUDE.md
index 67522f20..493f3b7d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -17,7 +17,7 @@ each Vaadin component in a *tester* that drives it the way a browser would.
 
 - Java 21+, Maven (multi-module)
 - Vaadin 25 / Flow — a `provided` dependency, one fixed version per branch
-- Kotlin for the older mock and internal layer in `shared/src/main/kotlin`
+- Kotlin only in the test sources; the main sources are pure Java
 - JUnit 6 (Jupiter) for the test API and for this repository's own tests
 - An annotation processor (`locator-processor`) that generates the typed
   locator API at build time
@@ -84,7 +84,7 @@ mvn test -pl junit6 -Dtest=BasicGridTesterTest#basicGrid_selectionOnClick
 # Run the tests matching a pattern
 mvn test -pl junit6 -Dtest="*ComboBox*Test"
 
-# Generate the Javadoc/Dokka artifacts the way CI does
+# Generate the Javadoc artifacts the way CI does
 mvn clean install -DskipTests -Djavadocs
 ```
 
diff --git a/CONVENTIONS.md b/CONVENTIONS.md
index 4f03c060..890daf50 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -108,9 +108,8 @@ Go through the Vaadin extension points rather than around them — fire service
 and session lifecycle events through the `VaadinService` event bus, and forward
 `Instantiator` calls to the real instantiator instead of reimplementing them.
 
-New code in `shared` is written in Java. The Kotlin sources under
-`shared/src/main/kotlin` are the older internal layer and are being ported to
-Java; do not add new Kotlin files there.
+`shared` is written in Java. Kotlin survives only in the test sources; do not
+add new Kotlin files.
 
 See [`guidelines/architecture.md`](guidelines/architecture.md).
 
diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index ad0460ea..ebfaeb39 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -176,7 +176,12 @@ that field postdates the prior port — it would have broken the public
 logout-idiom early return, the wrong-UI guard and the
 `recordReloadReplacement(…)` call, which six reload tests caught.
 
-### Phase 5 — `Grid.kt` and the kotlin-stdlib drop
+### Phase 5 — `Grid.kt` and the kotlin-stdlib drop — done
+
+On `refactor/no-kotlin-grid`. All five suites match the `main` baseline:
+shared 42, junit6 1406, junit6-cdi-tests 4, spring 41, quarkus 31.
+`shared/src/main` is now 100% Java and `kotlin-stdlib` is off its compile
+classpath, so downstream consumers pull no Kotlin runtime.
 
 - `Sequence<T>` returns (`_rowSequence`) become `Stream<T>` built over
   `DepthFirstTreeIterator` + `Spliterator`. Laziness matters: `TreeGrid._size()`
@@ -185,6 +190,19 @@ logout-idiom early return, the wrong-UI guard and the
   no callers — drop them; the `getCell(String)` overloads stay.
 - Delete `shared/src/main/kotlin`, move `kotlin-stdlib` to test scope, replace
   Dokka with `maven-javadoc-plugin`.
+- `_dump(Grid, IntRange)` becomes `_dump(Grid, int from, int to)`. A row range
+  is not a count, so it needs no `CountRange`.
+- The `org.jetbrains.annotations` imports move to JSpecify, which Vaadin already
+  puts on the classpath at `provided` scope — no new dependency.
+
+**Replacing Dokka turns Javadoc validation on for the first time.** Dokka
+validated nothing, so `maven-javadoc-plugin` immediately fails `shared` on about
+200 doclint issues across 53 files — mostly `self` errors from `<p/>`, missing
+`@param` on type variables, and unresolvable `@link` targets, nearly all in
+testers untouched by the port. `shared` therefore sets `<doclint>none</doclint>`
+so the port does not turn into a module-wide Javadoc cleanup. That cleanup is
+worth doing on its own, tightening the setting back a step at a time; the other
+modules already run with doclint on.
 
 ### Phase 6 — test-side Kotlin (separate decision)
 
diff --git a/guidelines/architecture.md b/guidelines/architecture.md
index fc0c7b7c..94d5931b 100644
--- a/guidelines/architecture.md
+++ b/guidelines/architecture.md
@@ -76,7 +76,7 @@ found too — a Dialog's content, a Grid's header, footer and editor components,
 a Card's slots.
 
 `ElementConditions` holds the element-level predicates the query builds on.
-`Locator` (the internal Kotlin one, not the public locator API) and
+`Locator` (the internal one, not the public locator API) and
 `DepthFirstTreeIterator` do the walking; `PrettyPrintTree` renders the tree for
 `TreeOnFailureExtension`.
 
diff --git a/guidelines/repository.md b/guidelines/repository.md
index 2a076b20..ab9ad19b 100644
--- a/guidelines/repository.md
+++ b/guidelines/repository.md
@@ -5,15 +5,14 @@
 - **Java 21+**, **Maven** (multi-module, parent `com.vaadin:vaadin-parent`).
 - **Vaadin 25 / Flow** as a `provided` dependency, one fixed version per
   branch — see [Flow Version](flow-version.md).
-- **Kotlin** for the older internal layer in `shared/src/main/kotlin`.
-  New code is Java; the Kotlin is being ported over time. The `mocks` package
-  has already been ported — see [`de-kotlin-plan.md`](../de-kotlin-plan.md).
+- **Kotlin** only in the test sources (`shared/src/test/kotlin`,
+  `junit6/src/test/kotlin`). The main sources are pure Java — see
+  [`de-kotlin-plan.md`](../de-kotlin-plan.md).
 - **JUnit 6 (Jupiter)** for the published test API and for this repository's
   own tests. A few legacy Kotlin tests still use DynaTest and Karibu DSL.
 - **ClassGraph** for classpath scanning (routes, testers).
 - **Spotless** with the Eclipse formatter for style; no checkstyle.
-- **Dokka** for Javadoc in the mixed Java/Kotlin modules, `maven-javadoc-plugin`
-  elsewhere.
+- **maven-javadoc-plugin** for Javadoc in every module.
 
 ## Module structure
 
@@ -48,7 +47,7 @@ modules that declare testers.
 - **The mocks** live in `com.vaadin.browserless.mocks` (Java):
   `MockService`, `MockVaadinServlet`, `MockRequest`, `MockResponse`,
   `MockHttpSession`, `MockedUI`.
-- **Internal helpers** live in `com.vaadin.browserless.internal` (Kotlin):
+- **Internal helpers** live in `com.vaadin.browserless.internal` (Java):
   `MockVaadin`, `Routes`, `Locator`, `PrettyPrintTree`, `Shortcuts`.
 - **Tests** live in `junit6/src/test/java`, mirroring the package of the code
   they cover. See [Testing](testing.md).
diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java
index 52db1da3..44b6aa03 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/mocks/MockQuarkusServlet.java
@@ -20,7 +20,7 @@
 
 import java.lang.reflect.Field;
 
-import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 
 import com.vaadin.browserless.internal.Routes;
 import com.vaadin.browserless.internal.UIFactory;
@@ -67,7 +67,7 @@ public class MockQuarkusServlet extends QuarkusVaadinServlet {
      *            the factory used to build Flow UIs.
      */
     public MockQuarkusServlet(Routes routes, BeanManager beanManager,
-            @NotNull UIFactory uiFactory) {
+            @NonNull UIFactory uiFactory) {
         this.routes = routes;
         this.uiFactory = uiFactory;
         this.beanManager = beanManager;
diff --git a/shared/pom.xml b/shared/pom.xml
index cb432d2b..df46c208 100644
--- a/shared/pom.xml
+++ b/shared/pom.xml
@@ -24,18 +24,6 @@
                 <groupId>org.jetbrains.kotlin</groupId>
                 <artifactId>kotlin-maven-plugin</artifactId>
                 <executions>
-                    <execution>
-                        <id>compile</id>
-                        <goals>
-                            <goal>compile</goal>
-                        </goals>
-                        <configuration>
-                            <sourceDirs>
-                                <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
-                                <sourceDir>${project.basedir}/src/main/java</sourceDir>
-                            </sourceDirs>
-                        </configuration>
-                    </execution>
                     <execution>
                         <id>test-compile</id>
                         <goals>
@@ -89,29 +77,30 @@
                     </execution>
                 </executions>
             </plugin>
-            <!-- Mixed Java/Kotlin module: Javadocs are generated by Dokka.
-                 Configuration and the javadocJar execution are inherited from
-                 the root pluginManagement and gated by maven.javadoc.skip. -->
+            <!-- Pure-Java main sources: Javadocs are generated by
+                 maven-javadoc-plugin. The attach-javadocs execution is
+                 inherited from the root pluginManagement and gated by
+                 maven.javadoc.skip. -->
             <plugin>
-                <groupId>org.jetbrains.dokka</groupId>
-                <artifactId>dokka-maven-plugin</artifactId>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <configuration>
+                    <!-- Dokka generated this module's Javadocs until the Kotlin
+                         sources were ported away, and it validated nothing, so
+                         doclint is seeing these sources for the first time: it
+                         reports roughly 200 issues across 53 files, nearly all
+                         of them in testers untouched by the port. Disabled here
+                         to keep the port from turning into a module-wide
+                         Javadoc cleanup; that cleanup is worth doing on its
+                         own, tightening this back to the default a step at a
+                         time. The other modules run with doclint on. -->
+                    <doclint>none</doclint>
+                </configuration>
             </plugin>
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>build-helper-maven-plugin</artifactId>
                 <executions>
-                    <execution>
-                        <id>add-kotlin-sources-for-source-jar</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>add-source</goal>
-                        </goals>
-                        <configuration>
-                            <sources>
-                                <source>src/main/kotlin</source>
-                            </sources>
-                        </configuration>
-                    </execution>
                     <execution>
                         <id>add-generated-locator-sources</id>
                         <phase>generate-sources</phase>
@@ -170,10 +159,13 @@
             <scope>test</scope>
         </dependency>
 
+        <!-- Only shared/src/test/kotlin needs Kotlin; the main sources are
+             pure Java, so consumers pull no Kotlin runtime. -->
         <dependency>
             <groupId>org.jetbrains.kotlin</groupId>
             <artifactId>kotlin-stdlib</artifactId>
             <version>${kotlin.version}</version>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>io.github.classgraph</groupId>
diff --git a/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java b/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
new file mode 100644
index 00000000..8e0d0604
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
@@ -0,0 +1,1402 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.component;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import com.vaadin.browserless.internal.BasicUtils;
+import com.vaadin.browserless.internal.DepthFirstTreeIterator;
+import com.vaadin.browserless.internal.MockVaadin;
+import com.vaadin.browserless.internal.PrettyPrintTree;
+import com.vaadin.browserless.internal.Renderers;
+import com.vaadin.browserless.internal.Utils;
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.checkbox.CheckboxGroup;
+import com.vaadin.flow.component.combobox.ComboBox;
+import com.vaadin.flow.component.grid.AbstractGridMultiSelectionModel;
+import com.vaadin.flow.component.grid.ColumnPathRenderer;
+import com.vaadin.flow.component.grid.FooterRow;
+import com.vaadin.flow.component.grid.Grid;
+import com.vaadin.flow.component.grid.GridMultiSelectionModel;
+import com.vaadin.flow.component.grid.GridNoneSelectionModel;
+import com.vaadin.flow.component.grid.GridSelectionModel;
+import com.vaadin.flow.component.grid.GridSingleSelectionModel;
+import com.vaadin.flow.component.grid.GridSortOrder;
+import com.vaadin.flow.component.grid.HeaderRow;
+import com.vaadin.flow.component.grid.ItemClickEvent;
+import com.vaadin.flow.component.grid.ItemDoubleClickEvent;
+import com.vaadin.flow.component.grid.editor.Editor;
+import com.vaadin.flow.component.listbox.ListBoxBase;
+import com.vaadin.flow.component.radiobutton.RadioButtonGroup;
+import com.vaadin.flow.component.select.Select;
+import com.vaadin.flow.component.treegrid.TreeGrid;
+import com.vaadin.flow.data.provider.DataCommunicator;
+import com.vaadin.flow.data.provider.DataProvider;
+import com.vaadin.flow.data.provider.Query;
+import com.vaadin.flow.data.provider.QuerySortOrder;
+import com.vaadin.flow.data.provider.SortDirection;
+import com.vaadin.flow.data.provider.hierarchy.HierarchicalDataProvider;
+import com.vaadin.flow.data.provider.hierarchy.HierarchicalQuery;
+import com.vaadin.flow.data.renderer.ComponentRenderer;
+import com.vaadin.flow.data.renderer.NativeButtonRenderer;
+import com.vaadin.flow.data.renderer.Renderer;
+import com.vaadin.flow.function.SerializablePredicate;
+import com.vaadin.flow.function.ValueProvider;
+
+/**
+ * Helpers for reading and driving a {@link Grid} the way a user would.
+ * <p>
+ * A grid renders its rows on the client, so the rows a test wants to assert on
+ * do not exist as server-side objects until something asks the data provider
+ * for them. These helpers do that asking: {@link #_get(Grid, int)} and
+ * {@link #_findAll(Grid)} fetch items, {@link #_getFormattedRow(Grid, int)} and
+ * {@link #_dump(Grid)} render what a cell actually shows, and
+ * {@link #_clickItem(Grid, int)} and the selection helpers fire the events a
+ * click or a checkbox would.
+ * <p>
+ * Most of this is reachable through {@code GridTester}, which is the friendlier
+ * entry point; these statics are what it delegates to.
+ */
+public final class GridUtils {
+
+    private GridUtils() {
+    }
+
+    // ---------------------------------------------------------------------
+    // Reflection lookups (cached)
+    // ---------------------------------------------------------------------
+
+    private static final Method _DataCommunicator_isDefinedSize;
+    private static final Method _DataCommunicator_fetchFromProvider;
+    private static final Method _DataCommunicator_setPagingEnabled;
+    private static final Method _DataCommunicator_getDataProviderSize;
+    private static final Method _AbstractCell_getColumn;
+    private static final Method _AbstractColumn_getBottomLevelColumn;
+    private static final Method _Column_getInternalId;
+    private static final Field _ColumnPathRenderer_provider;
+    private static final Class<?> _AbstractColumn_class;
+
+    private static final Method _ListBoxBase_getDataProvider;
+    private static final Method _CheckboxGroup_getDataProvider;
+    private static final Method _RadioButtonGroup_getDataProvider;
+
+    static {
+        try {
+            _DataCommunicator_isDefinedSize = DataCommunicator.class
+                    .getDeclaredMethod("isDefinedSize");
+
+            _DataCommunicator_fetchFromProvider = DataCommunicator.class
+                    .getDeclaredMethod("fetchFromProvider", int.class,
+                            int.class);
+            _DataCommunicator_fetchFromProvider.setAccessible(true);
+
+            Method setPagingEnabled = null;
+            for (Method m : DataCommunicator.class.getDeclaredMethods()) {
+                if (m.getName().equals("setPagingEnabled")) {
+                    setPagingEnabled = m;
+                    break;
+                }
+            }
+            _DataCommunicator_setPagingEnabled = setPagingEnabled;
+
+            _DataCommunicator_getDataProviderSize = DataCommunicator.class
+                    .getDeclaredMethod("getDataProviderSize");
+            _DataCommunicator_getDataProviderSize.setAccessible(true);
+
+            Class<?> abstractCellClass = Utils.findClassOrThrow(
+                    "com.vaadin.flow.component.grid.AbstractRow$AbstractCell");
+            _AbstractCell_getColumn = abstractCellClass
+                    .getDeclaredMethod("getColumn");
+            _AbstractCell_getColumn.setAccessible(true);
+
+            _AbstractColumn_class = Utils.findClassOrThrow(
+                    "com.vaadin.flow.component.grid.AbstractColumn");
+            _AbstractColumn_getBottomLevelColumn = _AbstractColumn_class
+                    .getDeclaredMethod("getBottomLevelColumn");
+            _AbstractColumn_getBottomLevelColumn.setAccessible(true);
+
+            _Column_getInternalId = Grid.Column.class
+                    .getDeclaredMethod("getInternalId");
+            _Column_getInternalId.setAccessible(true);
+
+            _ColumnPathRenderer_provider = Utils
+                    .findClassOrThrow(
+                            "com.vaadin.flow.component.grid.ColumnPathRenderer")
+                    .getDeclaredField("provider");
+            _ColumnPathRenderer_provider.setAccessible(true);
+
+            _ListBoxBase_getDataProvider = ListBoxBase.class
+                    .getDeclaredMethod("getDataProvider");
+            _ListBoxBase_getDataProvider.setAccessible(true);
+            _CheckboxGroup_getDataProvider = CheckboxGroup.class
+                    .getDeclaredMethod("getDataProvider");
+            _CheckboxGroup_getDataProvider.setAccessible(true);
+            _RadioButtonGroup_getDataProvider = RadioButtonGroup.class
+                    .getDeclaredMethod("getDataProvider");
+            _RadioButtonGroup_getDataProvider.setAccessible(true);
+        } catch (NoSuchMethodException | NoSuchFieldException
+                | ClassNotFoundException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    // ---------------------------------------------------------------------
+    // DataProvider helpers
+    // ---------------------------------------------------------------------
+
+    /**
+     * Returns the item on given row. Fails if the row index is invalid. The
+     * data provider is sorted according to given [sortOrders] (empty by
+     * default) and filtered according to given [filter] (null by default)
+     * first.
+     *
+     * @param rowIndex
+     *            the row, 0..size - 1
+     * @return the item at given row.
+     * @throws AssertionError
+     *             if the row index is out of bounds.
+     */
+    public static <T, F> T _get(DataProvider<T, F> provider, int rowIndex,
+            List<QuerySortOrder> sortOrders, Comparator<T> inMemorySorting,
+            F filter) {
+        if (rowIndex < 0) {
+            throw new IllegalArgumentException(
+                    "rowIndex must be 0 or greater: " + rowIndex);
+        }
+        Stream<T> fetched = provider.fetch(
+                new Query<>(rowIndex, 1, sortOrders, inMemorySorting, filter));
+        List<T> list = fetched.collect(Collectors.toList());
+        if (list.isEmpty()) {
+            throw new AssertionError("Requested to get row " + rowIndex
+                    + " but the data provider only has "
+                    + _size(provider, filter) + " rows matching filter "
+                    + filter);
+        }
+        return list.get(0);
+    }
+
+    public static <T, F> T _get(DataProvider<T, F> provider, int rowIndex) {
+        return _get(provider, rowIndex, Collections.emptyList(), null, null);
+    }
+
+    /**
+     * Returns all items in given data provider, sorted according to given
+     * [sortOrders] (empty by default) and filtered according to given [filter]
+     * (null by default).
+     *
+     * @return the list of items.
+     */
+    public static <T, F> List<T> _findAll(DataProvider<T, F> provider,
+            List<QuerySortOrder> sortOrders, Comparator<T> inMemorySorting,
+            F filter) {
+        Stream<T> fetched = provider.fetch(new Query<>(0, Integer.MAX_VALUE,
+                sortOrders, inMemorySorting, filter));
+        return fetched.collect(Collectors.toList());
+    }
+
+    public static <T, F> List<T> _findAll(DataProvider<T, F> provider) {
+        return _findAll(provider, Collections.emptyList(), null, null);
+    }
+
+    /**
+     * Returns the item on given row. Fails if the row index is invalid. Uses
+     * current Grid sorting.
+     *
+     * For [TreeGrid] this returns the x-th displayed row; skips children of
+     * collapsed nodes. Uses [_rowSequence].
+     *
+     * WARNING: Very slow operation for [TreeGrid].
+     *
+     * @param rowIndex
+     *            the row, 0..size - 1
+     * @return the item at given row, not null.
+     */
+    public static <T> T _get(Grid<T> grid, int rowIndex) {
+        if (rowIndex < 0) {
+            throw new IllegalArgumentException(
+                    "rowIndex must be 0 or greater: " + rowIndex);
+        }
+        if (!(grid instanceof TreeGrid) && _dataProviderSupportsSizeOp(grid)) {
+            // only perform this check for regular Grid. TreeGrid._fetch()'s
+            // Sequence consults size() internally.
+            int size = _size(grid);
+            if (rowIndex >= size) {
+                throw new AssertionError("Requested to get row " + rowIndex
+                        + " but the data provider only has " + size + " rows\n"
+                        + _dump(grid));
+            }
+        }
+        T result = _getOrNull(grid, rowIndex);
+        if (result == null) {
+            throw new AssertionError("Requested to get row " + rowIndex
+                    + " but the data provider returned 0 rows\n" + _dump(grid));
+        }
+        return result;
+    }
+
+    /**
+     * Returns the item on given row, or null if the [rowIndex] is larger than
+     * the number of items the data provider can provide. Uses current Grid
+     * sorting.
+     *
+     * For [TreeGrid] this returns the x-th displayed row; skips children of
+     * collapsed nodes. Uses [_rowSequence].
+     *
+     * WARNING: Very slow operation for [TreeGrid].
+     *
+     * @param rowIndex
+     *            the row, 0 or larger.
+     * @return the item at given row or null if the data provider provides less
+     *         rows.
+     */
+    public static <T> T _getOrNull(Grid<T> grid, int rowIndex) {
+        if (rowIndex < 0) {
+            throw new IllegalArgumentException(
+                    "rowIndex must be 0 or greater: " + rowIndex);
+        }
+        if (!(grid instanceof TreeGrid) && _dataProviderSupportsSizeOp(grid)) {
+            // only perform this check for regular Grid. TreeGrid._fetch()'s
+            // Sequence consults size() internally.
+            int size = _size(grid);
+            if (rowIndex >= size) {
+                return null;
+            }
+        }
+        List<T> fetched = _fetch(grid, rowIndex, 1);
+        return fetched.isEmpty() ? null : fetched.get(0);
+    }
+
+    /**
+     * Vaadin 19+ Grids support setting data providers which do not support
+     * retrieving the number of available rows. See `FetchCallback` for more
+     * details.
+     *
+     * @return true if the current data provider supports [_size] retrieval,
+     *         false if not. Returns true for Vaadin 14.
+     */
+    public static boolean _dataProviderSupportsSizeOp(Grid<?> grid) {
+        try {
+            return (Boolean) _DataCommunicator_isDefinedSize
+                    .invoke(grid.getDataCommunicator());
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Returns items in given range from Grid's data provider. Uses current Grid
+     * sorting.
+     *
+     * For [TreeGrid] this walks the [_rowSequence].
+     *
+     * The Grid never sets any filters into the data provider, however any
+     * ConfigurableFilterDataProvider will automatically apply its filters.
+     *
+     * WARNING: Very slow operation for [TreeGrid].
+     */
+    public static <T> List<T> _fetch(Grid<T> grid, int offset, int limit) {
+        if (grid instanceof TreeGrid) {
+            @SuppressWarnings("unchecked")
+            TreeGrid<T> treeGrid = (TreeGrid<T>) grid;
+            return _rowSequence(treeGrid).skip(offset).limit(limit)
+                    .collect(Collectors.toList());
+        }
+        return fetch(grid.getDataCommunicator(), offset, limit);
+    }
+
+    /**
+     * Returns items in given range from this data communicator. Uses current
+     * Grid sorting. Any ConfigurableFilterDataProvider will automatically apply
+     * its filters.
+     *
+     * This is an internal stuff, most probably you wish to call [_fetch].
+     */
+    public static <T> List<T> fetch(DataCommunicator<T> dc, int offset,
+            int limit) {
+        if (limit > BasicUtils._saneFetchLimit()) {
+            throw new IllegalArgumentException(
+                    "Vaadin doesn't handle fetching of many items very well unfortunately. The sane limit is "
+                            + BasicUtils._saneFetchLimit()
+                            + " but you asked for " + limit);
+        }
+        try {
+            // make sure the DataCommunicator is not in paged mode:
+            // https://github.com/mvysny/karibu-testing/issues/99
+            if (_DataCommunicator_setPagingEnabled != null) {
+                _DataCommunicator_setPagingEnabled.invoke(dc, false);
+            }
+            @SuppressWarnings("unchecked")
+            Stream<T> fetched = (Stream<T>) _DataCommunicator_fetchFromProvider
+                    .invoke(dc, offset, limit);
+            return fetched.collect(Collectors.toList());
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Returns all items from this data communicator. Uses current Grid sorting.
+     * Any ConfigurableFilterDataProvider will automatically apply its filters.
+     *
+     * This is an internal stuff, most probably you wish to call [_fetch].
+     */
+    public static <T> List<T> fetchAll(DataCommunicator<T> dc) {
+        return fetch(dc, 0, BasicUtils._saneFetchLimit());
+    }
+
+    /**
+     * Returns all items in given data provider. Uses current Grid sorting.
+     *
+     * For [TreeGrid] this returns all displayed rows; skips children of
+     * collapsed nodes.
+     *
+     * The Grid never sets any filters into the data provider, however any
+     * ConfigurableFilterDataProvider will automatically apply its filters.
+     *
+     * @return the list of items.
+     */
+    public static <T> List<T> _findAll(Grid<T> grid) {
+        return _fetch(grid, 0, BasicUtils._saneFetchLimit());
+    }
+
+    /**
+     * Returns the number of items in this data provider.
+     *
+     * In case of [HierarchicalDataProvider] this returns the number of ALL
+     * items including all leafs.
+     */
+    public static <T, F> int _size(DataProvider<T, F> provider, F filter) {
+        if (provider instanceof HierarchicalDataProvider) {
+            @SuppressWarnings("unchecked")
+            HierarchicalDataProvider<T, F> hp = (HierarchicalDataProvider<T, F>) provider;
+            return _size(hp, null, filter);
+        }
+        return provider.size(new Query<>(filter));
+    }
+
+    public static <T, F> int _size(DataProvider<T, F> provider) {
+        return _size(provider, null);
+    }
+
+    /**
+     * Returns the number of items in this data provider, including child items.
+     * The function traverses recursively until all children are found; then a
+     * total size is returned. The function uses [HierarchicalDataProvider.size]
+     * mostly, but also uses [HierarchicalDataProvider.fetchChildren] to
+     * discover children. Only children matching [filter] are considered for
+     * recursive computation of the size.
+     *
+     * Note that this can differ to `Grid._size()` since `Grid._size()` ignores
+     * children of collapsed tree nodes.
+     *
+     * @param root
+     *            start with this item; defaults to null to iterate all items
+     * @param filter
+     *            filter to pass to [HierarchicalQuery]
+     */
+    public static <T, F> int _size(HierarchicalDataProvider<T, F> provider,
+            T root, F filter) {
+        return (int) _rowSequence(provider, root, item -> true, filter).count();
+    }
+
+    public static <T, F> int _size(HierarchicalDataProvider<T, F> provider) {
+        return _size(provider, null, null);
+    }
+
+    public static <T, F> int _size(HierarchicalDataProvider<T, F> provider,
+            T root) {
+        return _size(provider, root, null);
+    }
+
+    /**
+     * Returns the number of items in this Grid.
+     *
+     * For [TreeGrid] this computes the number of items the [TreeGrid] is
+     * actually showing on-screen, ignoring children of collapsed nodes.
+     *
+     * A very slow operation for [TreeGrid] since it walks through all items
+     * returned by [_rowSequence].
+     *
+     * If [_dataProviderSupportsSizeOp] is false, this function will fetch all
+     * the data and count the result returned, which is also very slow.
+     */
+    public static int _size(Grid<?> grid) {
+        if (grid instanceof TreeGrid) {
+            return _size((TreeGrid<?>) grid);
+        }
+        if (!_dataProviderSupportsSizeOp(grid)) {
+            return _findAll(grid).size();
+        }
+        try {
+            return (Integer) _DataCommunicator_getDataProviderSize
+                    .invoke(grid.getDataCommunicator());
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Gets a [Grid.Column] of this grid by its [columnKey].
+     *
+     * @throws AssertionError
+     *             if no such column exists.
+     */
+    public static <T> Grid.Column<T> _getColumnByKey(Grid<T> grid,
+            String columnKey) {
+        Grid.Column<T> col = grid.getColumnByKey(columnKey);
+        if (col == null) {
+            List<String> keys = grid.getColumns().stream()
+                    .map(Grid.Column::getKey).filter(java.util.Objects::nonNull)
+                    .collect(Collectors.toList());
+            throw new AssertionError(PrettyPrintTree.toPrettyString(grid)
+                    + ": No such column with key '" + columnKey
+                    + "'; available columns: " + keys);
+        }
+        return col;
+    }
+
+    /**
+     * Retrieves a component produced by [ComponentRenderer] in given [Grid]
+     * cell. Fails if the renderer is not a [ComponentRenderer].
+     *
+     * @param rowIndex
+     *            the row index, 0 or higher.
+     * @param columnKey
+     *            the column key [Grid.Column.getKey]
+     * @throws IllegalStateException
+     *             if the renderer is not [ComponentRenderer].
+     */
+    public static <T> Component _getCellComponent(Grid<T> grid, int rowIndex,
+            String columnKey) {
+        Grid.Column<T> column = _getColumnByKey(grid, columnKey);
+        Renderer<T> renderer = column.getRenderer();
+        if (!(renderer instanceof ComponentRenderer)) {
+            throw new IllegalArgumentException(
+                    PrettyPrintTree.toPrettyString(grid) + " column "
+                            + columnKey + " uses renderer " + renderer
+                            + " but we expect a ComponentRenderer here");
+        }
+        if (renderer instanceof NativeButtonRenderer) {
+            throw new IllegalArgumentException(PrettyPrintTree
+                    .toPrettyString(grid) + " column " + columnKey
+                    + " uses NativeButtonRenderer which is not supported by this function");
+        }
+        T item = _get(grid, rowIndex);
+        @SuppressWarnings("unchecked")
+        ComponentRenderer<?, T> cr = (ComponentRenderer<?, T>) renderer;
+        return cr.createComponent(item);
+    }
+
+    /**
+     * Returns the formatted value of given column as a String. Uses
+     * [getPresentationValue] and converts the result to string (even if the
+     * result is a [Component]).
+     *
+     * @param rowIndex
+     *            the row index, 0 or higher.
+     * @param columnKey
+     *            the column ID.
+     */
+    public static <T> String _getFormatted(Grid<T> grid, int rowIndex,
+            String columnKey) {
+        T rowObject = _get(grid, rowIndex);
+        Grid.Column<T> column = _getColumnByKey(grid, columnKey);
+        return _getFormatted(column, rowObject);
+    }
+
+    /**
+     * Returns the formatted value as a String. Uses [getPresentationValue] and
+     * converts the result to string (even if the result is a [Component]).
+     *
+     * @param rowObject
+     *            the bean
+     */
+    public static <T> String _getFormatted(Grid.Column<T> column, T rowObject) {
+        Object value = getPresentationValue(column, rowObject);
+        return String.valueOf(value);
+    }
+
+    /**
+     * Returns the formatted row as a list of Strings, one for every visible
+     * column. Uses [_getFormatted].
+     *
+     * @param rowObject
+     *            the bean
+     */
+    public static <T> List<String> _getFormattedRow(Grid<T> grid, T rowObject) {
+        List<String> result = new ArrayList<>();
+        for (Grid.Column<T> c : grid.getColumns()) {
+            if (c.isVisible()) {
+                result.add(_getFormatted(c, rowObject));
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Returns the formatted row as a list of Strings, one for every visible
+     * column. Uses [_getFormatted]. Fails if the [rowIndex] is not within the
+     * limits.
+     *
+     * @param rowIndex
+     *            the index of the row, 0..size-1.
+     */
+    public static <T> List<String> _getFormattedRow(Grid<T> grid,
+            int rowIndex) {
+        T rowObject = _get(grid, rowIndex);
+        return _getFormattedRow(grid, rowObject);
+    }
+
+    /**
+     * Returns the formatted row as a list of Strings, one for every visible
+     * column. Uses [_getFormatted]. Returns null if the [rowIndex] is not
+     * within the limits.
+     *
+     * @param rowIndex
+     *            the index of the row, 0-based.
+     */
+    public static <T> List<String> _getFormattedRowOrNull(Grid<T> grid,
+            int rowIndex) {
+        T rowObject = _getOrNull(grid, rowIndex);
+        if (rowObject == null) {
+            return null;
+        }
+        return _getFormattedRow(grid, rowObject);
+    }
+
+    /**
+     * Returns the output of renderer set for this column for given [rowObject]
+     * formatted as close as possible to the client-side output, using
+     * [Grid.Column.renderer].
+     */
+    public static <T> Object getPresentationValue(Grid.Column<T> column,
+            T rowObject) {
+        Renderer<T> renderer = column.getRenderer();
+        if (renderer instanceof ColumnPathRenderer) {
+            @SuppressWarnings("unchecked")
+            ColumnPathRenderer<T> cpr = (ColumnPathRenderer<T>) renderer;
+            ValueProvider<T, ?> valueProvider = providerOf(cpr);
+            if (valueProvider == null) {
+                return null;
+            }
+            Object value = valueProvider.apply(rowObject);
+            return String.valueOf(value);
+        }
+        return Renderers._getPresentationValue(renderer, rowObject);
+    }
+
+    private static <T> String getSortIndicator(Grid<T> grid,
+            Grid.Column<T> column) {
+        GridSortOrder<T> so = null;
+        for (GridSortOrder<T> o : grid.getSortOrder()) {
+            if (o.getSorted() == column) {
+                so = o;
+                break;
+            }
+        }
+        if (so == null) {
+            return "";
+        }
+        return so.getDirection() == SortDirection.ASCENDING ? "v" : "^";
+    }
+
+    /**
+     * Dumps given range of rows of the Grid, formatting the values using the
+     * [_getFormatted] function. Does not consider header groups. The output
+     * example:
+     *
+     * <pre>
+     * --[Name]--[Age]--[Occupation]--
+     * 0: John, 25, Service Worker
+     * 1: Fred, 40, Supervisor
+     * --and 198 more
+     * </pre>
+     */
+    public static <T> String _dump(Grid<T> grid) {
+        return _dump(grid, 0, 9);
+    }
+
+    public static <T> String _dump(Grid<T> grid, int from, int to) {
+        StringBuilder sb = new StringBuilder();
+        List<Grid.Column<T>> visibleColumns = new ArrayList<>();
+        for (Grid.Column<T> c : grid.getColumns()) {
+            if (c.isVisible()) {
+                visibleColumns.add(c);
+            }
+        }
+        sb.append("--");
+        for (int i = 0; i < visibleColumns.size(); i++) {
+            Grid.Column<T> c = visibleColumns.get(i);
+            sb.append("[").append(c.getHeaderText()).append("]")
+                    .append(getSortIndicator(grid, c));
+            if (i < visibleColumns.size() - 1) {
+                sb.append("-");
+            }
+        }
+        sb.append("--\n");
+        int rangeSize = Math.max(0, to + 1 - from);
+        if (grid instanceof TreeGrid) {
+            @SuppressWarnings("unchecked")
+            TreeGrid<T> treeGrid = (TreeGrid<T>) grid;
+            PrettyPrintTree tree = _dataSourceToPrettyTree(treeGrid);
+            String printed = tree.print();
+            List<String> lines = filterNotBlankAll(
+                    Arrays.asList(printed.split("\n", -1)));
+            if (!lines.isEmpty()) {
+                lines = lines.subList(1, lines.size());
+            }
+            int dsSize = lines.size();
+            int displayed = 0;
+            for (int i = from; i <= to && i < dsSize; i++) {
+                if (i >= 0) {
+                    sb.append(i).append(": ").append(lines.get(i)).append("\n");
+                    displayed++;
+                }
+            }
+            int andMore = dsSize - displayed;
+            if (andMore > 0) {
+                sb.append("--and ").append(andMore).append(" more\n");
+            }
+        } else if (_dataProviderSupportsSizeOp(grid)) {
+            int dsSize = _size(grid);
+            int displayed = 0;
+            for (int i = from; i <= to && i < dsSize; i++) {
+                if (i >= 0) {
+                    List<String> row = _getFormattedRow(grid, i);
+                    sb.append(i).append(": ");
+                    for (int j = 0; j < row.size(); j++) {
+                        sb.append(row.get(j));
+                        if (j < row.size() - 1) {
+                            sb.append(", ");
+                        }
+                    }
+                    sb.append("\n");
+                    displayed++;
+                }
+            }
+            int andMore = dsSize - displayed;
+            if (andMore > 0) {
+                sb.append("--and ").append(andMore).append(" more\n");
+            }
+        } else {
+            int rowsOutputted = 0;
+            for (int i = from; i <= to; i++) {
+                List<String> row = _getFormattedRowOrNull(grid, i);
+                if (row == null) {
+                    break;
+                }
+                sb.append(i).append(": ");
+                for (int j = 0; j < row.size(); j++) {
+                    sb.append(row.get(j));
+                    if (j < row.size() - 1) {
+                        sb.append(", ");
+                    }
+                }
+                sb.append("\n");
+                rowsOutputted++;
+            }
+            if (rowsOutputted == rangeSize) {
+                sb.append("--and possibly more\n");
+            } else {
+                sb.append("--\n");
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Asserts that this grid's provider returns given [count] of items. If not,
+     * an [AssertionError] is thrown with the Grid [_dump].
+     */
+    public static void expectRows(Grid<?> grid, int count) {
+        int actual = _size(grid);
+        if (actual != count) {
+            throw new AssertionError(
+                    PrettyPrintTree.toPrettyString(grid) + ": expected " + count
+                            + " rows but got " + actual + "\n" + _dump(grid));
+        }
+    }
+
+    /**
+     * Asserts that this grid's [rowIndex] row is formatted as expected.
+     *
+     * @param row
+     *            the expected row formatting.
+     */
+    public static void expectRow(Grid<?> grid, int rowIndex, String... row) {
+        List<String> expected = Arrays.asList(row);
+        List<String> actual = _getFormattedRow(grid, rowIndex);
+        if (!expected.equals(actual)) {
+            throw new AssertionError(PrettyPrintTree.toPrettyString(grid)
+                    + " at " + rowIndex + ": expected " + expected + " but got "
+                    + actual + "\n" + _dump(grid));
+        }
+    }
+
+    /**
+     * Returns the column object backing the given HeaderCell. Returns an
+     * instance of {@code com.vaadin.flow.component.grid.AbstractColumn}.
+     */
+    static Object column(HeaderRow.HeaderCell cell) {
+        try {
+            return _AbstractCell_getColumn.invoke(cell);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Returns the column object backing the given FooterCell. Returns an
+     * instance of {@code com.vaadin.flow.component.grid.AbstractColumn}.
+     */
+    static Object column(FooterRow.FooterCell cell) {
+        try {
+            return _AbstractCell_getColumn.invoke(cell);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Returns the [ValueProvider] backing this [ColumnPathRenderer].
+     */
+    @SuppressWarnings("unchecked")
+    static <T> ValueProvider<T, ?> providerOf(ColumnPathRenderer<T> renderer) {
+        try {
+            return (ValueProvider<T, ?>) _ColumnPathRenderer_provider
+                    .get(renderer);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Retrieves column key from an `AbstractColumn` instance. The problem here
+     * is that the argument can be `ColumnGroup` which doesn't have a key.
+     */
+    private static String columnKey(Object abstractColumn) {
+        try {
+            _AbstractColumn_class.cast(abstractColumn);
+            Grid.Column<?> gridColumn = (Grid.Column<?>) _AbstractColumn_getBottomLevelColumn
+                    .invoke(abstractColumn);
+            return gridColumn.getKey();
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Retrieves the cell for given [Grid.Column.getKey].
+     *
+     * @return the corresponding cell
+     * @throws IllegalArgumentException
+     *             if no such column exists.
+     */
+    public static HeaderRow.HeaderCell getCell(HeaderRow row, String key) {
+        for (HeaderRow.HeaderCell cell : row.getCells()) {
+            Grid.Column<?> col = (Grid.Column<?>) column(cell);
+            if (java.util.Objects.equals(col.getKey(), key)) {
+                return cell;
+            }
+        }
+        throw new IllegalArgumentException("This grid has no property named "
+                + key + ": " + row.getCells());
+    }
+
+    /**
+     * Retrieves the cell for given [Grid.Column.getKey].
+     *
+     * @return the corresponding cell
+     * @throws IllegalArgumentException
+     *             if no such column exists.
+     */
+    public static FooterRow.FooterCell getCell(FooterRow row, String key) {
+        for (FooterRow.FooterCell cell : row.getCells()) {
+            if (java.util.Objects.equals(columnKey(column(cell)), key)) {
+                return cell;
+            }
+        }
+        throw new IllegalArgumentException("This grid has no property named "
+                + key + ": " + row.getCells());
+    }
+
+    /**
+     * Sorts given grid. Affects [_findAll], [_get] and other data-fetching
+     * functions.
+     */
+    public static <T> void sort(Grid<T> grid, QuerySortOrder... sortOrder) {
+        List<GridSortOrder<T>> orders = new ArrayList<>();
+        for (QuerySortOrder qso : sortOrder) {
+            orders.add(
+                    new GridSortOrder<>(_getColumnByKey(grid, qso.getSorted()),
+                            qso.getDirection()));
+        }
+        grid.sort(orders);
+    }
+
+    // ---------------------------------------------------------------------
+    // Click / select helpers
+    // ---------------------------------------------------------------------
+
+    /**
+     * Fires the [ItemClickEvent] event for given [rowIndex] which invokes all
+     * item click listeners registered via [Grid.addItemClickListener].
+     *
+     * @param button
+     *            the id of the pressed mouse button (0 is the default button,
+     *            see ClickEvent.getButton)
+     * @param ctrlKey
+     *            `true` if the control key was down when the event was fired,
+     *            `false` otherwise
+     * @param shiftKey
+     *            `true` if the shift key was down when the event was fired,
+     *            `false` otherwise
+     * @param altKey
+     *            `true` if the alt key was down when the event was fired,
+     *            `false` otherwise
+     * @param metaKey
+     *            `true` if the meta key was down when the event was fired,
+     *            `false` otherwise
+     */
+    public static <T> void _clickItem(Grid<T> grid, int rowIndex, int button,
+            boolean ctrlKey, boolean shiftKey, boolean altKey,
+            boolean metaKey) {
+        _clickItem(grid, rowIndex, (Grid.Column<?>) null, button, ctrlKey,
+                shiftKey, altKey, metaKey);
+    }
+
+    public static <T> void _clickItem(Grid<T> grid, int rowIndex) {
+        _clickItem(grid, rowIndex, 0, false, false, false, false);
+    }
+
+    /**
+     * Fires the [ItemClickEvent] event for given [rowIndex] and a [column]
+     * which invokes all item click listeners registered via
+     * [Grid.addItemClickListener].
+     *
+     * @param button
+     *            the id of the pressed mouse button
+     * @param column
+     *            optional column to be clicked
+     * @param ctrlKey
+     *            `true` if the control key was down when the event was fired,
+     *            `false` otherwise
+     * @param shiftKey
+     *            `true` if the shift key was down when the event was fired,
+     *            `false` otherwise
+     * @param altKey
+     *            `true` if the alt key was down when the event was fired,
+     *            `false` otherwise
+     * @param metaKey
+     *            `true` if the meta key was down when the event was fired,
+     *            `false` otherwise
+     */
+    public static <T> void _clickItem(Grid<T> grid, int rowIndex,
+            Grid.Column<?> column, int button, boolean ctrlKey,
+            boolean shiftKey, boolean altKey, boolean metaKey) {
+        BasicUtils.checkEditableByUser(grid);
+        // fire SelectionEvent if need be:
+        // https://github.com/mvysny/karibu-testing/issues/96
+        T item = _get(grid, rowIndex);
+        if (grid.getSelectionModel() instanceof GridSingleSelectionModel) {
+            Set<T> selected = grid.getSelectedItems();
+            T selectedItem = selected.isEmpty() ? null
+                    : selected.iterator().next();
+            if (!java.util.Objects.equals(selectedItem, item)) {
+                grid.select(item);
+            } else {
+                grid.deselectAll();
+            }
+        }
+
+        // fire ItemClickEvent
+        String itemKey = grid.getDataCommunicator().getKeyMapper().key(item);
+        String internalColumnId = column == null ? null : _internalId(column);
+        ItemClickEvent<T> event = new ItemClickEvent<>(grid, true, itemKey,
+                internalColumnId, -1, -1, -1, -1, 1, button, ctrlKey, shiftKey,
+                altKey, metaKey);
+        BasicUtils._fireEvent(grid, event);
+    }
+
+    public static <T> void _clickItem(Grid<T> grid, int rowIndex,
+            Grid.Column<?> column) {
+        _clickItem(grid, rowIndex, column, 1, false, false, false, false);
+    }
+
+    /**
+     * Fires the [ItemClickEvent] event for given [rowIndex] and a [columnKey]
+     * which invokes all item click listeners registered via
+     * [Grid.addItemClickListener].
+     *
+     * @param button
+     *            the id of the pressed mouse button
+     * @param columnKey
+     *            the key of the column to be clicked
+     * @param ctrlKey
+     *            `true` if the control key was down when the event was fired,
+     *            `false` otherwise
+     * @param shiftKey
+     *            `true` if the shift key was down when the event was fired,
+     *            `false` otherwise
+     * @param altKey
+     *            `true` if the alt key was down when the event was fired,
+     *            `false` otherwise
+     * @param metaKey
+     *            `true` if the meta key was down when the event was fired,
+     *            `false` otherwise
+     */
+    public static <T> void _clickItem(Grid<T> grid, int rowIndex,
+            String columnKey, int button, boolean ctrlKey, boolean shiftKey,
+            boolean altKey, boolean metaKey) {
+        _clickItem(grid, rowIndex, _getColumnByKey(grid, columnKey), button,
+                ctrlKey, shiftKey, altKey, metaKey);
+    }
+
+    public static <T> void _clickItem(Grid<T> grid, int rowIndex,
+            String columnKey) {
+        _clickItem(grid, rowIndex, columnKey, 1, false, false, false, false);
+    }
+
+    /**
+     * Fires the [ItemDoubleClickEvent] event for given [rowIndex] which invokes
+     * all item click listeners registered via
+     * [Grid.addItemDoubleClickListener].
+     *
+     * @param button
+     *            the id of the pressed mouse button
+     * @param ctrlKey
+     *            `true` if the control key was down when the event was fired,
+     *            `false` otherwise
+     * @param shiftKey
+     *            `true` if the shift key was down when the event was fired,
+     *            `false` otherwise
+     * @param altKey
+     *            `true` if the alt key was down when the event was fired,
+     *            `false` otherwise
+     * @param metaKey
+     *            `true` if the meta key was down when the event was fired,
+     *            `false` otherwise
+     */
+    public static <T> void _doubleClickItem(Grid<T> grid, int rowIndex,
+            int button, boolean ctrlKey, boolean shiftKey, boolean altKey,
+            boolean metaKey) {
+        BasicUtils.checkEditableByUser(grid);
+        String itemKey = grid.getDataCommunicator().getKeyMapper()
+                .key(_get(grid, rowIndex));
+        ItemDoubleClickEvent<T> event = new ItemDoubleClickEvent<>(grid, true,
+                itemKey, null, -1, -1, -1, -1, 2, button, ctrlKey, shiftKey,
+                altKey, metaKey);
+        BasicUtils._fireEvent(grid, event);
+    }
+
+    public static <T> void _doubleClickItem(Grid<T> grid, int rowIndex) {
+        _doubleClickItem(grid, rowIndex, 1, false, false, false, false);
+    }
+
+    // ---------------------------------------------------------------------
+    // TreeGrid helpers
+    // ---------------------------------------------------------------------
+
+    /**
+     * Returns a stream which walks over all rows the [TreeGrid] is actually
+     * showing. The stream will *skip* children of collapsed nodes.
+     *
+     * Iterating the entire stream is a very slow operation since it will
+     * repeatedly poll [HierarchicalDataProvider] for list of children.
+     *
+     * Honors current grid ordering.
+     */
+    public static <T> Stream<T> _rowSequence(TreeGrid<T> grid,
+            SerializablePredicate<T> filter) {
+        Predicate<T> isExpanded = grid::isExpanded;
+        return _rowSequence(grid.getDataProvider(), null, isExpanded, filter);
+    }
+
+    public static <T> Stream<T> _rowSequence(TreeGrid<T> grid) {
+        return _rowSequence(grid, null);
+    }
+
+    /**
+     * Returns a stream which walks over all rows the [TreeGrid] is actually
+     * showing. The stream will *skip* children of collapsed nodes.
+     *
+     * Iterating the entire stream is a very slow operation since it will
+     * repeatedly poll [HierarchicalDataProvider] for list of children.
+     *
+     * Honors current grid ordering.
+     *
+     * @param root
+     *            start with this item; defaults to null to iterate all items
+     * @param isExpanded
+     *            if returns false for an item, children of that item are
+     *            skipped
+     * @param filter
+     *            filter to pass to [HierarchicalQuery]
+     */
+    public static <T, F> Stream<T> _rowSequence(
+            HierarchicalDataProvider<T, F> provider, T root,
+            Predicate<T> isExpanded, F filter) {
+        Function<T, List<T>> getChildrenOf = item -> {
+            if (item == null || isExpanded.test(item)) {
+                return checkedFetch(provider,
+                        new HierarchicalQuery<>(filter, item));
+            }
+            return Collections.emptyList();
+        };
+        List<T> roots = getChildrenOf.apply(root);
+        Stream<T> result = Stream.empty();
+        for (T r : roots) {
+            Iterable<T> subtree = () -> new DepthFirstTreeIterator<>(r,
+                    getChildrenOf::apply);
+            result = Stream.concat(result,
+                    StreamSupport.stream(subtree.spliterator(), false));
+        }
+        return result;
+    }
+
+    public static <T, F> Stream<T> _rowSequence(
+            HierarchicalDataProvider<T, F> provider) {
+        return _rowSequence(provider, null, item -> true, null);
+    }
+
+    /**
+     * Returns the number of items the [TreeGrid] is actually showing. For
+     * example it doesn't count in children of collapsed nodes.
+     *
+     * A very slow operation since it walks through all items returned by
+     * [_rowSequence].
+     */
+    public static int _size(TreeGrid<?> grid) {
+        return (int) _rowSequence(grid).count();
+    }
+
+    private static <T, F> int checkedSize(
+            HierarchicalDataProvider<T, F> provider,
+            HierarchicalQuery<T, F> query) {
+        if (query.getParent() != null
+                && !provider.hasChildren(query.getParent())) {
+            return 0;
+        }
+        int result = provider.size(query);
+        if (result < 0) {
+            throw new IllegalStateException(
+                    "size(" + query + ") returned negative count: " + result);
+        }
+        return result;
+    }
+
+    private static <T, F> List<T> checkedFetch(
+            HierarchicalDataProvider<T, F> provider,
+            HierarchicalQuery<T, F> query) {
+        if (checkedSize(provider, query) == 0) {
+            return Collections.emptyList();
+        }
+        return provider.fetchChildren(query).collect(Collectors.toList());
+    }
+
+    public static <T> PrettyPrintTree _dataSourceToPrettyTree(
+            TreeGrid<T> grid) {
+        Function<T, List<T>> getChildrenOf = item -> {
+            if (item == null || grid.isExpanded(item)) {
+                return checkedFetch(grid.getDataProvider(),
+                        new HierarchicalQuery<>(null, item));
+            }
+            return Collections.emptyList();
+        };
+        List<T> roots = getChildrenOf.apply(null);
+        List<PrettyPrintTree> rootTrees = new ArrayList<>();
+        for (T r : roots) {
+            rootTrees.add(toPrettyTree(grid, getChildrenOf, r));
+        }
+        return new PrettyPrintTree("TreeGrid", rootTrees);
+    }
+
+    private static <T> PrettyPrintTree toPrettyTree(TreeGrid<T> grid,
+            Function<T, List<T>> getChildrenOf, T item) {
+        List<String> row = _getFormattedRow(grid, item);
+        StringBuilder self = new StringBuilder();
+        for (int j = 0; j < row.size(); j++) {
+            self.append(row.get(j));
+            if (j < row.size() - 1) {
+                self.append(", ");
+            }
+        }
+        self.append("\n");
+        List<T> children = getChildrenOf.apply(item);
+        List<PrettyPrintTree> childTrees = new ArrayList<>();
+        for (T c : children) {
+            childTrees.add(toPrettyTree(grid, getChildrenOf, c));
+        }
+        return new PrettyPrintTree(self.toString(), childTrees);
+    }
+
+    public static <T> List<T> _getRootItems(TreeGrid<T> grid) {
+        return grid.getDataProvider().fetch(new HierarchicalQuery<>(null, null))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Expands all nodes. May invoke massive data loading.
+     */
+    public static <T> void _expandAll(TreeGrid<T> grid, int depth) {
+        grid.expandRecursively(_getRootItems(grid), depth);
+    }
+
+    public static <T> void _expandAll(TreeGrid<T> grid) {
+        _expandAll(grid, 100);
+    }
+
+    // ---------------------------------------------------------------------
+    // Component.dataProvider (full implementation)
+    // ---------------------------------------------------------------------
+
+    /**
+     * Returns the data provider currently set to this Component.
+     *
+     * Works both with Vaadin 16 and Vaadin 17: Vaadin 17 components no longer
+     * implement HasItems.
+     */
+    public static DataProvider<?, ?> dataProvider(Component c) {
+        try {
+            // until https://github.com/vaadin/flow/issues/6296 is resolved
+            if (c instanceof Grid) {
+                return ((Grid<?>) c).getDataProvider();
+            }
+            if (c instanceof Select) {
+                return ((Select<?>) c).getDataProvider();
+            }
+            if (c instanceof ListBoxBase) {
+                return (DataProvider<?, ?>) _ListBoxBase_getDataProvider
+                        .invoke(c);
+            }
+            if (c instanceof RadioButtonGroup) {
+                return (DataProvider<?, ?>) _RadioButtonGroup_getDataProvider
+                        .invoke(c);
+            }
+            if (c instanceof CheckboxGroup) {
+                return (DataProvider<?, ?>) _CheckboxGroup_getDataProvider
+                        .invoke(c);
+            }
+            if (c instanceof ComboBox) {
+                return ((ComboBox<?>) c).getDataProvider();
+            }
+            return null;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    // ---------------------------------------------------------------------
+    // Editor / selection
+    // ---------------------------------------------------------------------
+
+    /**
+     * Call this instead of [Editor.editItem] - this function makes sure that
+     * the editor opening is mocked properly, calls the editor bindings, and
+     * fires the editor-open-event.
+     */
+    public static <T> void _editItem(Editor<T> editor, T item) {
+        if (!editor.getGrid().isAttached()) {
+            throw new IllegalStateException(
+                    "Grid is not attached so can not edit");
+        }
+        editor.editItem(item);
+        MockVaadin.clientRoundtrip();
+    }
+
+    private static volatile Method clientSelectAll;
+
+    private static volatile Method clientDeselectAll;
+
+    private static Method _AbstractGridMultiSelectionModel_clientSelectAll()
+            throws NoSuchMethodException {
+        if (clientSelectAll == null) {
+            Method m = AbstractGridMultiSelectionModel.class
+                    .getDeclaredMethod("clientSelectAll");
+            m.setAccessible(true);
+            clientSelectAll = m;
+        }
+        return clientSelectAll;
+    }
+
+    private static Method _AbstractGridMultiSelectionModel_clientDeselectAll()
+            throws NoSuchMethodException {
+        if (clientDeselectAll == null) {
+            Method m = AbstractGridMultiSelectionModel.class
+                    .getDeclaredMethod("clientDeselectAll");
+            m.setAccessible(true);
+            clientDeselectAll = m;
+        }
+        return clientDeselectAll;
+    }
+
+    private static <T> GridMultiSelectionModel<T> _selectAllCheckboxModel(
+            Grid<T> grid, String action) {
+        GridSelectionModel<T> model = grid.getSelectionModel();
+        if (!(model instanceof GridMultiSelectionModel)) {
+            throw new IllegalStateException(
+                    action + " requires multi selection mode");
+        }
+        GridMultiSelectionModel<T> multi = (GridMultiSelectionModel<T>) model;
+        if (!multi.isSelectAllCheckboxVisible()) {
+            throw new IllegalStateException(
+                    action + " requires the select all checkbox to be visible");
+        }
+        return multi;
+    }
+
+    /**
+     * In single select clears the selection and selects only the given item; in
+     * multi-select adds it to the selection.
+     *
+     * @param grid
+     *            the grid to select in
+     * @param item
+     *            the item to select
+     * @param <T>
+     *            the grid item type
+     */
+    public static <T> void _select(Grid<T> grid, T item) {
+        BasicUtils.checkEditableByUser(grid);
+        if (grid.getSelectionModel() instanceof GridSingleSelectionModel) {
+            grid.deselectAll();
+        }
+        // fails properly if the Grid doesn't support selection.
+        grid.getSelectionModel().selectFromClient(item);
+    }
+
+    /**
+     * Selects all items in the Grid; runs the same code as when the "select
+     * all" checkbox is checked.
+     *
+     * @param grid
+     *            the grid to select in
+     * @param <T>
+     *            the grid item type
+     * @throws IllegalStateException
+     *             if the grid is not multi-select, or the "select all" checkbox
+     *             is hidden
+     */
+    public static <T> void _selectAll(Grid<T> grid) {
+        BasicUtils.checkEditableByUser(grid);
+        GridMultiSelectionModel<T> model = _selectAllCheckboxModel(grid,
+                "Select all");
+        try {
+            _AbstractGridMultiSelectionModel_clientSelectAll().invoke(model);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Deselects the given item: the same code that runs when the user
+     * ctrl-clicks a selected row or unchecks the row's selection checkbox in
+     * multi-select, or clicks the selected row in single select.
+     * <p>
+     * The call is ignored — just as the user's click would be — if the item is
+     * not selectable ({@link Grid#setItemSelectableProvider}), or if the grid
+     * is single-select with
+     * {@link GridSingleSelectionModel#isDeselectAllowed()} set to false.
+     *
+     * @param grid
+     *            the grid to deselect in
+     * @param item
+     *            the item to deselect; it must be selected, since deselecting a
+     *            row that is not selected is not a gesture the user has
+     * @param <T>
+     *            the grid item type
+     * @throws IllegalStateException
+     *             if the item is not selected
+     */
+    public static <T> void _deselect(Grid<T> grid, T item) {
+        BasicUtils.checkEditableByUser(grid);
+        if (!(grid.getSelectionModel() instanceof GridNoneSelectionModel)
+                && !grid.getSelectionModel().isSelected(item)) {
+            throw new IllegalStateException(
+                    "Can not deselect " + item + ": the row is not selected");
+        }
+        // fails properly if the Grid doesn't support selection.
+        grid.getSelectionModel().deselectFromClient(item);
+    }
+
+    /**
+     * Deselects all items in the Grid; runs the same code as when the "select
+     * all" checkbox is unchecked.
+     * <p>
+     * This is the counterpart of {@link #_selectAll} and behaves like the
+     * checkbox does: the whole selection is dropped in one selection event,
+     * without the per-row {@code ClientItemToggleEvent}s the user would cause
+     * by unchecking rows one by one. Call {@link #_deselect} per row to model
+     * that instead.
+     *
+     * @param grid
+     *            the grid to deselect in
+     * @param <T>
+     *            the grid item type
+     * @throws IllegalStateException
+     *             if the grid is not multi-select, or the "select all" checkbox
+     *             is hidden
+     */
+    public static <T> void _deselectAll(Grid<T> grid) {
+        BasicUtils.checkEditableByUser(grid);
+        GridMultiSelectionModel<T> model = _selectAllCheckboxModel(grid,
+                "Deselect all");
+        try {
+            _AbstractGridMultiSelectionModel_clientDeselectAll().invoke(model);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Returns the column's Internal ID. Not related to [Grid.Column.getKey] in
+     * any way. Auto-generated by the Grid. Not really useful; mostly used
+     * internally by Vaadin.
+     */
+    public static String _internalId(Grid.Column<?> column) {
+        try {
+            return (String) _Column_getInternalId.invoke(column);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    // ---------------------------------------------------------------------
+    // private helpers
+    // ---------------------------------------------------------------------
+
+    private static List<String> filterNotBlankAll(List<String> source) {
+        List<String> result = new ArrayList<>();
+        for (String s : source) {
+            if (s != null && !s.isBlank()) {
+                result.add(s);
+            }
+        }
+        return result;
+    }
+}
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/GridContextMenuSupport.java b/shared/src/main/java/com/vaadin/browserless/internal/GridContextMenuSupport.java
index 294133f5..dc68461b 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/GridContextMenuSupport.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/GridContextMenuSupport.java
@@ -21,7 +21,7 @@
 import java.util.List;
 import java.util.Map;
 
-import com.vaadin.browserless.component.GridKt;
+import com.vaadin.browserless.component.GridUtils;
 import com.vaadin.flow.component.grid.Grid;
 import com.vaadin.flow.component.grid.contextmenu.GridContextMenu;
 import com.vaadin.flow.dom.DomEventListener;
@@ -146,7 +146,7 @@ public static String getColumnInternalId(Grid<?> grid, String columnKey) {
             throw new IllegalStateException("Column with key " + columnKey
                     + " is not visible, so a user cannot reach it");
         }
-        return GridKt.get_internalId(column);
+        return GridUtils._internalId(column);
     }
 
     private static List<GridContextMenu<?>> findContextMenus(Grid<?> grid) {
diff --git a/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java b/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java
index c91586d7..2a234093 100644
--- a/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java
@@ -15,7 +15,7 @@
  */
 package com.vaadin.flow.component.accordion;
 
-import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.Nullable;
 
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
diff --git a/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java b/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java
index 7d1f5c62..38e6d721 100644
--- a/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java
@@ -17,7 +17,7 @@
 
 import java.util.List;
 
-import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.Nullable;
 
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
diff --git a/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java b/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java
index ebb4fbed..ed611ca2 100644
--- a/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java
@@ -17,7 +17,7 @@
 
 import java.util.List;
 
-import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.Nullable;
 
 import com.vaadin.browserless.ComponentQuery;
 import com.vaadin.browserless.ComponentTester;
diff --git a/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java b/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java
index cea8b984..47fc18a2 100644
--- a/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java
@@ -26,7 +26,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
@@ -150,7 +150,7 @@ public Set<V> getSelected() {
         return getComponent().getValue();
     }
 
-    @NotNull
+    @NonNull
     private Stream<Checkbox> getCheckboxes(Predicate<Checkbox> filter) {
         return getComponent().getChildren().filter(Checkbox.class::isInstance)
                 .map(Checkbox.class::cast).filter(filter);
diff --git a/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java b/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
index ef83e5d1..10739612 100644
--- a/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
@@ -28,7 +28,7 @@
 import com.vaadin.browserless.MetaKeys;
 import com.vaadin.browserless.MouseButton;
 import com.vaadin.browserless.Tests;
-import com.vaadin.browserless.component.GridKt;
+import com.vaadin.browserless.component.GridUtils;
 import com.vaadin.browserless.internal.GridContextMenuSupport;
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.grid.contextmenu.GridContextMenu;
@@ -67,7 +67,7 @@ public GridTester(T component) {
      * @return items in grid
      */
     public int size() {
-        return GridKt._size(getComponent());
+        return GridUtils._size(getComponent());
     }
 
     /**
@@ -80,7 +80,7 @@ public int size() {
      * @return grid item on row
      */
     public Y getRow(int row) {
-        return GridKt._get(getComponent(), row);
+        return GridUtils._get(getComponent(), row);
     }
 
     /**
@@ -139,7 +139,7 @@ public void clickRow(int row, MetaKeys metaKeys) {
      */
     public void clickRow(int row, MouseButton button, MetaKeys metaKeys) {
         ensureComponentIsUsable();
-        GridKt._clickItem(getComponent(), row, button.getButton(),
+        GridUtils._clickItem(getComponent(), row, button.getButton(),
                 metaKeys.isCtrl(), metaKeys.isShift(), metaKeys.isAlt(),
                 metaKeys.isMeta());
     }
@@ -200,7 +200,7 @@ public void doubleClickRow(int row, MetaKeys metaKeys) {
      */
     public void doubleClickRow(int row, MouseButton button, MetaKeys metaKeys) {
         ensureComponentIsUsable();
-        GridKt._doubleClickItem(getComponent(), row, button.getButton(),
+        GridUtils._doubleClickItem(getComponent(), row, button.getButton(),
                 metaKeys.isCtrl(), metaKeys.isShift(), metaKeys.isAlt(),
                 metaKeys.isMeta());
     }
@@ -221,7 +221,7 @@ public void doubleClickRow(int row, MouseButton button, MetaKeys metaKeys) {
     public void select(int row) {
         ensureComponentIsUsable();
         final Y item = getRow(row);
-        GridKt._select(getComponent(), item);
+        GridUtils._select(getComponent(), item);
     }
 
     /**
@@ -237,7 +237,7 @@ public void select(int row) {
      */
     public void selectAll() {
         ensureComponentIsUsable();
-        GridKt._selectAll(getComponent());
+        GridUtils._selectAll(getComponent());
     }
 
     /**
@@ -265,7 +265,7 @@ public void selectAll() {
     public void deselect(int row) {
         ensureComponentIsUsable();
         final Y item = getRow(row);
-        GridKt._deselect(getComponent(), item);
+        GridUtils._deselect(getComponent(), item);
     }
 
     /**
@@ -286,7 +286,7 @@ public void deselect(int row) {
      */
     public void deselectAll() {
         ensureComponentIsUsable();
-        GridKt._deselectAll(getComponent());
+        GridUtils._deselectAll(getComponent());
     }
 
     /**
diff --git a/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java b/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java
index cf69c829..8ec346d4 100644
--- a/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java
@@ -22,7 +22,7 @@
 import com.vaadin.browserless.ComponentQuery;
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
-import com.vaadin.browserless.component.GridKt;
+import com.vaadin.browserless.component.GridUtils;
 import com.vaadin.browserless.internal.GridContextMenuSupport;
 import com.vaadin.browserless.internal.MenuItemNavigation;
 import com.vaadin.flow.component.Component;
@@ -158,7 +158,7 @@ public void open(int row, String columnKey) {
         }
         Grid<Y> grid = getGrid();
         String itemKey = GridContextMenuSupport.getItemKey(grid,
-                GridKt._get(grid, row));
+                GridUtils._get(grid, row));
         String columnId = columnKey == null ? null
                 : GridContextMenuSupport.getColumnInternalId(grid, columnKey);
         GridContextMenuSupport.setTargetItem(grid, itemKey, columnId);
diff --git a/shared/src/main/java/com/vaadin/flow/component/masterdetaillayout/MasterDetailLayoutTester.java b/shared/src/main/java/com/vaadin/flow/component/masterdetaillayout/MasterDetailLayoutTester.java
index 3411a60e..c9523190 100644
--- a/shared/src/main/java/com/vaadin/flow/component/masterdetaillayout/MasterDetailLayoutTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/masterdetaillayout/MasterDetailLayoutTester.java
@@ -15,7 +15,7 @@
  */
 package com.vaadin.flow.component.masterdetaillayout;
 
-import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.Nullable;
 
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
diff --git a/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonGroupTester.java b/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonGroupTester.java
index 26125566..12362e80 100644
--- a/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonGroupTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonGroupTester.java
@@ -20,7 +20,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
@@ -76,7 +76,7 @@ public V getSelected() {
         return getComponent().getValue();
     }
 
-    @NotNull
+    @NonNull
     private Stream<RadioButton> getRadioButtons(Predicate<RadioButton> filter) {
         return getComponent().getChildren()
                 .filter(RadioButton.class::isInstance)
diff --git a/shared/src/main/java/com/vaadin/flow/component/splitlayout/SplitLayoutTester.java b/shared/src/main/java/com/vaadin/flow/component/splitlayout/SplitLayoutTester.java
index 573cee75..f52bf5c1 100644
--- a/shared/src/main/java/com/vaadin/flow/component/splitlayout/SplitLayoutTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/splitlayout/SplitLayoutTester.java
@@ -15,7 +15,7 @@
  */
 package com.vaadin.flow.component.splitlayout;
 
-import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.Nullable;
 import tools.jackson.databind.node.ObjectNode;
 
 import com.vaadin.browserless.ComponentQuery;
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt b/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
deleted file mode 100644
index c42daf5c..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
+++ /dev/null
@@ -1,899 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-@file:Suppress("FunctionName")
-
-package com.vaadin.browserless.component
-
-import com.vaadin.flow.component.ClickNotifier
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.checkbox.CheckboxGroup
-import com.vaadin.flow.component.combobox.ComboBox
-import com.vaadin.flow.component.grid.AbstractGridMultiSelectionModel
-import com.vaadin.flow.component.grid.ColumnPathRenderer
-import com.vaadin.flow.component.grid.FooterRow
-import com.vaadin.flow.component.grid.Grid
-import com.vaadin.flow.component.grid.GridMultiSelectionModel
-import com.vaadin.flow.component.grid.GridNoneSelectionModel
-import com.vaadin.flow.component.grid.GridSingleSelectionModel
-import com.vaadin.flow.component.grid.GridSortOrder
-import com.vaadin.flow.component.grid.HeaderRow
-import com.vaadin.flow.component.grid.ItemClickEvent
-import com.vaadin.flow.component.grid.ItemDoubleClickEvent
-import com.vaadin.flow.component.grid.editor.Editor
-import com.vaadin.flow.component.listbox.ListBoxBase
-import com.vaadin.flow.component.radiobutton.RadioButtonGroup
-import com.vaadin.flow.component.select.Select
-import com.vaadin.flow.component.treegrid.TreeGrid
-import com.vaadin.flow.data.binder.HasItems
-import com.vaadin.flow.data.provider.DataCommunicator
-import com.vaadin.flow.data.provider.DataProvider
-import com.vaadin.flow.data.provider.Query
-import com.vaadin.flow.data.provider.QuerySortOrder
-import com.vaadin.flow.data.provider.SortDirection
-import com.vaadin.flow.data.provider.hierarchy.HierarchicalDataProvider
-import com.vaadin.flow.data.provider.hierarchy.HierarchicalQuery
-import com.vaadin.flow.data.renderer.ComponentRenderer
-import com.vaadin.flow.data.renderer.NativeButtonRenderer
-import com.vaadin.flow.data.renderer.Renderer
-import com.vaadin.flow.function.SerializablePredicate
-import com.vaadin.flow.function.ValueProvider
-import com.vaadin.browserless.internal.DepthFirstTreeIterator
-import com.vaadin.browserless.internal.MockVaadin
-import com.vaadin.browserless.internal.PrettyPrintTree
-import com.vaadin.browserless.internal.BasicUtils._fireEvent
-import com.vaadin.browserless.internal.Renderers._getPresentationValue
-import com.vaadin.browserless.internal.BasicUtils._saneFetchLimit
-import com.vaadin.browserless.internal.BasicUtils.checkEditableByUser
-import com.vaadin.browserless.internal.Renderers.template
-import com.vaadin.browserless.internal.PrettyPrintTree.toPrettyString
-import java.lang.reflect.Method
-import java.lang.reflect.Field
-import java.util.stream.Stream
-import kotlin.reflect.KClass
-import kotlin.reflect.KProperty1
-import kotlin.streams.toList
-import com.vaadin.browserless.internal.Utils.findClassOrThrow
-
-/**
- * Returns the item on given row. Fails if the row index is invalid. The data provider is
- * sorted according to given [sortOrders] (empty by default) and filtered according
- * to given [filter] (null by default) first.
- * @param rowIndex the row, 0..size - 1
- * @return the item at given row.
- * @throws AssertionError if the row index is out of bounds.
- */
-public fun <T, F> DataProvider<T, F>._get(rowIndex: Int, sortOrders: List<QuerySortOrder> = listOf(), inMemorySorting: Comparator<T>? = null, filter: F? = null): T {
-    require(rowIndex >= 0) { "rowIndex must be 0 or greater: $rowIndex" }
-    val fetched: Stream<T> = fetch(Query(rowIndex, 1, sortOrders, inMemorySorting, filter))
-    return fetched.toList().firstOrNull()
-            ?: throw AssertionError("Requested to get row $rowIndex but the data provider only has ${_size(filter)} rows matching filter $filter")
-}
-
-/**
- * Returns all items in given data provider, sorted according to given [sortOrders] (empty by default) and filtered according
- * to given [filter] (null by default).
- * @return the list of items.
- */
-public fun <T, F> DataProvider<T, F>._findAll(sortOrders: List<QuerySortOrder> = listOf(), inMemorySorting: Comparator<T>? = null, filter: F? = null): List<T> {
-    val fetched: Stream<T> = fetch(Query(0, Int.MAX_VALUE, sortOrders, inMemorySorting, filter))
-    return fetched.toList()
-}
-
-/**
- * Returns the item on given row. Fails if the row index is invalid. Uses current Grid sorting.
- *
- * For [TreeGrid] this returns the x-th displayed row; skips children of collapsed nodes.
- * Uses [_rowSequence].
- *
- * WARNING: Very slow operation for [TreeGrid].
- * @param rowIndex the row, 0..size - 1
- * @return the item at given row, not null.
- */
-public fun <T : Any> Grid<T>._get(rowIndex: Int): T {
-    require(rowIndex >= 0) { "rowIndex must be 0 or greater: $rowIndex" }
-    if (this !is TreeGrid && _dataProviderSupportsSizeOp) {
-        // only perform this check for regular Grid. TreeGrid._fetch()'s Sequence consults size() internally.
-        val size: Int = _size()
-        if (rowIndex >= size) {
-            throw AssertionError("Requested to get row $rowIndex but the data provider only has ${_size()} rows\n${_dump()}")
-        }
-    }
-    return _getOrNull(rowIndex)
-        ?: throw AssertionError("Requested to get row $rowIndex but the data provider returned 0 rows\n${_dump()}")
-}
-
-/**
- * Returns the item on given row, or null if the [rowIndex] is larger than the number
- * of items the data provider can provide. Uses current Grid sorting.
- *
- * For [TreeGrid] this returns the x-th displayed row; skips children of collapsed nodes.
- * Uses [_rowSequence].
- *
- * WARNING: Very slow operation for [TreeGrid].
- * @param rowIndex the row, 0 or larger.
- * @return the item at given row or null if the data provider provides less rows.
- */
-public fun <T : Any> Grid<T>._getOrNull(rowIndex: Int): T? {
-    require(rowIndex >= 0) { "rowIndex must be 0 or greater: $rowIndex" }
-    if (this !is TreeGrid && _dataProviderSupportsSizeOp) {
-        // only perform this check for regular Grid. TreeGrid._fetch()'s Sequence consults size() internally.
-        val size: Int = _size()
-        if (rowIndex >= size) {
-            return null
-        }
-    }
-    val fetched: List<T> = _fetch(rowIndex, 1)
-    return fetched.firstOrNull()
-}
-
-/**
- * Vaadin 19+ Grids support setting data providers which do not support retrieving
- * the number of available rows. See `FetchCallback` for more details.
- * @return true if the current data provider supports [_size] retrieval, false
- * if not. Returns true for Vaadin 14.
- */
-public val Grid<*>._dataProviderSupportsSizeOp: Boolean get() {
-    val m = DataCommunicator::class.java.getDeclaredMethod("isDefinedSize")
-    return m.invoke(dataCommunicator) as Boolean
-}
-
-/**
- * Returns items in given range from Grid's data provider. Uses current Grid sorting.
- *
- * For [TreeGrid] this walks the [_rowSequence].
- *
- * The Grid never sets any filters into the data provider, however any
- * ConfigurableFilterDataProvider will automatically apply its filters.
- *
- * WARNING: Very slow operation for [TreeGrid].
- */
-public fun <T> Grid<T>._fetch(offset: Int, limit: Int): List<T> = when(this) {
-    is TreeGrid<T> -> this._rowSequence().drop(offset).take(limit).toList()
-    else -> dataCommunicator.fetch(offset, limit)
-}
-
-private val _DataCommunicator_fetchFromProvider: Method =
-    DataCommunicator::class.java.getDeclaredMethod("fetchFromProvider", Int::class.java, Int::class.java).apply {
-        isAccessible = true
-    }
-
-private val _DataCommunicator_setPagingEnabled: Method? =
-    DataCommunicator::class.java.declaredMethods.firstOrNull { it.name == "setPagingEnabled" }
-
-
-/**
- * Returns items in given range from this data communicator. Uses current Grid sorting.
- * Any ConfigurableFilterDataProvider will automatically apply its filters.
- *
- * This is an internal stuff, most probably you wish to call [_fetch].
- */
-public fun <T> DataCommunicator<T>.fetch(offset: Int, limit: Int): List<T> {
-    require(limit <= _saneFetchLimit()) { "Vaadin doesn't handle fetching of many items very well unfortunately. The sane limit is ${_saneFetchLimit()} but you asked for $limit" }
-
-    // make sure the DataCommunicator is not in paged mode: https://github.com/mvysny/karibu-testing/issues/99
-    _DataCommunicator_setPagingEnabled?.invoke(this, false)
-
-    @Suppress("UNCHECKED_CAST")
-    val fetched: Stream<T> = _DataCommunicator_fetchFromProvider.invoke(this, offset, limit) as Stream<T>
-    return fetched.toList()
-}
-
-/**
- * Returns all items from this data communicator. Uses current Grid sorting.
- * Any ConfigurableFilterDataProvider will automatically apply its filters.
- *
- * This is an internal stuff, most probably you wish to call [_fetch].
- */
-public fun <T> DataCommunicator<T>.fetchAll(): List<T> = fetch(0, _saneFetchLimit())
-
-/**
- * Returns all items in given data provider. Uses current Grid sorting.
- *
- * For [TreeGrid] this returns all displayed rows; skips children of collapsed nodes.
- *
- * The Grid never sets any filters into the data provider, however any
- * ConfigurableFilterDataProvider will automatically apply its filters.
- *
- * @return the list of items.
- */
-public fun <T> Grid<T>._findAll(): List<T> = _fetch(0, _saneFetchLimit())
-
-/**
- * Returns the number of items in this data provider.
- *
- * In case of [HierarchicalDataProvider]
- * this returns the number of ALL items including all leafs.
- */
-public fun <T, F> DataProvider<T, F>._size(filter: F? = null): Int {
-    if (this is HierarchicalDataProvider<T, F>) {
-        return this._size(null, filter)
-    }
-    return size(Query(filter))
-}
-
-/**
- * Returns the number of items in this data provider, including child items.
- * The function traverses recursively until all children are found; then a total size
- * is returned. The function uses [HierarchicalDataProvider.size] mostly, but
- * also uses [HierarchicalDataProvider.fetchChildren] to discover children.
- * Only children matching [filter] are considered for recursive computation of
- * the size.
- *
- * Note that this can differ to `Grid._size()` since `Grid._size()` ignores children
- * of collapsed tree nodes.
- * @param root start with this item; defaults to null to iterate all items
- * @param filter filter to pass to [HierarchicalQuery]
- */
-@JvmOverloads
-public fun <T, F> HierarchicalDataProvider<T, F>._size(root: T? = null, filter: F? = null): Int =
-    _rowSequence(root, filter = filter).count()
-
-private val _DataCommunicator_getDataProviderSize: Method =
-    DataCommunicator::class.java.getDeclaredMethod("getDataProviderSize").apply { isAccessible = true }
-
-/**
- * Returns the number of items in this Grid.
- *
- * For [TreeGrid] this computes the number of items the [TreeGrid] is actually showing on-screen,
- * ignoring children of collapsed nodes.
- *
- * A very slow operation for [TreeGrid] since it walks through all items returned by [_rowSequence].
- *
- * If [_dataProviderSupportsSizeOp] is false, this function will fetch all the data
- * and count the result returned, which is also very slow.
- */
-public fun Grid<*>._size(): Int {
-    if (this is TreeGrid<*>) {
-        return this._size()
-    }
-    if (!_dataProviderSupportsSizeOp) {
-        return _findAll().size
-    }
-    return _DataCommunicator_getDataProviderSize.invoke(dataCommunicator) as Int
-}
-
-/**
- * Gets a [Grid.Column] of this grid by its [columnKey].
- * @throws AssertionError if no such column exists.
- */
-public fun <T> Grid<T>._getColumnByKey(columnKey: String): Grid.Column<T> = getColumnByKey(columnKey)
-        ?: throw AssertionError("${toPrettyString(this)}: No such column with key '$columnKey'; available columns: ${columns.mapNotNull { it.key }}")
-
-/**
- * Performs a click on a [ClickableRenderer] in given [Grid] cell. Only supports the following scenarios:
- * * [ClickableRenderer]
- * * [ComponentRenderer] which renders a [Button] or a [ClickNotifier].
- *
- * The `click` closure is no longer supported - please see https://github.com/mvysny/karibu-testing/issues/67 for more details.
- * @param rowIndex the row index, 0 or higher.
- * @param columnKey the column key [Grid.Column.getKey]
- * @throws AssertionError if the renderer is not [ClickableRenderer] nor [ComponentRenderer].
- */
-//public fun <T : Any> Grid<T>._clickRenderer(rowIndex: Int, columnKey: String) {
-//    checkEditableByUser()
-//    val column: Grid.Column<T> = _getColumnByKey(columnKey)
-//    val renderer: Renderer<T>? = column.renderer
-//    val item: T = _get(rowIndex)
-//    if (renderer is ClickableRenderer<*>) {
-//        @Suppress("UNCHECKED_CAST")
-//        (renderer as ClickableRenderer<T>).onClick(item)
-//    } else if (renderer is ComponentRenderer<*, *>) {
-//        val component: Component = (renderer as ComponentRenderer<*, T>).createComponent(item)
-//        if (component is Button) {
-//            component._click()
-//        } else if (component is ClickNotifier<*>) {
-//            component._click()
-//        } else {
-//            // don't try to do anything smart here since things will break silently for the customer as they upgrade Vaadin version
-//            // https://github.com/mvysny/karibu-testing/issues/67
-//            fail("${toPrettyString(this)} column $columnKey: ComponentRenderer produced ${toPrettyString(component)} which is not a button nor a ClickNotifier - please use _getCellComponent() instead")
-//        }
-//    } else {
-//        fail("${toPrettyString(this)} column $columnKey has renderer $renderer which is not supported by this method")
-//    }
-//}
-
-/**
- * Retrieves a component produced by [ComponentRenderer] in given [Grid] cell. Fails if the
- * renderer is not a [ComponentRenderer].
- * @param rowIndex the row index, 0 or higher.
- * @param columnKey the column key [Grid.Column.getKey]
- * @throws IllegalStateException if the renderer is not [ComponentRenderer].
- */
-public fun <T : Any> Grid<T>._getCellComponent(
-    rowIndex: Int,
-    columnKey: String
-): Component {
-    val column: Grid.Column<T> = _getColumnByKey(columnKey)
-    val renderer: Renderer<T>? = column.renderer
-    if (renderer !is ComponentRenderer<*, *>) {
-        throw java.lang.IllegalArgumentException("${toPrettyString(this)} column $columnKey uses renderer $renderer but we expect a ComponentRenderer here")
-    }
-    if (renderer is NativeButtonRenderer<*>) {
-        throw java.lang.IllegalArgumentException("${toPrettyString(this)} column $columnKey uses NativeButtonRenderer which is not supported by this function")
-    }
-    val item: T = _get(rowIndex)
-    val component: Component = (renderer as ComponentRenderer<*, T>).createComponent(item)
-    return component
-}
-
-/**
- * Returns the formatted value of given column as a String. Uses [getPresentationValue]
- * and converts the result to string (even if the result is a [Component]).
- * @param rowIndex the row index, 0 or higher.
- * @param columnKey the column ID.
- */
-@Suppress("UNCHECKED_CAST")
-public fun <T : Any> Grid<T>._getFormatted(rowIndex: Int, columnKey: String): String {
-    val rowObject: T = _get(rowIndex)
-    val column: Grid.Column<T> = _getColumnByKey(columnKey)
-    return column._getFormatted(rowObject)
-}
-
-/**
- * Returns the formatted value as a String. Uses [getPresentationValue]
- * and converts the result to string (even if the result is a [Component]).
- * @param rowObject the bean
- */
-@Suppress("UNCHECKED_CAST")
-public fun <T : Any> Grid.Column<T>._getFormatted(rowObject: T): String =
-        getPresentationValue(rowObject).toString()
-
-/**
- * Returns the formatted row as a list of Strings, one for every visible column.
- * Uses [_getFormatted].
- * @param rowObject the bean
- */
-public fun <T : Any> Grid<T>._getFormattedRow(rowObject: T): List<String> =
-        columns.filter { it.isVisible }.map { it._getFormatted(rowObject) }
-
-/**
- * Returns the formatted row as a list of Strings, one for every visible column.
- * Uses [_getFormatted]. Fails if the [rowIndex] is not within the limits.
- * @param rowIndex the index of the row, 0..size-1.
- */
-public fun <T : Any> Grid<T>._getFormattedRow(rowIndex: Int): List<String> {
-    val rowObject: T = _get(rowIndex)
-    return _getFormattedRow(rowObject)
-}
-
-/**
- * Returns the formatted row as a list of Strings, one for every visible column.
- * Uses [_getFormatted]. Returns null if the [rowIndex] is not within the limits.
- * @param rowIndex the index of the row, 0-based.
- */
-public fun <T : Any> Grid<T>._getFormattedRowOrNull(rowIndex: Int): List<String>? {
-    val rowObject: T = _getOrNull(rowIndex) ?: return null
-    return _getFormattedRow(rowObject)
-}
-
-/**
- * Returns the output of renderer set for this column for given [rowObject] formatted as close as possible
- * to the client-side output, using [Grid.Column.renderer].
- */
-@Suppress("UNCHECKED_CAST")
-public fun <T : Any> Grid.Column<T>.getPresentationValue(rowObject: T): Any? {
-    val renderer: Renderer<T> = this.renderer
-    if (renderer is ColumnPathRenderer) {
-        val valueProvider: ValueProvider<T, *> = renderer.provider
-                ?: return null
-        val value: Any? = valueProvider.apply(rowObject)
-        return value.toString()
-    }
-    return _getPresentationValue(renderer, rowObject)
-}
-
-private fun <T> Grid<T>.getSortIndicator(column: Grid.Column<T>): String {
-    val so: GridSortOrder<T>? = sortOrder.firstOrNull { it.sorted == column }
-    return when {
-        so == null -> ""
-        so.direction == SortDirection.ASCENDING -> "v"
-        else -> "^"
-    }
-}
-
-/**
- * Dumps given range of [rows] of the Grid, formatting the values using the [_getFormatted] function. Does not consider header groups. The output example:
- * ```
- * --[Name]--[Age]--[Occupation]--
- * 0: John, 25, Service Worker
- * 1: Fred, 40, Supervisor
- * --and 198 more
- * ```
- */
-@JvmOverloads
-public fun <T : Any> Grid<T>._dump(rows: IntRange = 0..9): String = buildString {
-    val visibleColumns: List<Grid.Column<T>> = columns.filter { it.isVisible }
-    visibleColumns.map { "[${it.headerText}]${getSortIndicator(it)}" }.joinTo(this, prefix = "--", separator = "-", postfix = "--\n")
-    val dsIndices: IntRange
-    val displayIndices: Set<Int>
-    if (this@_dump is TreeGrid<T>) {
-        val tree: PrettyPrintTree = this@_dump._dataSourceToPrettyTree()
-        val lines = tree.print().split('\n').filterNotBlank().drop(1)
-        dsIndices = lines.indices
-        displayIndices = rows.intersect(dsIndices)
-        for (i in displayIndices) {
-            append("$i: ${lines[i]}\n")
-        }
-        val andMore = dsIndices.size - displayIndices.size
-        if (andMore > 0) {
-            append("--and $andMore more\n")
-        }
-    } else if (_dataProviderSupportsSizeOp) {
-        dsIndices = 0 until _size()
-        displayIndices = rows.intersect(dsIndices)
-        for (i in displayIndices) {
-            _getFormattedRow(i).joinTo(this, prefix = "$i: ", postfix = "\n")
-        }
-        val andMore = dsIndices.size - displayIndices.size
-        if (andMore > 0) {
-            append("--and $andMore more\n")
-        }
-    } else {
-        var rowsOutputted = 0
-        for (i in rows) {
-            val row = _getFormattedRowOrNull(i) ?: break
-            row.joinTo(this, prefix = "$i: ", postfix = "\n")
-            rowsOutputted++
-        }
-        if (rowsOutputted == rows.size) {
-            append("--and possibly more\n")
-        } else {
-            append("--\n")
-        }
-    }
-}
-
-/**
- * Asserts that this grid's provider returns given [count] of items. If not,
- * an [AssertionError] is thrown with the Grid [_dump].
- */
-public fun Grid<*>.expectRows(count: Int) {
-    val actual = _size()
-    if (actual != count) {
-        throw AssertionError("${toPrettyString(this)}: expected $count rows but got $actual\n${_dump()}")
-    }
-}
-
-/**
- * Asserts that this grid's [rowIndex] row is formatted as expected.
- * @param row the expected row formatting.
- */
-public fun Grid<*>.expectRow(rowIndex: Int, vararg row: String) {
-    val expected: List<String> = row.toList()
-    val actual: List<String> = _getFormattedRow(rowIndex)
-    if (expected != actual) {
-        throw AssertionError("${toPrettyString(this)} at $rowIndex: expected $expected but got $actual\n${_dump()}")
-    }
-}
-
-/**
- * Returns `com.vaadin.flow.component.grid.AbstractColumn`
- */
-@Suppress("ConflictingExtensionProperty")  // conflicting property is "protected"
-internal val HeaderRow.HeaderCell.column: Any
-    get() = _AbstractCell_getColumn.invoke(this)
-
-private val abstractCellClass: Class<*> = findClassOrThrow("com.vaadin.flow.component.grid.AbstractRow\$AbstractCell")
-private val abstractColumnClass: Class<*> = findClassOrThrow("com.vaadin.flow.component.grid.AbstractColumn")
-private val _AbstractCell_getColumn: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val m: Method = abstractCellClass.getDeclaredMethod("getColumn")
-    m.isAccessible = true
-    m
-}
-
-internal val <T> ColumnPathRenderer<T>.provider: ValueProvider<T, *>
-    get() = _ColumnPathRenderer_provider.get(this) as (ValueProvider<T,*>)
-
-private val _ColumnPathRenderer_provider: Field by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val f: Field = findClassOrThrow("com.vaadin.flow.component.grid.ColumnPathRenderer").getDeclaredField("provider")
-    f.isAccessible = true
-    f
-}
-
-/**
- * Returns `com.vaadin.flow.component.grid.AbstractColumn`
- */
-@Suppress("ConflictingExtensionProperty")  // conflicting property is "protected"
-private val FooterRow.FooterCell.column: Any
-    get() = _AbstractCell_getColumn.invoke(this)
-
-/**
- * Retrieves the cell for given [property]; it matches [Grid.Column.getKey] to [KProperty1.name].
- * @return the corresponding cell
- * @throws IllegalArgumentException if no such column exists.
- */
-public fun HeaderRow.getCell(property: KProperty1<*, *>): HeaderRow.HeaderCell =
-        getCell(property.name)
-
-/**
- * Retrieves the cell for given [Grid.Column.getKey].
- * @return the corresponding cell
- * @throws IllegalArgumentException if no such column exists.
- */
-public fun HeaderRow.getCell(key: String): HeaderRow.HeaderCell {
-    val cell: HeaderRow.HeaderCell? = cells.firstOrNull { (it.column as Grid.Column<*>).key == key }
-    require(cell != null) { "This grid has no property named ${key}: $cells" }
-    return cell
-}
-
-private val _AbstractColumn_getBottomLevelColumn: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val method: Method = abstractColumnClass.getDeclaredMethod("getBottomLevelColumn")
-    method.isAccessible = true
-    method
-}
-
-/**
- * Retrieves column key from the `AbstractColumn` receiver. The problem here is that receiver can be `ColumnGroup` which doesn't have
- * a key.
- */
-private val Any.columnKey: String?
-    get() {
-        abstractColumnClass.cast(this)
-        val gridColumn: Grid.Column<*> = _AbstractColumn_getBottomLevelColumn.invoke(this) as Grid.Column<*>
-        return gridColumn.key
-    }
-
-/**
- * Retrieves the cell for given [property]; it matches [Grid.Column.getKey] to [KProperty1.name].
- * @return the corresponding cell
- * @throws IllegalArgumentException if no such column exists.
- */
-public fun FooterRow.getCell(property: KProperty1<*, *>): FooterRow.FooterCell =
-        getCell(property.name)
-
-/**
- * Retrieves the cell for given [Grid.Column.getKey].
- * @return the corresponding cell
- * @throws IllegalArgumentException if no such column exists.
- */
-public fun FooterRow.getCell(key: String): FooterRow.FooterCell {
-    val cell: FooterRow.FooterCell? = cells.firstOrNull { it.column.columnKey == key }
-    require(cell != null) { "This grid has no property named ${key}: $cells" }
-    return cell
-}
-
-/**
- * Sorts given grid. Affects [_findAll], [_get] and other data-fetching functions.
- */
-public fun <T> Grid<T>.sort(vararg sortOrder: QuerySortOrder) {
-    sort(sortOrder.map { GridSortOrder(_getColumnByKey(it.sorted), it.direction) })
-}
-
-/**
- * Fires the [ItemClickEvent] event for given [rowIndex] which invokes all item click listeners registered via
- * [Grid.addItemClickListener].
- * @param button the id of the pressed mouse button (0 is the default button, see ClickEvent.getButton)
- * @param ctrlKey `true` if the control key was down when the event was fired, `false` otherwise
- * @param shiftKey `true` if the shift key was down when the event was fired, `false` otherwise
- * @param altKey `true` if the alt key was down when the event was fired, `false` otherwise
- * @param metaKey `true` if the meta key was down when the event was fired, `false` otherwise
- */
-@JvmOverloads
-public fun <T : Any> Grid<T>._clickItem(rowIndex: Int, button: Int = 0, ctrlKey: Boolean = false,
-                           shiftKey: Boolean = false, altKey: Boolean = false, metaKey: Boolean = false) {
-    _clickItem(rowIndex, null, button, ctrlKey, shiftKey, altKey, metaKey)
-}
-
-/**
- * Fires the [ItemClickEvent] event for given [rowIndex] and a [column] which invokes all item click listeners
- * registered via [Grid.addItemClickListener].
- * @param button the id of the pressed mouse button
- * @param column optional column to be clicked
- * @param ctrlKey `true` if the control key was down when the event was fired, `false` otherwise
- * @param shiftKey `true` if the shift key was down when the event was fired, `false` otherwise
- * @param altKey `true` if the alt key was down when the event was fired, `false` otherwise
- * @param metaKey `true` if the meta key was down when the event was fired, `false` otherwise
- */
-@JvmOverloads
-public fun <T : Any> Grid<T>._clickItem(rowIndex: Int, column: Grid.Column<*>?, button: Int = 1, ctrlKey: Boolean = false,
-                           shiftKey: Boolean = false, altKey: Boolean = false, metaKey: Boolean = false) {
-    checkEditableByUser(this)
-    // fire SelectionEvent if need be: https://github.com/mvysny/karibu-testing/issues/96
-    val item: T = _get(rowIndex)
-    if (selectionModel is GridSingleSelectionModel) {
-        val selectedItem: T? = selectedItems.firstOrNull()
-        if (selectedItem != item) {
-            select(item)
-        } else {
-            // clicking on a selected item will de-select it.
-            deselectAll()
-        }
-    }
-
-    // fire ItemClickEvent
-    val itemKey: String = dataCommunicator.keyMapper.key(item)
-    val internalColumnId = column?._internalId
-    val event = ItemClickEvent<T>(this, true, itemKey, internalColumnId, -1, -1, -1, -1, 1, button, ctrlKey, shiftKey, altKey, metaKey)
-    _fireEvent(this, event)
-}
-
-/**
- * Fires the [ItemClickEvent] event for given [rowIndex] and a [columnKey] which invokes all item click listeners
- * registered via [Grid.addItemClickListener].
- * @param button the id of the pressed mouse button
- * @param columnKey the key of the column to be clicked
- * @param ctrlKey `true` if the control key was down when the event was fired, `false` otherwise
- * @param shiftKey `true` if the shift key was down when the event was fired, `false` otherwise
- * @param altKey `true` if the alt key was down when the event was fired, `false` otherwise
- * @param metaKey `true` if the meta key was down when the event was fired, `false` otherwise
- */
-@JvmOverloads
-public fun <T : Any> Grid<T>._clickItem(rowIndex: Int, columnKey: String, button: Int = 1, ctrlKey: Boolean = false,
-                           shiftKey: Boolean = false, altKey: Boolean = false, metaKey: Boolean = false) {
-    _clickItem(rowIndex, _getColumnByKey(columnKey), button, ctrlKey, shiftKey, altKey, metaKey)
-}
-
-/**
- * Fires the [ItemDoubleClickEvent] event for given [rowIndex] which invokes all item click listeners registered via
- * [Grid.addItemDoubleClickListener].
- * @param button the id of the pressed mouse button
- * @param ctrlKey `true` if the control key was down when the event was fired, `false` otherwise
- * @param shiftKey `true` if the shift key was down when the event was fired, `false` otherwise
- * @param altKey `true` if the alt key was down when the event was fired, `false` otherwise
- * @param metaKey `true` if the meta key was down when the event was fired, `false` otherwise
- */
-@JvmOverloads
-public fun <T : Any> Grid<T>._doubleClickItem(rowIndex: Int, button: Int = 1, ctrlKey: Boolean = false,
-                                        shiftKey: Boolean = false, altKey: Boolean = false, metaKey: Boolean = false) {
-    checkEditableByUser(this)
-    val itemKey: String = dataCommunicator.keyMapper.key(_get(rowIndex))
-    val event = ItemDoubleClickEvent<T>(this, true, itemKey, null, -1, -1, -1, -1, 2, button, ctrlKey, shiftKey, altKey, metaKey)
-    _fireEvent(this, event)
-}
-
-/**
- * Returns a sequence which walks over all rows the [TreeGrid] is actually showing.
- * The sequence will *skip* children of collapsed nodes.
- *
- * Iterating the entire sequence is a very slow operation since it will repeatedly
- * poll [HierarchicalDataProvider] for list of children.
- *
- * Honors current grid ordering.
- */
-public fun <T> TreeGrid<T>._rowSequence(filter: SerializablePredicate<T>? = null): Sequence<T> {
-    val isExpanded: (T) -> Boolean = { item: T -> isExpanded(item) }
-    return dataProvider._rowSequence(null, isExpanded, filter)
-}
-
-/**
- * Returns a sequence which walks over all rows the [TreeGrid] is actually showing.
- * The sequence will *skip* children of collapsed nodes.
- *
- * Iterating the entire sequence is a very slow operation since it will repeatedly
- * poll [HierarchicalDataProvider] for list of children.
- *
- * Honors current grid ordering.
- * @param root start with this item; defaults to null to iterate all items
- * @param isExpanded if returns null for an item, children of that item are skipped
- * @param filter filter to pass to [HierarchicalQuery]
- */
-@JvmOverloads
-public fun <T, F> HierarchicalDataProvider<T, F>._rowSequence(root: T? = null,
-                                                       isExpanded: (T)->Boolean = { true },
-                                                       filter: F? = null): Sequence<T> {
-
-    fun getChildrenOf(item: T?): List<T> = if (item == null || isExpanded(item)) {
-        checkedFetch(HierarchicalQuery<T, F>(filter, item))
-    } else {
-        listOf<T>()
-    }
-
-    fun itemSubtreeSequence(item: T): Sequence<T> =
-            DepthFirstTreeIterator(item) { getChildrenOf(it) } .asSequence()
-
-    val roots: List<T> = getChildrenOf(root)
-    return roots.map { itemSubtreeSequence(it) } .asSequence().flatten()
-}
-
-/**
- * Returns the number of items the [TreeGrid] is actually showing. For example
- * it doesn't count in children of collapsed nodes.
- *
- * A very slow operation since it walks through all items returned by [_rowSequence].
- */
-public fun TreeGrid<*>._size(): Int = _rowSequence().count()
-
-private fun <T, F> HierarchicalDataProvider<T, F>.checkedSize(query: HierarchicalQuery<T, F>): Int {
-    if (query.parent != null && !hasChildren(query.parent)) return 0
-    val result: Int = size(query)
-    check(result >= 0) { "size($query) returned negative count: $result" }
-    return result
-}
-private fun <T, F> HierarchicalDataProvider<T, F>.checkedFetch(query: HierarchicalQuery<T, F>): List<T> = when {
-    checkedSize(query) == 0 -> listOf()
-    else -> fetchChildren(query).toList()
-}
-
-public fun <T : Any> TreeGrid<T>._dataSourceToPrettyTree(): PrettyPrintTree {
-    fun getChildrenOf(item: T?): List<T> =
-            if (item == null || isExpanded(item)) {
-                dataProvider.checkedFetch(HierarchicalQuery<T, SerializablePredicate<T>?>(null, item))
-            } else {
-                listOf<T>()
-            }
-
-    fun toPrettyTree(item: T): PrettyPrintTree {
-        val self: String = _getFormattedRow(item).joinToString(postfix = "\n")
-        val children: List<T> = getChildrenOf(item)
-        return PrettyPrintTree(self, children.map { toPrettyTree(it) } .toMutableList())
-    }
-
-    val roots: List<T> = getChildrenOf(null)
-    return PrettyPrintTree("TreeGrid", roots.map { toPrettyTree(it) } .toMutableList())
-}
-
-@Suppress("UNCHECKED_CAST")
-public fun <T> TreeGrid<T>._getRootItems(): List<T> =
-        dataProvider.fetch(HierarchicalQuery(null, null)).toList()
-
-/**
- * Expands all nodes. May invoke massive data loading.
- */
-@JvmOverloads
-public fun <T> TreeGrid<T>._expandAll(depth: Int = 100) {
-    expandRecursively(_getRootItems(), depth)
-}
-
-/**
- * Returns the data provider currently set to this [HasItems].
- */
-//public val <T> HasItems<T>.dataProvider: DataProvider<T, *>? get() = when (this) {
-//    // until https://github.com/vaadin/flow/issues/6296 is resolved
-//    is Grid<T> -> this.dataProvider
-//    is IronList<T> -> this.dataProvider
-//    is Select<T> -> this.dataProvider
-//    is ListBoxBase<*, T, *> -> this.getDataProvider()
-//    is RadioButtonGroup<T> -> this.dataProvider
-//    is CheckboxGroup<T> -> this.dataProvider
-//    is ComboBox<T> -> this.dataProvider
-//    else -> null
-//}
-
-/**
- * Returns the data provider currently set to this Component.
- *
- * Works both with Vaadin 16 and Vaadin 17: Vaadin 17 components no longer implement HasItems.
- */
-public val Component.dataProvider: DataProvider<*, *>? get() = when (this) {
-    // until https://github.com/vaadin/flow/issues/6296 is resolved
-    is Grid<*> -> this.dataProvider
-    is Select<*> -> this.dataProvider
-    is ListBoxBase<*, *, *> -> _Grid_getDataProvider.invoke(this) as DataProvider<*, *>
-    is RadioButtonGroup<*> -> _RadioButtonGroup_getDataProvider.invoke(this) as DataProvider<*, *>
-    is CheckboxGroup<*> -> _CheckboxGroup_getDataProvider.invoke(this) as DataProvider<*, *>
-    is ComboBox<*> -> this.dataProvider
-    else -> null
-}
-
-/**
- * Call this instead of [Editor.editItem] - this function makes sure that the editor opening is
- * mocked properly, calls the editor bindings, and fires the editor-open-event.
- */
-public fun <T> Editor<T>._editItem(item: T) {
-//    expect(true, "${toPrettyString(grid)} is not attached, editItem() would do nothing. Make sure the Grid is attached to an UI") {
-//        grid.isAttached()
-//    }
-    if(!grid.isAttached()) throw java.lang.IllegalStateException("Grid is not attached so can not edit")
-    editItem(item)
-    MockVaadin.clientRoundtrip()
-}
-
-//////////////
-private val _Column_getInternalId: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val m = Grid.Column::class.java.getDeclaredMethod("getInternalId")
-    m.isAccessible = true
-    m
-}
-private val _AbstractGridMultiSelectionModel_clientSelectAll: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val m = AbstractGridMultiSelectionModel::class.java.getDeclaredMethod("clientSelectAll")
-    m.isAccessible = true
-    m
-}
-private val _AbstractGridMultiSelectionModel_clientDeselectAll: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    val m = AbstractGridMultiSelectionModel::class.java.getDeclaredMethod("clientDeselectAll")
-    m.isAccessible = true
-    m
-}
-
-/**
- * The multi-select model of this Grid, ready for the "select all" checkbox code to be run on it.
- * Fails if the grid is not multi-select or if the checkbox isn't shown, since then the user has
- * no way to trigger it: both `clientSelectAll()` and `clientDeselectAll()` quietly return in
- * that case.
- */
-private fun <T> Grid<T>._selectAllCheckboxModel(action: String): GridMultiSelectionModel<T> {
-    val model = selectionModel
-    if(model !is GridMultiSelectionModel) {
-        throw IllegalStateException("$action requires multi selection mode")
-    }
-    if(!model.isSelectAllCheckboxVisible) {
-        throw IllegalStateException("$action requires the select all checkbox to be visible")
-    }
-    return model
-}
-
-/**
- * In single select clears the selection and select only given [item], for multiselect add to selection.
- */
-public fun <T: Any> Grid<T>._select(item: T) {
-    checkEditableByUser(this)
-    if(selectionModel is GridSingleSelectionModel) {
-        deselectAll()
-    }
-    // fails properly if the Grid doesn't support selection.
-    selectionModel.selectFromClient(item)
-}
-
-/**
- * Selects all items in the Grid; runs the same code as when the "select all" checkbox is checked.
- * Fails if the grid is not multi-select or the "select all" checkbox is hidden.
- */
-public fun <T> Grid<T>._selectAll() {
-    checkEditableByUser(this)
-    val model = _selectAllCheckboxModel("Select all")
-    _AbstractGridMultiSelectionModel_clientSelectAll.invoke(model)
-}
-
-/**
- * Deselects given [item]: the same code that runs when the user ctrl-clicks a selected row or
- * unchecks the row's selection checkbox in multi-select, or clicks the selected row in single select.
- *
- * The [item] must be selected; deselecting a row that isn't selected is not a gesture the user
- * has, so it fails instead of doing nothing.
- *
- * The call is ignored - just like the user's click would be - if the item is not selectable
- * ([Grid.setItemSelectableProvider]), or if the grid is single-select with
- * [GridSingleSelectionModel.isDeselectAllowed] set to false.
- */
-public fun <T: Any> Grid<T>._deselect(item: T) {
-    checkEditableByUser(this)
-    if(selectionModel !is GridNoneSelectionModel && !selectionModel.isSelected(item)) {
-        throw IllegalStateException("Can not deselect ${item}: the row is not selected")
-    }
-    // fails properly if the Grid doesn't support selection.
-    selectionModel.deselectFromClient(item)
-}
-
-/**
- * Deselects all items in the Grid; runs the same code as when the "select all" checkbox is unchecked.
- * Fails if the grid is not multi-select or the "select all" checkbox is hidden.
- *
- * This is the counterpart of [_selectAll] and behaves like the checkbox does: the whole selection
- * is dropped in one selection event, without the per-row `ClientItemToggleEvent`s the user would
- * cause by unchecking rows one by one. Call [_deselect] per row to model that instead.
- */
-public fun <T> Grid<T>._deselectAll() {
-    checkEditableByUser(this)
-    val model = _selectAllCheckboxModel("Deselect all")
-    _AbstractGridMultiSelectionModel_clientDeselectAll.invoke(model)
-}
-
-/**
- * Returns the column's Internal ID. Not related to [Grid.Column.getKey] in any way.
- * Auto-generated by the Grid. Not really useful; mostly used internally by Vaadin.
- */
-public val Grid.Column<*>._internalId: String
-    get() = _Column_getInternalId.invoke(this) as String
-
-
-private val _Grid_getDataProvider: Method =
-    Grid::class.java.getDeclaredMethod("getDataProvider").apply { isAccessible = true }
-private val _CheckboxGroup_getDataProvider: Method =
-    CheckboxGroup::class.java.getDeclaredMethod("getDataProvider").apply { isAccessible = true }
-private val _RadioButtonGroup_getDataProvider: Method =
-    RadioButtonGroup::class.java.getDeclaredMethod("getDataProvider").apply { isAccessible = true }
diff --git a/shared/src/main/kotlin/com/vaadin/browserless/component/GridSupport.kt b/shared/src/main/kotlin/com/vaadin/browserless/component/GridSupport.kt
deleted file mode 100644
index 062eaf77..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/component/GridSupport.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.component
-
-/**
- * The last Kotlin-only helpers `Grid.kt` still needs. Both go away with it in
- * the final phase of the port.
- */
-
-/**
- * Size of the [IntRange], used by the `Grid._dump()` implementation.
- */
-internal val IntRange.size: Int get() = (endInclusive + 1 - start).coerceAtLeast(0)
-
-/**
- * Removes nulls and blank strings from this iterable.
- */
-internal fun Iterable<String?>.filterNotBlank(): List<String> =
-    filterNotNull().filter { it.isNotBlank() }
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
index 363e8644..254f47b6 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
@@ -22,7 +22,7 @@
 import java.security.Principal;
 import java.util.function.UnaryOperator;
 
-import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.ApplicationContext;
 import org.springframework.security.authentication.AuthenticationTrustResolver;
@@ -53,16 +53,16 @@
  */
 public class MockSpringServlet extends SpringServlet {
 
-    @NotNull
+    @NonNull
     public final Routes routes;
-    @NotNull
+    @NonNull
     public final ApplicationContext ctx;
-    @NotNull
+    @NonNull
     public final UIFactory uiFactory;
 
-    public MockSpringServlet(@NotNull Routes routes,
+    public MockSpringServlet(@NonNull Routes routes,
 
-            @NotNull ApplicationContext ctx, @NotNull UIFactory uiFactory) {
+            @NonNull ApplicationContext ctx, @NonNull UIFactory uiFactory) {
         super(ctx, false);
         this.ctx = ctx;
         this.routes = routes;
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
index ffb95164..9bb49ec4 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
@@ -15,7 +15,7 @@
  */
 package com.vaadin.browserless.mocks;
 
-import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 import org.springframework.context.ApplicationContext;
 
 import com.vaadin.browserless.internal.UIFactory;
@@ -43,12 +43,12 @@
  * @since 1.0
  */
 public class MockSpringServletService extends SpringVaadinServletService {
-    @NotNull
+    @NonNull
     private final UIFactory uiFactory;
 
-    public MockSpringServletService(@NotNull MockSpringServlet servlet,
-            @NotNull DeploymentConfiguration deploymentConfiguration,
-            @NotNull ApplicationContext ctx, @NotNull UIFactory uiFactory) {
+    public MockSpringServletService(@NonNull MockSpringServlet servlet,
+            @NonNull DeploymentConfiguration deploymentConfiguration,
+            @NonNull ApplicationContext ctx, @NonNull UIFactory uiFactory) {
         super(servlet, deploymentConfiguration, ctx);
         this.uiFactory = uiFactory;
     }
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
index 1e5cd0d3..84dbd8c0 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
@@ -15,7 +15,7 @@
  */
 package com.vaadin.browserless.mocks;
 
-import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 
 import com.vaadin.browserless.internal.MockVaadin;
 import com.vaadin.browserless.internal.UIFactory;
@@ -40,11 +40,11 @@
  * @since 1.0
  */
 public class MockSpringVaadinSession extends VaadinSession {
-    @NotNull
+    @NonNull
     private final UIFactory uiFactory;
 
-    public MockSpringVaadinSession(@NotNull VaadinService service,
-            @NotNull UIFactory uiFactory) {
+    public MockSpringVaadinSession(@NonNull VaadinService service,
+            @NonNull UIFactory uiFactory) {
         super(service);
         this.uiFactory = uiFactory;
     }

From a8729c3b39a7844eef93768b04e5a00ae79c9762 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 18:32:56 +0000
Subject: [PATCH 07/13] refactor!: port the tests from Kotlin to JUnit 6 Java
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The last 25 Kotlin files were all test-scoped, so this removes Kotlin from
the repository entirely: `kotlin-maven-plugin`, `dynatest`, `karibu-dsl`,
`kotlin-stdlib`, Dokka and the Spotless `kotlin` block are all gone from
the build.

DynaTest's `group { … }` / `test { … }` become `@Nested` / `@Test`, and its
helpers get Java equivalents in `TestSerialization` and `TestAssertions`.
`LocatorDsl.kt` existed only so Kotlin callers could write
`_get<Button> { caption = "…" }`; the tests now call `Locator._get(clazz,
spec -> …)`, which is what a user writes anyway. `AllTests.kt` was a pure
aggregator and disappears.

Test counts are unchanged across all five suites, verified by comparing the
surefire testcase names rather than the totals.
---
 CLAUDE.md                                     |   1 -
 CONVENTIONS.md                                |   3 +-
 de-kotlin-plan.md                             |  52 +-
 guidelines/repository.md                      |   7 +-
 guidelines/testing.md                         |   2 -
 junit6/pom.xml                                |  93 ---
 .../browserless/BrowserlessBaseClassTest.java |   3 +-
 .../vaadin/browserless/TestAssertions.java    |  59 ++
 .../vaadin/browserless/TestInitListener.java  |  61 ++
 .../vaadin/browserless/TestSerialization.java |  60 ++
 .../browserless/internal/AsyncTest.java       | 204 ++++++
 .../internal/AttachedTextField.java}          |  15 +-
 .../browserless/internal/BasicUtilsTest.java  | 176 +++++
 .../internal/ComponentUtilsTest.java          | 349 ++++++++++
 .../browserless/internal/CompositeTest.java   |  56 ++
 .../internal/DepthFirstTreeIteratorTest.java  |  77 +++
 .../internal/ElementUtilsTest.java            | 167 +++++
 .../browserless/internal/LocatorTest.java     | 548 +++++++++++++++
 .../LocatorWithoutLifecycleHookTest.java      | 113 +++
 .../browserless/internal/MockVaadinTest.java  | 645 ++++++++++++++++++
 .../internal/PrettyPrintTreeTest.java         | 344 ++++++++++
 .../browserless/internal/RoutesTest.java      | 163 +++++
 .../browserless/internal/SearchSpecTest.java  | 184 +++++
 .../browserless/internal/ShortcutsTest.java   | 180 +++++
 .../internal/TestClasspathTest.java           |  44 ++
 .../browserless/internal/TestViews.java       |  65 ++
 .../browserless/mocks/MockContextTest.java    | 100 +++
 .../mocks/MockHttpSessionTest.java            | 134 ++++
 .../browserless/mocks/MockPrincipal.java}     |  26 +-
 .../browserless/mocks/MockRequestTest.java    | 168 +++++
 .../browserless/mocks/MockResponseTest.java   |  68 ++
 .../mocks/SessionAttributeMapTest.java        | 180 +++++
 .../vaadin/browserless/TestInitListener.kt    |  44 --
 .../com/vaadin/browserless/TestUtils.kt       |  64 --
 .../vaadin/browserless/internal/AllTests.kt   |  90 ---
 .../vaadin/browserless/internal/AsyncTest.kt  | 160 -----
 .../browserless/internal/BasicUtilsTest.kt    | 129 ----
 .../internal/ComponentUtilsTest.kt            | 276 --------
 .../browserless/internal/CompositeTest.kt     |  44 --
 .../internal/DepthFirstTreeIteratorTest.kt    |  54 --
 .../browserless/internal/ElementUtilsTest.kt  | 125 ----
 .../vaadin/browserless/internal/LocatorDsl.kt | 139 ----
 .../browserless/internal/LocatorTest.kt       | 430 ------------
 .../browserless/internal/MockVaadinTest.kt    | 600 ----------------
 .../internal/PrettyPrintTreeTest.kt           | 373 ----------
 .../vaadin/browserless/internal/RoutesTest.kt | 133 ----
 .../browserless/internal/SearchSpecTest.kt    | 159 -----
 .../browserless/internal/ShortcutsTest.kt     | 163 -----
 .../browserless/mocks/MockContextTest.kt      |  69 --
 .../browserless/mocks/MockHttpSessionTest.kt  | 100 ---
 .../browserless/mocks/MockRequestTest.kt      | 138 ----
 .../browserless/mocks/MockResponseTest.kt     |  50 --
 .../mocks/SessionAttributeMapTest.kt          | 128 ----
 pom.xml                                       |  42 +-
 shared/pom.xml                                |  84 +--
 .../browserless/internal/IsTemplateTest.java  |  76 +++
 .../BrowserlessLookupInitializerTest.java     | 113 +++
 .../vaadin/browserless/internal/AllTests.kt   |  59 --
 .../mocks/BrowserlessLookupInitializerTest.kt |  88 ---
 59 files changed, 4425 insertions(+), 3852 deletions(-)
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/TestAssertions.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/TestInitListener.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/TestSerialization.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/AsyncTest.java
 rename junit6/src/test/{kotlin/com/vaadin/browserless/internal/AttachedTextField.kt => java/com/vaadin/browserless/internal/AttachedTextField.java} (63%)
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/BasicUtilsTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/ComponentUtilsTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/CompositeTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/ElementUtilsTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/LocatorTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/LocatorWithoutLifecycleHookTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/PrettyPrintTreeTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/RoutesTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/SearchSpecTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/ShortcutsTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/TestClasspathTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/internal/TestViews.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/mocks/MockContextTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/mocks/MockHttpSessionTest.java
 rename junit6/src/test/{kotlin/com/vaadin/browserless/mocks/Utils.kt => java/com/vaadin/browserless/mocks/MockPrincipal.java} (53%)
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/mocks/MockRequestTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/mocks/MockResponseTest.java
 create mode 100644 junit6/src/test/java/com/vaadin/browserless/mocks/SessionAttributeMapTest.java
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/TestInitListener.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/TestUtils.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/AsyncTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/CompositeTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockContextTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockHttpSessionTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockResponseTest.kt
 delete mode 100644 junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt
 create mode 100644 shared/src/test/java/com/vaadin/browserless/internal/IsTemplateTest.java
 create mode 100644 shared/src/test/java/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.java
 delete mode 100644 shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
 delete mode 100644 shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt

diff --git a/CLAUDE.md b/CLAUDE.md
index 493f3b7d..2e208bf4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -17,7 +17,6 @@ each Vaadin component in a *tester* that drives it the way a browser would.
 
 - Java 21+, Maven (multi-module)
 - Vaadin 25 / Flow — a `provided` dependency, one fixed version per branch
-- Kotlin only in the test sources; the main sources are pure Java
 - JUnit 6 (Jupiter) for the test API and for this repository's own tests
 - An annotation processor (`locator-processor`) that generates the typed
   locator API at build time
diff --git a/CONVENTIONS.md b/CONVENTIONS.md
index 890daf50..7295bb35 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -108,8 +108,7 @@ Go through the Vaadin extension points rather than around them — fire service
 and session lifecycle events through the `VaadinService` event bus, and forward
 `Instantiator` calls to the real instantiator instead of reimplementing them.
 
-`shared` is written in Java. Kotlin survives only in the test sources; do not
-add new Kotlin files.
+This repository is written in Java; do not add Kotlin sources.
 
 See [`guidelines/architecture.md`](guidelines/architecture.md).
 
diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index ebfaeb39..0b79f80f 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -14,6 +14,9 @@ Working plan for removing Kotlin from `browserless-test`. The goal is that
 | `junit6/src/test/kotlin` | 23 | ~3,050 | DynaTest + Karibu DSL |
 | `shared/src/test/kotlin` | 2 | 144 | DynaTest |
 
+All of it is ported as of Phase 6; the table is the starting point the phases
+below work through.
+
 `spring`, `quarkus`, `junit6/src/main` and `locator-processor` are already pure
 Java, but about 48 Java files reference the Kotlin packages and 24 call sites go
 through Kotlin file facades (`LocatorKt`, `PrettyPrintTreeKt`, `GridKt`,
@@ -204,17 +207,44 @@ so the port does not turn into a module-wide Javadoc cleanup. That cleanup is
 worth doing on its own, tightening the setting back a step at a time; the other
 modules already run with doclint on.
 
-### Phase 6 — test-side Kotlin (separate decision)
-
-The 25 Kotlin test files are test-scoped, so they never reach consumers, and
-leaving them keeps the port's risk down. They also keep `kotlin-maven-plugin`,
-`dynatest` and `karibu-dsl` in the build, against `guidelines/testing.md`.
-
-Recommended: land Phases 1–5 first, then convert the ~3,200 LOC of DynaTest to
-JUnit 6 Java. `group { … }` / `test { … }` map cleanly onto `@Nested` /
-`@Test`, and `AllTests.kt` is a pure aggregator that disappears. This is the one
-phase where a mistake can silently delete coverage, so it needs a test-count
-diff rather than just a green build.
+### Phase 6 — test-side Kotlin — done
+
+The last 25 Kotlin files, all test-scoped, are now JUnit 6 Java, and the word
+Kotlin is gone from the build: no `kotlin-maven-plugin`, no `dynatest`, no
+`karibu-dsl`, no `kotlin-stdlib`, no Dokka, no `kotlin` block in Spotless. All
+five suites match the `main` baseline: shared 42, junit6 1406,
+junit6-cdi-tests 4, spring 41, quarkus 31.
+
+- `group { … }` / `test { … }` map onto `@Nested` / `@Test`; `beforeEach` and
+  `afterEach` onto `@BeforeEach` / `@AfterEach`, and a `beforeGroup` onto
+  `@BeforeAll`. `AllTests.kt` was a pure aggregator: its two standalone tests
+  became `TestClasspathTest` and the rest of it disappeared.
+- `locatorTest()` and `locatorTest2()` were two DynaTest fragments the
+  aggregator wired under different lifecycle hooks, so they became two classes:
+  `LocatorTest` (with `MyLifecycleHook` installed) and
+  `LocatorWithoutLifecycleHookTest`.
+- `LocatorDsl.kt` existed only to keep `_get<Button> { caption = "…" }` working
+  for Kotlin callers. With the tests in Java it is deleted, and they call
+  `Locator._get(clazz, spec -> …)` directly — which is also what a user writes.
+- DynaTest's helpers needed Java equivalents: `cloneBySerialization()` became
+  `TestSerialization`, `expectThrows(clazz, message) { … }` became
+  `TestAssertions.expectThrows(Class, regex, Executable)`, and `expectList(…)`
+  became a plain `assertEquals(List.of(…), …)`.
+- Karibu DSL builders (`verticalLayout { textField(…) }`) become plain Vaadin
+  constructor and `add()` calls.
+- Watch the assertions that Kotlin's loose typing hid. A `var flag = false`
+  asserted with `expect(true)` says nothing about how many times a listener
+  fired; ported to a counter asserted `== 1` it turned red, because
+  `VaadinSession.close()` detaches the UI twice.
+- Test names: DynaTest's free-text names (`"attributes"`, `"spec"`,
+  `"FailsOnNoComponents UI"`) become method names in the repository's
+  `subject_scenario_expectation` shape, which is what surefire reports.
+
+**Verification.** A green build is not enough here — a dropped `test { … }`
+block leaves no trace. Every step was checked by comparing the *multiset of
+`<testcase name="…">` values* in the surefire XML against a baseline worktree,
+not the `tests="N"` attribute, which DynaTest under-reports. 1,448 before,
+1,448 after, with all 225 renamed names pairing one-for-one.
 
 ## Breaking changes
 
diff --git a/guidelines/repository.md b/guidelines/repository.md
index ab9ad19b..61caa8de 100644
--- a/guidelines/repository.md
+++ b/guidelines/repository.md
@@ -5,11 +5,8 @@
 - **Java 21+**, **Maven** (multi-module, parent `com.vaadin:vaadin-parent`).
 - **Vaadin 25 / Flow** as a `provided` dependency, one fixed version per
   branch — see [Flow Version](flow-version.md).
-- **Kotlin** only in the test sources (`shared/src/test/kotlin`,
-  `junit6/src/test/kotlin`). The main sources are pure Java — see
-  [`de-kotlin-plan.md`](../de-kotlin-plan.md).
 - **JUnit 6 (Jupiter)** for the published test API and for this repository's
-  own tests. A few legacy Kotlin tests still use DynaTest and Karibu DSL.
+  own tests.
 - **ClassGraph** for classpath scanning (routes, testers).
 - **Spotless** with the Eclipse formatter for style; no checkstyle.
 - **maven-javadoc-plugin** for Javadoc in every module.
@@ -73,7 +70,7 @@ Formatting is applied by `mvn spotless:apply` and validated by
 `eclipse/VaadinJavaConventions.xml`, the import order in
 `eclipse/flow.importorder`, the Apache 2 license header in
 `eclipse/apache2-license-header.txt`, no wildcard imports, and a trailing
-newline. Kotlin files get the license header check only.
+newline.
 
 ## Blast radius
 
diff --git a/guidelines/testing.md b/guidelines/testing.md
index b570f33a..aa29857f 100644
--- a/guidelines/testing.md
+++ b/guidelines/testing.md
@@ -19,8 +19,6 @@ Layout inside `junit6/src/test`:
   `LocatorApiTest`, `SignalsTest`) and the shared test contracts.
 - `java/com/example/…` — views and fixtures that tests navigate to, kept out of
   the framework packages so route scanning stays predictable.
-- `kotlin/` — the remaining DynaTest/Karibu-style tests of the Kotlin internals.
-  Do not add new ones; write new tests as JUnit 6 in Java.
 
 The Spring, Quarkus and CDI integrations have their own test sources, because
 each needs a different container on the classpath. `junit6-cdi-tests` exists
diff --git a/junit6/pom.xml b/junit6/pom.xml
index 1c98959e..d93f60a4 100644
--- a/junit6/pom.xml
+++ b/junit6/pom.xml
@@ -22,68 +22,12 @@
         </resources>
 
         <plugins>
-            <!--
-                To compile projects that include Kotlin and Java source code, the Kotlin compiler should run before
-                the Java compiler.
-                That means that kotlin-maven-plugin definition must be placed before maven-compiler-plugin
-            -->
-            <plugin>
-                <groupId>org.jetbrains.kotlin</groupId>
-                <artifactId>kotlin-maven-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>compile</id>
-                        <goals>
-                            <goal>compile</goal>
-                        </goals>
-                        <configuration>
-                            <sourceDirs>
-                                <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
-                                <sourceDir>${project.basedir}/src/main/java</sourceDir>
-                            </sourceDirs>
-                        </configuration>
-                    </execution>
-                    <execution>
-                        <id>test-compile</id>
-                        <goals>
-                            <goal>test-compile</goal>
-                        </goals>
-                        <configuration>
-                            <sourceDirs>
-                                <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
-                                <sourceDir>${project.basedir}/src/test/java</sourceDir>
-                            </sourceDirs>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <executions>
-                    <!-- Replacing default-compile as it is treated specially by maven -->
-                    <execution>
-                        <id>default-compile</id>
-                        <phase>none</phase>
-                    </execution>
-                    <!-- Replacing default-testCompile as it is treated specially by maven -->
                     <execution>
                         <id>default-testCompile</id>
-                        <phase>none</phase>
-                    </execution>
-                    <execution>
-                        <id>java-compile</id>
-                        <phase>compile</phase>
-                        <goals>
-                            <goal>compile</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>java-test-compile</id>
-                        <phase>test-compile</phase>
-                        <goals>
-                            <goal>testCompile</goal>
-                        </goals>
                         <configuration>
                             <!-- End-user-style configuration: run the locator
                                  processor on junit6's own test sources, with
@@ -111,24 +55,6 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
             </plugin>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>build-helper-maven-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>add-kotlin-sources-for-source-jar</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>add-source</goal>
-                        </goals>
-                        <configuration>
-                            <sources>
-                                <source>src/main/kotlin</source>
-                            </sources>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-source-plugin</artifactId>
@@ -170,18 +96,6 @@
             <scope>provided</scope>
         </dependency>
 
-        <dependency>
-            <groupId>com.github.mvysny.dynatest</groupId>
-            <artifactId>dynatest</artifactId>
-            <version>0.25</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.github.mvysny.karibudsl</groupId>
-            <artifactId>karibu-dsl</artifactId>
-            <version>1.0.8</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>com.vaadin</groupId>
             <artifactId>browserless-test-shared</artifactId>
@@ -192,13 +106,6 @@
             <artifactId>junit-jupiter</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kotlin-stdlib</artifactId>
-            <version>${kotlin.version}</version>
-        </dependency>
-
-
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-simple</artifactId>
diff --git a/junit6/src/test/java/com/vaadin/browserless/BrowserlessBaseClassTest.java b/junit6/src/test/java/com/vaadin/browserless/BrowserlessBaseClassTest.java
index 2adc3fff..c5be209b 100644
--- a/junit6/src/test/java/com/vaadin/browserless/BrowserlessBaseClassTest.java
+++ b/junit6/src/test/java/com/vaadin/browserless/BrowserlessBaseClassTest.java
@@ -27,6 +27,7 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import com.vaadin.browserless.internal.TestViews;
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.UI;
 import com.vaadin.flow.component.geolocation.GeolocationFacadeIntegrationTest;
@@ -75,7 +76,7 @@ void extendingBaseClass_runTest_routesAreDiscovered() {
                     .map(RouteBaseData::getNavigationTarget)
                     .collect(Collectors.toSet());
             Set<Class<? extends Component>> allViews = new HashSet<>(
-                    TestRoutes.INSTANCE.getViews());
+                    TestViews.ALL_VIEWS);
             allViews.add(SingleParam.class);
             allViews.add(TemplatedParam.class);
             allViews.add(AutoLayoutView.class);
diff --git a/junit6/src/test/java/com/vaadin/browserless/TestAssertions.java b/junit6/src/test/java/com/vaadin/browserless/TestAssertions.java
new file mode 100644
index 00000000..db577563
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/TestAssertions.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless;
+
+import java.util.regex.Pattern;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Assertion helpers replacing the ones the Kotlin tests took from DynaTest.
+ */
+public final class TestAssertions {
+
+    private TestAssertions() {
+    }
+
+    /**
+     * Asserts that the given block throws an exception of the given type whose
+     * message matches the given regular expression.
+     * <p>
+     * JUnit's own {@code assertThrows} says nothing about the message, and
+     * several of these tests assert on the message precisely because it is the
+     * thing a user reads when a lookup or a usability check fails.
+     *
+     * @param clazz
+     *            the expected exception type, or a supertype of it
+     * @param expectedMessageRegex
+     *            a regular expression the message must contain a match for
+     * @param block
+     *            the code expected to throw
+     * @param <T>
+     *            the exception type
+     * @return the exception that was thrown, so a caller can assert further
+     */
+    public static <T extends Throwable> T expectThrows(Class<T> clazz,
+            String expectedMessageRegex,
+            org.junit.jupiter.api.function.Executable block) {
+        T ex = assertThrows(clazz, block);
+        String message = ex.getMessage() == null ? "" : ex.getMessage();
+        if (!Pattern.compile(expectedMessageRegex).matcher(message).find()) {
+            throw new AssertionError(clazz.getName() + " message: Expected '"
+                    + expectedMessageRegex + "' but was '" + message + "'", ex);
+        }
+        return ex;
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/TestInitListener.java b/junit6/src/test/java/com/vaadin/browserless/TestInitListener.java
new file mode 100644
index 00000000..558ffacd
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/TestInitListener.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless;
+
+import com.vaadin.flow.server.ServiceInitEvent;
+import com.vaadin.flow.server.VaadinServiceInitListener;
+
+/**
+ * This class is picked up automatically by Vaadin (since it's registered via
+ * META-INF/services). We then test elsewhere that MockVaadin-mocked env indeed
+ * picked up this init listener and executed it.
+ */
+public class TestInitListener implements VaadinServiceInitListener {
+
+    private static boolean serviceInitCalled;
+
+    private static boolean uiInitCalled;
+
+    private static boolean uiBeforeEnterCalled;
+
+    @Override
+    public void serviceInit(ServiceInitEvent event) {
+        serviceInitCalled = true;
+        event.getSource().addUIInitListener(uiInitEvent -> {
+            uiInitCalled = true;
+            uiInitEvent.getUI()
+                    .addBeforeEnterListener(e -> uiBeforeEnterCalled = true);
+        });
+    }
+
+    public static boolean isServiceInitCalled() {
+        return serviceInitCalled;
+    }
+
+    public static boolean isUiInitCalled() {
+        return uiInitCalled;
+    }
+
+    public static boolean isUiBeforeEnterCalled() {
+        return uiBeforeEnterCalled;
+    }
+
+    public static void clearInitFlags() {
+        serviceInitCalled = false;
+        uiInitCalled = false;
+        uiBeforeEnterCalled = false;
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/TestSerialization.java b/junit6/src/test/java/com/vaadin/browserless/TestSerialization.java
new file mode 100644
index 00000000..bbc2e65c
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/TestSerialization.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
+/**
+ * Serialization helpers for tests, replacing DynaTest's
+ * {@code cloneBySerialization()}.
+ */
+public final class TestSerialization {
+
+    private TestSerialization() {
+    }
+
+    /**
+     * Serializes and deserializes the given object, so that a test can assert
+     * it survives a round trip. A Vaadin session is serialized by a servlet
+     * container, so anything reachable from one has to stay serializable.
+     *
+     * @param object
+     *            the object to round-trip
+     * @param <T>
+     *            the object type
+     * @return the deserialized copy
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends Serializable> T cloneBySerialization(T object) {
+        try {
+            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+            try (ObjectOutputStream out = new ObjectOutputStream(bytes)) {
+                out.writeObject(object);
+            }
+            try (ObjectInputStream in = new ObjectInputStream(
+                    new ByteArrayInputStream(bytes.toByteArray()))) {
+                return (T) in.readObject();
+            }
+        } catch (Exception e) {
+            throw new AssertionError(
+                    "Failed to serialize " + object.getClass().getName(), e);
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/AsyncTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/AsyncTest.java
new file mode 100644
index 00000000..b0afdfb6
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/AsyncTest.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.server.Command;
+import com.vaadin.flow.server.VaadinRequest;
+import com.vaadin.flow.server.VaadinResponse;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinSession;
+
+import static com.vaadin.browserless.TestAssertions.expectThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+class AsyncTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    /**
+     * The commands scheduled by {@code UI.access()} only run when something
+     * flushes the queue, which in a browserless test is the explicit round
+     * trip. Asserting that they have <em>not</em> run before it is the point of
+     * most of these.
+     */
+    private static void assertMockedInstancesAvailable() {
+        assertNotNull(VaadinSession.getCurrent());
+        assertNotNull(VaadinService.getCurrent());
+        assertNotNull(UI.getCurrent());
+        // Request and response are never available in access() commands
+        assertNull(VaadinRequest.getCurrent());
+        assertNull(VaadinResponse.getCurrent());
+    }
+
+    @Nested
+    class FromUiThread {
+
+        @Test
+        void access_blockIsNotCalledImmediately() {
+            AtomicBoolean checkAccess = new AtomicBoolean(true);
+            UI.getCurrent().access(() -> {
+                if (checkAccess.get()) {
+                    fail("Shouldn't be called now");
+                }
+            });
+            checkAccess.set(false);
+        }
+
+        @Test
+        void accessSynchronously_blockIsCalledImmediatelyBecauseTheTestHoldsTheUiLock() {
+            AtomicBoolean called = new AtomicBoolean();
+            UI.getCurrent().accessSynchronously(() -> called.set(true));
+            assertTrue(called.get());
+        }
+
+        @Test
+        void clientRoundtrip_processesEveryQueuedAccessCall() {
+            AtomicInteger calledCount = new AtomicInteger();
+            UI.getCurrent().access(new Command() {
+                @Override
+                public void execute() {
+                    if (calledCount.get() < 4) {
+                        calledCount.incrementAndGet();
+                        UI.getCurrent().access(this);
+                    }
+                }
+            });
+            assertEquals(0, calledCount.get());
+            MockVaadin.clientRoundtrip();
+            assertEquals(4, calledCount.get());
+        }
+
+        @Test
+        void clientRoundtrip_accessCommandThrows_propagatesTheFailure() {
+            UI.getCurrent().access(() -> {
+                throw new RuntimeException("simulated");
+            });
+            expectThrows(ExecutionException.class, "simulated",
+                    () -> MockVaadin.clientRoundtrip());
+        }
+
+        @Test
+        void access_hasProperlyMockedInstances() {
+            UI.getCurrent().access(AsyncTest::assertMockedInstancesAvailable);
+            MockVaadin.clientRoundtrip();
+        }
+
+        // https://github.com/mvysny/karibu-testing/issues/80
+        @Test
+        void push_doesNothingButCanBeCalled() {
+            UI.getCurrent().push();
+            UI.getCurrent().access(() -> UI.getCurrent().push());
+            MockVaadin.clientRoundtrip();
+            UI.getCurrent().accessSynchronously(() -> UI.getCurrent().push());
+        }
+    }
+
+    @Nested
+    class FromBackgroundThread {
+
+        private ExecutorService executor;
+
+        @BeforeEach
+        void startExecutor() {
+            executor = Executors.newCachedThreadPool();
+        }
+
+        @AfterEach
+        void stopExecutor() throws InterruptedException {
+            executor.shutdown();
+            executor.awaitTermination(4, TimeUnit.SECONDS);
+        }
+
+        private void asyncAwait(Consumer<UI> block) {
+            UI ui = UI.getCurrent();
+            try {
+                executor.submit(() -> block.accept(ui)).get();
+            } catch (InterruptedException | ExecutionException e) {
+                throw new AssertionError(e);
+            }
+        }
+
+        @Test
+        void access_blockIsNotCalledImmediatelyBecauseTheTestHoldsTheUiLock() {
+            asyncAwait(ui -> {
+                AtomicBoolean checkAccess = new AtomicBoolean(true);
+                ui.access(() -> {
+                    if (checkAccess.get()) {
+                        fail("Shouldn't be called now");
+                    }
+                });
+                checkAccess.set(false);
+            });
+        }
+
+        @Test
+        void clientRoundtrip_processesEveryQueuedAccessCall() {
+            AtomicInteger calledCount = new AtomicInteger();
+            asyncAwait(ui -> ui.access(new Command() {
+                @Override
+                public void execute() {
+                    if (calledCount.get() < 4) {
+                        calledCount.incrementAndGet();
+                        UI.getCurrent().access(this);
+                    }
+                }
+            }));
+            assertEquals(0, calledCount.get());
+            MockVaadin.clientRoundtrip();
+            assertEquals(4, calledCount.get());
+        }
+
+        @Test
+        void access_hasProperlyMockedInstances() {
+            asyncAwait(
+                    ui -> ui.access(AsyncTest::assertMockedInstancesAvailable));
+            MockVaadin.clientRoundtrip();
+        }
+
+        // https://github.com/mvysny/karibu-testing/issues/80
+        @Test
+        void push_doesNothingButCanBeCalled() {
+            asyncAwait(ui -> ui.access(() -> UI.getCurrent().push()));
+            MockVaadin.clientRoundtrip();
+        }
+    }
+}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AttachedTextField.kt b/junit6/src/test/java/com/vaadin/browserless/internal/AttachedTextField.java
similarity index 63%
rename from junit6/src/test/kotlin/com/vaadin/browserless/internal/AttachedTextField.kt
rename to junit6/src/test/java/com/vaadin/browserless/internal/AttachedTextField.java
index d6a1b131..f798ecaf 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AttachedTextField.kt
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/AttachedTextField.java
@@ -13,15 +13,18 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.vaadin.browserless.internal
+package com.vaadin.browserless.internal;
 
-import com.vaadin.flow.component.textfield.TextField
+import com.vaadin.flow.component.textfield.TextField;
 
 /**
- * TextField for testing which returns that it is attached.
+ * A {@link TextField} that reports itself as attached, so a test can exercise
+ * the usability checks without building a whole UI around the field.
  */
-class AttachedTextField : TextField() {
-    override fun isAttached(): Boolean {
-        return true
+class AttachedTextField extends TextField {
+
+    @Override
+    public boolean isAttached() {
+        return true;
     }
 }
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/BasicUtilsTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/BasicUtilsTest.java
new file mode 100644
index 00000000..6f4e853b
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/BasicUtilsTest.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import tools.jackson.databind.node.ObjectNode;
+
+import com.vaadin.flow.component.ClickEvent;
+import com.vaadin.flow.component.html.Div;
+import com.vaadin.flow.component.orderedlayout.VerticalLayout;
+import com.vaadin.flow.component.textfield.TextField;
+import com.vaadin.flow.dom.DomEvent;
+import com.vaadin.flow.internal.JacksonUtils;
+
+import static com.vaadin.browserless.TestAssertions.expectThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class BasicUtilsTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Nested
+    class CheckEditableByUser {
+
+        @Test
+        void disabledField_throws() {
+            AttachedTextField tf = new AttachedTextField();
+            tf.setEnabled(false);
+            expectThrows(IllegalStateException.class,
+                    "The AttachedTextField\\[DISABLED,.*] is not enabled",
+                    () -> BasicUtils.checkEditableByUser(tf));
+        }
+
+        @Test
+        void invisibleField_throws() {
+            AttachedTextField tf = new AttachedTextField();
+            tf.setVisible(false);
+            expectThrows(IllegalStateException.class,
+                    "The AttachedTextField\\[INVIS,.*] is not effectively visible",
+                    () -> BasicUtils.checkEditableByUser(tf));
+        }
+
+        @Test
+        void detachedField_throws() {
+            expectThrows(IllegalStateException.class,
+                    "The TextField\\[.*] is not attached",
+                    () -> BasicUtils.checkEditableByUser(new TextField()));
+        }
+
+        @Test
+        void fieldInInvisibleLayout_throws() {
+            VerticalLayout layout = new VerticalLayout();
+            layout.setVisible(false);
+            TextField tf = new TextField();
+            layout.add(tf);
+            expectThrows(IllegalStateException.class,
+                    "The TextField\\[.*] is not effectively visible",
+                    () -> BasicUtils.checkEditableByUser(tf));
+        }
+
+        @Test
+        void usableField_passes() {
+            BasicUtils.checkEditableByUser(new AttachedTextField());
+        }
+    }
+
+    @Nested
+    class ExpectNotEditableByUser {
+
+        @Test
+        void disabledField_passes() {
+            AttachedTextField tf = new AttachedTextField();
+            tf.setEnabled(false);
+            BasicUtils.expectNotEditableByUser(tf);
+        }
+
+        @Test
+        void invisibleField_passes() {
+            AttachedTextField tf = new AttachedTextField();
+            tf.setVisible(false);
+            BasicUtils.expectNotEditableByUser(tf);
+        }
+
+        @Test
+        void fieldInInvisibleLayout_passes() {
+            VerticalLayout layout = new VerticalLayout();
+            layout.setVisible(false);
+            TextField tf = new TextField();
+            layout.add(tf);
+            BasicUtils.expectNotEditableByUser(tf);
+        }
+
+        @Test
+        void usableField_throws() {
+            expectThrows(AssertionError.class,
+                    "The AttachedTextField\\[.*] is editable", () -> BasicUtils
+                            .expectNotEditableByUser(new AttachedTextField()));
+        }
+    }
+
+    @Nested
+    class FireDomEvent {
+
+        @Test
+        void plainDiv_doesNotThrow() {
+            BasicUtils._fireDomEvent(new Div(), "click");
+        }
+
+        @Test
+        void domListener_isCalled() {
+            Div div = new Div();
+            AtomicReference<DomEvent> event = new AtomicReference<>();
+            div.getElement().addEventListener("click", event::set);
+            BasicUtils._fireDomEvent(div, "click");
+            assertEquals("click", event.get().getType());
+        }
+
+        @Test
+        void clickListener_receivesTheEventDataFromTheClient() {
+            Div div = new Div();
+            AtomicReference<ClickEvent<Div>> event = new AtomicReference<>();
+            div.addClickListener(event::set);
+            ObjectNode data = JacksonUtils.createObjectNode();
+            data.put("event.screenX", 20.0);
+            BasicUtils._fireDomEvent(div, "click", data);
+            assertEquals(20, event.get().getScreenX());
+            assertTrue(event.get().isFromClient());
+        }
+    }
+
+    @Test
+    void focus_attachedField_firesFocusEvent() {
+        AttachedTextField f = new AttachedTextField();
+        AtomicBoolean called = new AtomicBoolean();
+        f.addFocusListener(e -> called.set(true));
+        BasicUtils._focus(f);
+        assertTrue(called.get());
+    }
+
+    @Test
+    void blur_attachedField_firesBlurEvent() {
+        AttachedTextField f = new AttachedTextField();
+        AtomicBoolean called = new AtomicBoolean();
+        f.addBlurListener(e -> called.set(true));
+        BasicUtils._blur(f);
+        assertTrue(called.get());
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/ComponentUtilsTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/ComponentUtilsTest.java
new file mode 100644
index 00000000..7e2b1aac
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/ComponentUtilsTest.java
@@ -0,0 +1,349 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.checkbox.Checkbox;
+import com.vaadin.flow.component.formlayout.FormLayout;
+import com.vaadin.flow.component.html.Div;
+import com.vaadin.flow.component.html.Span;
+import com.vaadin.flow.component.orderedlayout.FlexLayout;
+import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
+import com.vaadin.flow.component.textfield.TextArea;
+import com.vaadin.flow.component.textfield.TextField;
+
+import static com.vaadin.browserless.TestAssertions.expectThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ComponentUtilsTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Nested
+    class RemoveFromParent {
+
+        @Test
+        void componentWithNoParent_doesNothing() {
+            Text t = new Text("foo");
+            ComponentUtils.removeFromParent(t);
+            assertNull(t.getParent().orElse(null));
+        }
+
+        @Test
+        void nestedComponent_isDetachedFromItsParent() {
+            FlexLayout fl = new FlexLayout();
+            fl.add(new Span("foo"));
+            Component label = fl.getComponentAt(0);
+            assertSame(fl, label.getParent().get());
+            ComponentUtils.removeFromParent(label);
+            assertNull(label.getParent().orElse(null));
+            assertEquals(0, fl.getComponentCount());
+        }
+
+        @Test
+        void removedComponent_canBeReattached() {
+            FlexLayout fl = new FlexLayout();
+            fl.add(new Span("foo"));
+            Component label = fl.getComponentAt(0);
+            ComponentUtils.removeFromParent(label);
+            fl.add(label);
+            assertSame(fl, label.getParent().orElse(null));
+            assertEquals(1, fl.getComponentCount());
+        }
+    }
+
+    @Test
+    void serverClick_firesTheClickListener() {
+        Button b = new Button();
+        AtomicInteger clicked = new AtomicInteger();
+        b.addClickListener(e -> clicked.incrementAndGet());
+        ComponentUtils.serverClick(b);
+        assertEquals(1, clicked.get());
+    }
+
+    @Test
+    void tooltip_setAndCleared_readBack() {
+        Button b = new Button();
+        assertNull(b.getTooltip().getText());
+        b.setTooltipText("");
+        assertEquals("", b.getTooltip().getText());
+        b.setTooltipText("foo");
+        assertEquals("foo", b.getTooltip().getText());
+        b.setTooltipText(null);
+        assertNull(b.getTooltip().getText());
+    }
+
+    @Test
+    void addContextMenuListener_doesNotThrow() {
+        ComponentUtils.addContextMenuListener(new Button(), e -> {
+        });
+    }
+
+    @Nested
+    class FindAncestor {
+
+        @Test
+        void noParent_returnsNull() {
+            assertNull(ComponentUtils.findAncestor(new Button(), c -> false));
+        }
+
+        @Test
+        void nothingAccepted_returnsNull() {
+            Button button = new Button();
+            UI.getCurrent().add(button);
+            assertNull(ComponentUtils.findAncestor(button, c -> false));
+        }
+
+        @Test
+        void acceptsTheUi_findsIt() {
+            Button button = new Button();
+            UI.getCurrent().add(button);
+            assertSame(UI.getCurrent(),
+                    ComponentUtils.findAncestor(button, c -> c instanceof UI));
+        }
+
+        @Test
+        void acceptsEverything_skipsSelfAndFindsTheParent() {
+            Button button = new Button();
+            UI.getCurrent().add(button);
+            assertSame(UI.getCurrent(),
+                    ComponentUtils.findAncestor(button, c -> true));
+        }
+    }
+
+    @Nested
+    class FindAncestorOrSelf {
+
+        @Test
+        void noParent_returnsNull() {
+            assertNull(ComponentUtils.findAncestorOrSelf(new Button(),
+                    c -> false));
+        }
+
+        @Test
+        void nothingAccepted_returnsNull() {
+            Button button = new Button();
+            UI.getCurrent().add(button);
+            assertNull(ComponentUtils.findAncestorOrSelf(button, c -> false));
+        }
+
+        @Test
+        void acceptsEverything_findsSelf() {
+            Button button = new Button();
+            UI.getCurrent().add(button);
+            assertSame(button,
+                    ComponentUtils.findAncestorOrSelf(button, c -> true));
+        }
+    }
+
+    @Test
+    void isNestedIn_onlyTrueOnceAdded() {
+        assertFalse(ComponentUtils.isNestedIn(new Button(), UI.getCurrent()));
+        Button button = new Button();
+        UI.getCurrent().add(button);
+        assertTrue(ComponentUtils.isNestedIn(button, UI.getCurrent()));
+    }
+
+    @Test
+    void isAttached_trueOnceAddedAndStillTrueForAClosedUi() {
+        assertTrue(ComponentUtils.isAttached(UI.getCurrent()));
+        assertFalse(ComponentUtils.isAttached(new Button("foo")));
+        Button button = new Button();
+        UI.getCurrent().add(button);
+        assertTrue(ComponentUtils.isAttached(button));
+        UI.getCurrent().close();
+        assertTrue(ComponentUtils.isAttached(UI.getCurrent()));
+    }
+
+    @Test
+    void insertBefore_existingChild_insertsAheadOfIt() {
+        HorizontalLayout l = new HorizontalLayout();
+        Span first = new Span("first");
+        l.addComponentAsFirst(first);
+        ComponentUtils.insertBefore(l, new Span("second"), first);
+        assertEquals("second, first", texts(l));
+        ComponentUtils.insertBefore(l, new Span("third"), first);
+        assertEquals("second, third, first", texts(l));
+    }
+
+    @Test
+    void hasChildren_reflectsWhetherAnythingIsAdded() {
+        HorizontalLayout l = new HorizontalLayout();
+        assertFalse(ComponentUtils.hasChildren(l));
+        l.addComponentAsFirst(new Span("first"));
+        assertTrue(ComponentUtils.hasChildren(l));
+        l.removeAll();
+        assertFalse(ComponentUtils.hasChildren(l));
+    }
+
+    @Nested
+    class ClassNames2 {
+
+        @Test
+        void addClassNames2_whitespaceSeparated_addsEachName() {
+            Div div = new Div();
+            ComponentUtils.addClassNames2(div, "foo  bar    baz");
+            assertTrue(div.getClassNames()
+                    .containsAll(List.of("foo", "bar", "baz")));
+        }
+
+        @Test
+        void addClassNames2_severalStrings_addsEachName() {
+            Div div = withClassNames();
+            assertTrue(div.getClassNames()
+                    .containsAll(List.of("foo", "bar", "baz", "one", "two")));
+        }
+
+        @Test
+        void setClassNames2_whitespaceSeparated_replacesTheNames() {
+            Div div = withClassNames();
+            ComponentUtils.setClassNames2(div, "  three four  ");
+            assertTrue(
+                    div.getClassNames().containsAll(List.of("three", "four")));
+        }
+
+        @Test
+        void setClassNames2_severalStrings_replacesTheNames() {
+            Div div = withClassNames();
+            ComponentUtils.setClassNames2(div, "  three ", "four  ");
+            assertTrue(
+                    div.getClassNames().containsAll(List.of("three", "four")));
+        }
+
+        @Test
+        void removeClassNames2_whitespaceSeparated_removesEachName() {
+            Div div = withClassNames();
+            ComponentUtils.removeClassNames2(div, "  bar baz  ");
+            assertTrue(div.getClassNames()
+                    .containsAll(List.of("foo", "one", "two")));
+        }
+
+        @Test
+        void removeClassNames2_severalStrings_removesEachName() {
+            Div div = withClassNames();
+            ComponentUtils.removeClassNames2(div, "  bar ", "baz  ");
+            assertTrue(div.getClassNames()
+                    .containsAll(List.of("foo", "one", "two")));
+        }
+
+        private Div withClassNames() {
+            Div div = new Div();
+            ComponentUtils.addClassNames2(div, "foo  bar    baz", "  one  two");
+            return div;
+        }
+    }
+
+    @Test
+    void placeholder_resolvedForFieldsThatHaveOneAndRefusedForOthers() {
+        TextField tf = new TextField();
+        tf.setPlaceholder("foo");
+        assertEquals("foo", ComponentUtils.placeholder(tf));
+        ComponentUtils.placeholder(tf, "");
+        assertEquals("", ComponentUtils.placeholder(tf));
+
+        TextArea ta = new TextArea();
+        ta.setPlaceholder("foo");
+        assertEquals("foo", ComponentUtils.placeholder(ta));
+        ComponentUtils.placeholder(ta, "");
+        assertEquals("", ComponentUtils.placeholder(ta));
+
+        Button b = new Button(); // doesn't support placeholder
+        assertNull(ComponentUtils.placeholder(b));
+        expectThrows(IllegalStateException.class,
+                "Button doesn't support setting placeholder",
+                () -> ComponentUtils.placeholder(b, "foo"));
+    }
+
+    @Nested
+    class Label {
+
+        @Test
+        void textField_setAndCleared_readBack() {
+            TextField c = new TextField();
+            assertEquals("", ComponentUtils.label(c));
+            ComponentUtils.label(c, "foo");
+            assertEquals("foo", ComponentUtils.label(c));
+            ComponentUtils.label(c, "");
+            assertEquals("", ComponentUtils.label(c));
+        }
+
+        @Test
+        void checkbox_setAndCleared_readBack() {
+            Checkbox c = new Checkbox();
+            assertEquals("", ComponentUtils.label(c));
+            ComponentUtils.label(c, "foo");
+            assertEquals("foo", ComponentUtils.label(c));
+            ComponentUtils.label(c, "");
+            assertEquals("", ComponentUtils.label(c));
+        }
+    }
+
+    @Test
+    void caption_resolvesToTheButtonTextTheFieldLabelAndTheFormItemLabel() {
+        Button button = new Button("foo");
+        assertEquals("foo", ComponentUtils.caption(button));
+        ComponentUtils.caption(button, "");
+        assertEquals("", ComponentUtils.caption(button));
+
+        Checkbox checkbox = new Checkbox();
+        ComponentUtils.caption(checkbox, "foo");
+        assertEquals("foo", ComponentUtils.caption(checkbox));
+        ComponentUtils.caption(checkbox, "");
+        assertEquals("", ComponentUtils.caption(checkbox));
+
+        assertEquals("", ComponentUtils.label(new FormLayout.FormItem()));
+        FormLayout fl = new FormLayout();
+        Component formItem = fl.addFormItem(new Button(), "foo");
+        assertEquals("foo", ComponentUtils.caption(formItem));
+    }
+
+    @Test
+    void caption_button_isItsText() {
+        Button c = new Button("foo");
+        assertEquals("foo", ComponentUtils.caption(c));
+        ComponentUtils.caption(c, "");
+        assertEquals("", ComponentUtils.caption(c));
+    }
+
+    private static String texts(Component parent) {
+        return parent.getChildren().map(BasicUtils::_text)
+                .collect(Collectors.joining(", "));
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/CompositeTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/CompositeTest.java
new file mode 100644
index 00000000..65654d46
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/CompositeTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.Composite;
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.component.html.Span;
+
+class CompositeTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void lookup_compositeWithVirtualChild_findsItExactlyOnce() {
+        MyComposite comp = new MyComposite();
+        Locator._expectOne(comp, Span.class,
+                spec -> spec.setText("virtual child"));
+    }
+
+    static class MyComposite extends Composite<VirtualChildComponent> {
+    }
+
+    @Tag("my-test")
+    public static class VirtualChildComponent extends Component {
+        public VirtualChildComponent() {
+            Span child = new Span("virtual child");
+            getElement().appendVirtualChild(child.getElement());
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.java
new file mode 100644
index 00000000..325deac2
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.html.Span;
+import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
+import com.vaadin.flow.component.orderedlayout.VerticalLayout;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+class DepthFirstTreeIteratorTest {
+
+    @Test
+    void iterator_nestedNodes_visitsNodeThenDescendantsThenSibling() {
+        DepthFirstTreeIterator<String> i = new DepthFirstTreeIterator<>("0",
+                s -> s.length() > 2 ? List.of()
+                        : List.of(s + "0", s + "1", s + "2"));
+        List<String> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        assertEquals(List.of("0", "00", "000", "001", "002", "01", "010", "011",
+                "012", "02", "020", "021", "022"), actual);
+    }
+
+    @Test
+    void walk_componentTree_visitsInDeclarationOrder() {
+        List<Component> expected = new ArrayList<>();
+        VerticalLayout root = new VerticalLayout();
+        expected.add(root);
+
+        Button button = new Button("Foo");
+        root.add(button);
+        expected.add(button);
+        // In Vaadin 25.1, Button also has a text node
+        button.getChildren().filter(c -> c instanceof Text).findFirst()
+                .ifPresent(expected::add);
+
+        HorizontalLayout horizontal = new HorizontalLayout();
+        root.add(horizontal);
+        expected.add(horizontal);
+        Span span = new Span();
+        horizontal.add(span);
+        expected.add(span);
+
+        VerticalLayout nested = new VerticalLayout();
+        root.add(nested);
+        expected.add(nested);
+
+        List<Component> actual = new ArrayList<>();
+        DepthFirstTreeIterator.walk(root).forEach(actual::add);
+        assertEquals(expected, actual);
+        assertSame(root, actual.get(0));
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/ElementUtilsTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/ElementUtilsTest.java
new file mode 100644
index 00000000..e3c42ec8
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/ElementUtilsTest.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.html.Div;
+import com.vaadin.flow.component.html.Paragraph;
+import com.vaadin.flow.component.html.Span;
+import com.vaadin.flow.component.textfield.TextField;
+import com.vaadin.flow.dom.DomEvent;
+import com.vaadin.flow.dom.Element;
+import com.vaadin.flow.internal.JacksonUtils;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class ElementUtilsTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void setOrRemoveAttribute_nullValue_removesTheAttribute() {
+        Element t = new Div().getElement();
+        assertNull(t.getAttribute("foo"));
+        ElementUtils.setOrRemoveAttribute(t, "foo", "bar");
+        assertEquals("bar", t.getAttribute("foo"));
+        ElementUtils.setOrRemoveAttribute(t, "foo", null);
+        assertNull(t.getAttribute("foo"));
+    }
+
+    @Nested
+    class ToggleClassName {
+
+        @Test
+        void absentClassName_isAdded() {
+            Div t = new Div();
+            ElementUtils.toggle(t.getClassNames(), "test");
+            assertEquals(Set.of("test"), t.getClassNames());
+        }
+
+        @Test
+        void presentClassName_isRemoved() {
+            Div t = new Div();
+            t.getClassNames().add("test");
+            ElementUtils.toggle(t.getClassNames(), "test");
+            assertEquals(Set.of(), t.getClassNames());
+        }
+    }
+
+    @Test
+    void insertBefore_existingChild_insertsAheadOfIt() {
+        Element l = new Div().getElement();
+        Element first = new Span("first").getElement();
+        l.appendChild(first);
+        Element second = new Span("second").getElement();
+        ElementUtils.insertBefore(l, second, first);
+        assertEquals("second, first", childTexts(l));
+        ElementUtils.insertBefore(l, new Span("third").getElement(), first);
+        assertEquals("second, third, first", childTexts(l));
+    }
+
+    @Test
+    void textRecursively2_nestedElementsAndInnerHtml_concatenatesAllText() {
+        assertEquals("foo",
+                ElementUtils.textRecursively2(new Span("foo").getElement()));
+
+        Div div = new Div();
+        div.add(new Span("foo"), new Text("bar"), new Paragraph("baz"));
+        assertEquals("foobarbaz",
+                ElementUtils.textRecursively2(div.getElement()));
+
+        Element raw = new Element("div");
+        raw.setProperty("innerHTML", "foo");
+        assertEquals("foo", ElementUtils.textRecursively2(raw));
+    }
+
+    @Nested
+    class GetVirtualChildren {
+
+        @Test
+        void noVirtualChildren_returnsEmptyList() {
+            assertEquals(List.of(),
+                    ElementUtils.getVirtualChildren(new Div().getElement()));
+            assertEquals(List.of(),
+                    ElementUtils.getVirtualChildren(new Span().getElement()));
+            Button b = new Button();
+            UI.getCurrent().add(b);
+            assertEquals(List.of(),
+                    ElementUtils.getVirtualChildren(b.getElement()));
+        }
+
+        @Test
+        void appendedVirtualChild_isReturned() {
+            Element span = new Span().getElement();
+            Div parent = new Div();
+            parent.getElement().appendVirtualChild(span);
+            assertEquals(List.of(span),
+                    ElementUtils.getVirtualChildren(parent.getElement()));
+        }
+    }
+
+    @Test
+    void getChildrenInSlot_slottedComponent_returnsIt() {
+        assertEquals(List.of(), ElementUtils
+                .getChildrenInSlot(new TextField().getElement(), "prefix"));
+
+        Div div = new Div();
+        TextField tf = new TextField();
+        tf.setPrefixComponent(div);
+        assertEquals(List.of(div.getElement()),
+                ElementUtils.getChildrenInSlot(tf.getElement(), "prefix"));
+    }
+
+    @Test
+    void clearSlot_slottedComponent_removesIt() {
+        TextField tf = new TextField();
+        tf.setPrefixComponent(new Div());
+        ElementUtils.clearSlot(tf.getElement(), "prefix");
+        assertEquals(List.of(),
+                ElementUtils.getChildrenInSlot(tf.getElement(), "prefix"));
+        assertNull(tf.getPrefixComponent());
+    }
+
+    @Test
+    void fireDomEvent_plainElement_doesNotThrow() {
+        Element element = new Div().getElement();
+        ElementUtils._fireDomEvent(element, new DomEvent(element, "click",
+                JacksonUtils.createObjectNode()));
+    }
+
+    private static String childTexts(Element parent) {
+        return parent.getChildren().map(Element::getText)
+                .collect(Collectors.joining(", "));
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/LocatorTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/LocatorTest.java
new file mode 100644
index 00000000..3877894d
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/LocatorTest.java
@@ -0,0 +1,548 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.HasComponents;
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.combobox.ComboBox;
+import com.vaadin.flow.component.html.Span;
+import com.vaadin.flow.component.orderedlayout.VerticalLayout;
+import com.vaadin.flow.component.textfield.PasswordField;
+import com.vaadin.flow.component.textfield.TextField;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Exercises {@link Locator} with a {@link TestingLifecycleHook} installed, so
+ * that every lookup can additionally be checked to have run the hook.
+ */
+class LocatorTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+        TestingLifecycleHooks.setCurrent(new MyLifecycleHook());
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestingLifecycleHooks.setCurrent(TestingLifecycleHook.DEFAULT);
+        MockVaadin.tearDown();
+    }
+
+    @Nested
+    class Get {
+
+        @Test
+        void get_noComponentMatches_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._get(new Button(), TextField.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void get_multipleComponentsMatch_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._get(nestedVerticalLayouts(UI.getCurrent()),
+                            VerticalLayout.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void get_containerItselfMatches_returnsTheContainer() {
+            Button button = new Button();
+            assertSame(button, Locator._get(button, Button.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void get_nestedComponentMatches_returnsIt() {
+            Button button = new Button();
+            assertSame(button,
+                    Locator._get(new VerticalLayout(button), Button.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void get_componentIsInvisible_fails() {
+            Button button = new Button();
+            button.setVisible(false);
+            assertThrows(AssertionError.class,
+                    () -> Locator._get(button, Button.class));
+            expectAfterLookupCalled();
+        }
+    }
+
+    @Nested
+    class Find {
+
+        @Test
+        void find_idSpec_returnsOnlyTheComponentWithThatId() {
+            Button button = new Button();
+            BasicUtils.id_(button, "foo");
+            VerticalLayout layout = new VerticalLayout(button, new Button());
+
+            assertEquals(List.of(button), Locator._find(layout, Button.class,
+                    spec -> spec.setId("foo")));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void find_componentIsInvisible_isNotReturned() {
+            Button button = new Button();
+            button.setVisible(false);
+
+            assertEquals(List.of(), Locator._find(button, Button.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void find_nestedComponents_returnsContainerAndDescendants() {
+            VerticalLayout layout = nestedVerticalLayouts(null);
+
+            assertEquals(2, Locator._find(layout, VerticalLayout.class).size());
+            expectAfterLookupCalled();
+        }
+    }
+
+    @Nested
+    class ExpectNone {
+
+        @Test
+        void expectNone_noComponentMatches_passes() {
+            Locator._expectNone(new Button(), TextField.class);
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectNone_multipleComponentsMatch_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expectNone(
+                            nestedVerticalLayouts(UI.getCurrent()),
+                            VerticalLayout.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectNone_containerItselfMatches_fails() {
+            Button button = new Button();
+            assertThrows(AssertionError.class,
+                    () -> Locator._expectNone(button, Button.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectNone_nestedComponentMatches_fails() {
+            VerticalLayout layout = new VerticalLayout(new Button());
+            assertThrows(AssertionError.class,
+                    () -> Locator._expectNone(layout, Button.class));
+            expectAfterLookupCalled();
+        }
+    }
+
+    @Test
+    void simpleUi_lookupsFindTheComponentsAUserWouldSee() {
+        VerticalLayout layout = new VerticalLayout();
+        TextField name = new TextField("Type your name here:");
+        Button button = new Button("Click Me");
+        button.addClickListener(event -> layout
+                .add(new Text("Thanks " + name.getValue() + ", it works!")));
+        layout.add(name, button);
+        UI.getCurrent().add(layout);
+
+        Locator._get(TextField.class,
+                spec -> spec.setCaption("Type your name here:"))
+                .setValue("Baron Vladimir Harkonnen");
+        expectAfterLookupCalled();
+
+        Locator._get(Button.class, spec -> spec.setCaption("Click Me")).click();
+        expectAfterLookupCalled();
+
+        assertEquals("Thanks Baron Vladimir Harkonnen, it works!", Locator._get(
+                Text.class,
+                // Since Vaadin 25.1 a Button contains a Text child
+                spec -> spec.getPredicates().add(text -> text.getParent()
+                        .filter(parent -> parent instanceof Button).isEmpty()))
+                .getText());
+        expectAfterLookupCalled();
+
+        // lookup by value
+        Locator._get(TextField.class,
+                spec -> spec.setValue("Baron Vladimir Harkonnen"));
+        expectAfterLookupCalled();
+
+        assertEquals("Thanks Baron Vladimir Harkonnen, it works!",
+                ((Text) layout.getChildren().toList().getLast()).getText());
+        assertEquals(3, layout.getComponentCount());
+    }
+
+    @Nested
+    class Matcher {
+
+        @Test
+        void id_matchesOnlyTheExactId() {
+            assertTrue(matches(new Button(), spec -> {
+            }));
+            assertFalse(matches(new Button(), spec -> spec.setId("a")));
+            assertTrue(matches(withId(new Button(), "a"), spec -> {
+            }));
+            assertTrue(matches(withId(new Button(), "a"),
+                    spec -> spec.setId("a")));
+            assertFalse(matches(withId(new Button(), "a b"),
+                    spec -> spec.setId("a")));
+            assertFalse(matches(withId(new Button(), "a"),
+                    spec -> spec.setId("a b")));
+        }
+
+        @Test
+        void caption_matchesOnlyTheExactCaption() {
+            assertTrue(matches(new Button("click me"),
+                    spec -> spec.setCaption("click me")));
+            assertTrue(matches(new TextField("name:"),
+                    spec -> spec.setCaption("name:")));
+            assertTrue(matches(new Button("click me"), spec -> {
+            }));
+            assertTrue(matches(new TextField("name:"), spec -> {
+            }));
+            assertFalse(matches(new Button("click me"),
+                    spec -> spec.setCaption("Click Me")));
+            assertFalse(matches(new TextField("name:"),
+                    spec -> spec.setCaption("Name")));
+        }
+
+        @Test
+        void placeholder_matchesOnlyTheExactPlaceholder() {
+            assertTrue(matches(new TextField("name", "the name"),
+                    spec -> spec.setPlaceholder("the name")));
+            assertTrue(matches(
+                    new PasswordField("password", "at least 6 characters"),
+                    spec -> spec.setPlaceholder("at least 6 characters")));
+            ComboBox<String> comboBox = new ComboBox<>();
+            comboBox.setPlaceholder("foo");
+            assertTrue(matches(comboBox, spec -> spec.setPlaceholder("foo")));
+            assertFalse(matches(new TextField("name", "the name"),
+                    spec -> spec.setPlaceholder("name")));
+            assertFalse(matches(
+                    new PasswordField("password", "at least 6 characters"),
+                    spec -> spec.setPlaceholder("password")));
+        }
+
+        @Test
+        void value_matchesTheComponentValue() {
+            assertTrue(matches(new TextField(null, "Mannerheim", "placeholder"),
+                    spec -> spec.setValue("Mannerheim")));
+            // "Mannerheim" is the caption here, not the value
+            assertFalse(matches(new TextField("Mannerheim"),
+                    spec -> spec.setValue("Mannerheim")));
+        }
+
+        @Test
+        void classes_matchWhenAllOfThemArePresent() {
+            assertTrue(matches(withClasses(), spec -> {
+            }));
+            assertTrue(matches(withClasses(), spec -> spec.setClasses("a")));
+            assertTrue(matches(withClasses(), spec -> spec.setClasses("b")));
+            assertTrue(matches(withClasses(), spec -> spec.setClasses("a b")));
+            assertFalse(matches(withClasses(), spec -> spec.setClasses("a c")));
+            assertFalse(matches(withClasses(), spec -> spec.setClasses("c")));
+        }
+
+        @Test
+        void withoutClasses_matchWhenNoneOfThemIsPresent() {
+            assertTrue(matches(withClasses(), spec -> {
+            }));
+            assertFalse(matches(withClasses(),
+                    spec -> spec.setWithoutClasses("a")));
+            assertFalse(matches(withClasses(),
+                    spec -> spec.setWithoutClasses("b")));
+            assertFalse(matches(withClasses(),
+                    spec -> spec.setWithoutClasses("a b")));
+            assertFalse(matches(withClasses(),
+                    spec -> spec.setWithoutClasses("a c")));
+            assertTrue(matches(withClasses(),
+                    spec -> spec.setWithoutClasses("c")));
+        }
+
+        @Test
+        void predicates_mustAllAccept() {
+            assertTrue(matches(new Button(), spec -> {
+            }));
+            assertFalse(matches(new Button(),
+                    spec -> spec.getPredicates().add(component -> false)));
+        }
+
+        @Test
+        void themes_matchWhenAllOfThemArePresent() {
+            assertTrue(matches(withThemes(), spec -> {
+            }));
+            assertTrue(matches(withThemes(),
+                    spec -> spec.setThemes("custom-theme")));
+            assertTrue(
+                    matches(withThemes(), spec -> spec.setThemes("my-theme")));
+            assertTrue(matches(withThemes(),
+                    spec -> spec.setThemes("custom-theme my-theme")));
+            assertFalse(
+                    matches(withThemes(), spec -> spec.setThemes("no-theme")));
+        }
+
+        @Test
+        void withoutThemes_matchWhenNoneOfThemIsPresent() {
+            assertTrue(matches(withThemes(), spec -> {
+            }));
+            assertFalse(matches(withThemes(),
+                    spec -> spec.setWithoutThemes("custom-theme")));
+            assertFalse(matches(withThemes(),
+                    spec -> spec.setWithoutThemes("my-theme")));
+            assertFalse(matches(withThemes(),
+                    spec -> spec.setWithoutThemes("custom-theme my-theme")));
+            assertTrue(matches(withThemes(),
+                    spec -> spec.setWithoutThemes("no-theme")));
+        }
+
+        private Button withClasses() {
+            Button button = new Button();
+            button.addClassNames("a", "b");
+            return button;
+        }
+
+        private Button withThemes() {
+            Button button = new Button();
+            button.addThemeNames("custom-theme", "my-theme");
+            return button;
+        }
+
+        private Button withId(Button button, String id) {
+            BasicUtils.id_(button, id);
+            return button;
+        }
+
+        /**
+         * Checks whether the component matches the given spec. All rules are
+         * matched except the count rule, and only against the component itself,
+         * not against its children.
+         */
+        private boolean matches(Component component,
+                Consumer<SearchSpec<Component>> block) {
+            SearchSpec<Component> spec = new SearchSpec<>(Component.class);
+            block.accept(spec);
+            return spec.toPredicate().test(component);
+        }
+    }
+
+    @Nested
+    class UnmockedEnvironment {
+
+        @BeforeEach
+        void unmock() {
+            MockVaadin.tearDown();
+            TestingLifecycleHooks.setCurrent(TestingLifecycleHook.DEFAULT);
+        }
+
+        @Test
+        void get_noMockedEnvironment_stillLooksUpComponents() {
+            Locator._get(new Button(), Button.class);
+            assertThrows(AssertionError.class,
+                    () -> Locator._get(new Button(), TextField.class));
+        }
+    }
+
+    @Nested
+    class ExpectOne {
+
+        @Test
+        void expectOne_uiHasNoMatchingComponent_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expectOne(Button.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectOne_containerHasNoMatchingComponent_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expectOne(new Button(), Span.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectOne_multipleComponentsMatch_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expectOne(
+                            nestedVerticalLayouts(UI.getCurrent()),
+                            VerticalLayout.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectOne_containerItselfMatches_passes() {
+            Locator._expectOne(new Button(), Button.class);
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectOne_nestedComponentMatches_passes() {
+            Locator._expectOne(new VerticalLayout(new Button()), Button.class);
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expectOne_specDoesNotMatch_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expectOne(new Button("foo"), Button.class,
+                            spec -> spec.setCaption("bar")));
+            expectAfterLookupCalled();
+        }
+    }
+
+    @Nested
+    class Expect {
+
+        @Test
+        void expect_uiHasNoMatchingComponent_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expect(Span.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expect_containerHasNoMatchingComponent_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expect(new Button(), Span.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expect_zeroExpectedAndNoneMatch_passes() {
+            Locator._expect(Span.class, 0);
+            expectAfterLookupCalled();
+            Locator._expect(new Button(), Span.class, 0);
+        }
+
+        @Test
+        void expect_countIsWrong_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expect(
+                            nestedVerticalLayouts(UI.getCurrent()),
+                            VerticalLayout.class));
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expect_countIsRight_passes() {
+            Locator._expect(nestedVerticalLayouts(UI.getCurrent()),
+                    VerticalLayout.class, 2);
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expect_containerItselfMatches_passes() {
+            Locator._expect(new Button(), Button.class, 1);
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expect_nestedComponentMatches_passes() {
+            Locator._expect(new VerticalLayout(new Button()), Button.class, 1);
+            expectAfterLookupCalled();
+        }
+
+        @Test
+        void expect_specDoesNotMatch_fails() {
+            assertThrows(AssertionError.class,
+                    () -> Locator._expect(new Button("foo"), Button.class, 1,
+                            spec -> spec.setCaption("bar")));
+            expectAfterLookupCalled();
+        }
+    }
+
+    /**
+     * Builds a {@link VerticalLayout} holding another one, optionally attaching
+     * it to the given parent.
+     */
+    private static VerticalLayout nestedVerticalLayouts(HasComponents parent) {
+        VerticalLayout outer = new VerticalLayout();
+        outer.add(new VerticalLayout());
+        if (parent != null) {
+            parent.add(outer);
+        }
+        return outer;
+    }
+
+    /**
+     * Asserts that the last lookup ran both halves of the lifecycle hook, then
+     * installs a fresh hook for the next lookup.
+     */
+    private static void expectAfterLookupCalled() {
+        MyLifecycleHook hook = (MyLifecycleHook) TestingLifecycleHooks
+                .getCurrent();
+        assertTrue(hook.beforeLookupCalled,
+                "awaitBeforeLookup() has not been called");
+        assertTrue(hook.afterLookupCalled,
+                "awaitAfterLookup() has not been called");
+        TestingLifecycleHooks.setCurrent(new MyLifecycleHook());
+    }
+
+    /**
+     * A hook that records whether it has been called, and fails loudly when a
+     * lookup calls it out of order or twice.
+     */
+    private static class MyLifecycleHook implements TestingLifecycleHook {
+
+        private boolean beforeLookupCalled;
+
+        private boolean afterLookupCalled;
+
+        @Override
+        public void awaitBeforeLookup() {
+            if (beforeLookupCalled) {
+                throw new IllegalStateException(
+                        "awaitBeforeLookup() has been already called");
+            }
+            if (afterLookupCalled) {
+                throw new IllegalStateException(
+                        "awaitAfterLookup() has been already called");
+            }
+            beforeLookupCalled = true;
+        }
+
+        @Override
+        public void awaitAfterLookup() {
+            if (!beforeLookupCalled) {
+                throw new IllegalStateException(
+                        "awaitBeforeLookup() has not yet been called");
+            }
+            if (afterLookupCalled) {
+                throw new IllegalStateException(
+                        "awaitAfterLookup() has been already called");
+            }
+            afterLookupCalled = true;
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/LocatorWithoutLifecycleHookTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/LocatorWithoutLifecycleHookTest.java
new file mode 100644
index 00000000..47cbf8d5
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/LocatorWithoutLifecycleHookTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.regex.Pattern;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.dialog.Dialog;
+
+import static com.vaadin.browserless.TestAssertions.expectThrows;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Exercises the {@link Locator} assertions that don't need a
+ * {@link TestingLifecycleHook} of their own, so they run against the default
+ * hook a user would get.
+ */
+class LocatorWithoutLifecycleHookTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void expectNoDialogs_aDialogIsOpen_failsWithTheComponentTree() {
+        Locator._expectNoDialogs(); // succeeds when there are no dialogs
+
+        Dialog dialog = new Dialog();
+        dialog.open();
+        AssertionError exception = assertThrows(AssertionError.class,
+                Locator::_expectNoDialogs);
+        String expected = ".*Too many visible Dialogs \\(1\\) in MockedUI\\[] "
+                + "matching Dialog and count=0\\.\\.0: \\[Dialog\\[.*]]\\. Component tree:\n"
+                + "└── MockedUI\\[]\n" + "\\s+└── Dialog\\[.*].*\n";
+        assertTrue(
+                Pattern.compile(expected, Pattern.MULTILINE)
+                        .matcher(exception.getMessage()).matches(),
+                "Unexpected failure message: " + exception.getMessage());
+
+        dialog.close();
+        Locator._expectNoDialogs();
+    }
+
+    @Nested
+    class InternalServerErrorHandling {
+
+        @Test
+        void expectOne_navigationFailed_failsFastOnTheInternalServerError() {
+            // Vaadin shows InternalServerError when an exception occurs during
+            // the navigation phase. The _expect*() functions should detect this
+            // and fail fast.
+            rerouteToError();
+
+            expectThrows(AssertionError.class, Pattern.quote(
+                    "An internal server error occurred; please check log for the actual stack-trace. Error text: There was an exception while trying to navigate to"),
+                    () -> Locator._expectOne(UI.class));
+        }
+
+        @Test
+        void expectInternalServerError_noErrorHappened_fails() {
+            expectThrows(AssertionError.class, Pattern.quote(
+                    "Expected an internal server error but none happened. Component tree:\n"
+                            + "└── MockedUI[]"),
+                    Locator::_expectInternalServerError);
+        }
+
+        @Test
+        void expectInternalServerError_navigationFailed_passes() {
+            rerouteToError();
+
+            Locator._expectInternalServerError();
+        }
+
+        @Test
+        void expectInternalServerError_expectedMessageMatches_passes() {
+            rerouteToError();
+
+            Locator._expectInternalServerError("Simulated");
+        }
+
+        private void rerouteToError() {
+            Utils.currentUI()
+                    .addBeforeEnterListener(event -> event.rerouteToError(
+                            new RuntimeException("Simulated"), "Simulated"));
+            UI.getCurrent().navigate("");
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java
new file mode 100644
index 00000000..b30c3919
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java
@@ -0,0 +1,645 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import jakarta.servlet.http.Cookie;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import com.example.base.HelloWorldView;
+import com.example.base.ParametrizedView;
+import com.example.base.child.ChildView;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.browserless.TestInitListener;
+import com.vaadin.browserless.mocks.MockService;
+import com.vaadin.browserless.mocks.MockVaadinServlet;
+import com.vaadin.browserless.mocks.MockVaadinSession;
+import com.vaadin.browserless.mocks.MockedUI;
+import com.vaadin.flow.component.AttachEvent;
+import com.vaadin.flow.component.DetachEvent;
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.dialog.Dialog;
+import com.vaadin.flow.component.html.Div;
+import com.vaadin.flow.component.orderedlayout.VerticalLayout;
+import com.vaadin.flow.function.DeploymentConfiguration;
+import com.vaadin.flow.router.RouteConfiguration;
+import com.vaadin.flow.server.ServiceException;
+import com.vaadin.flow.server.VaadinRequest;
+import com.vaadin.flow.server.VaadinResponse;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinServlet;
+import com.vaadin.flow.server.VaadinServletRequest;
+import com.vaadin.flow.server.VaadinServletService;
+import com.vaadin.flow.server.VaadinSession;
+
+import static com.vaadin.browserless.TestAssertions.expectThrows;
+import static com.vaadin.browserless.TestSerialization.cloneBySerialization;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MockVaadinTest {
+
+    private static final String WELCOME_TREE = """
+            └── MockedUI[]
+                └── WelcomeView[@theme='spacing padding']
+                    └── Text[text='Welcome!']""";
+
+    private static Routes routes;
+
+    @BeforeAll
+    static void discoverViews() {
+        routes = new Routes().autoDiscoverViews("com.example.base");
+    }
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup(routes);
+        expectWelcomeTree();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Nested
+    class SetupAndTearDown {
+
+        @Test
+        void setup_mocksAllTheVaadinCurrentInstances() {
+            assertNotNull(UI.getCurrent());
+            assertNotNull(VaadinSession.getCurrent());
+            assertNotNull(VaadinService.getCurrent());
+            assertNotNull(VaadinRequest.getCurrent());
+            assertNotNull(VaadinResponse.getCurrent());
+            assertNotNull(VaadinSession.getCurrent().getConfiguration());
+            assertNotNull(VaadinSession.getCurrent().getService());
+            assertNotNull(VaadinSession.getCurrent().getBrowser());
+            assertNotNull(VaadinSession.getCurrent().getBrowser().getLocale());
+            assertFalse(VaadinSession.getCurrent().getBrowser().isIPhone());
+            assertTrue(VaadinSession.getCurrent().getBrowser().isFirefox());
+            assertFalse(VaadinSession.getCurrent().getBrowser().isChrome());
+            assertFalse(VaadinSession.getCurrent().getBrowser().isChromeOS());
+            assertFalse(VaadinSession.getCurrent().getBrowser().isAndroid());
+            assertFalse(VaadinSession.getCurrent().getBrowser().isEdge());
+        }
+
+        @Test
+        void setup_currentUiHasSaneValues() {
+            assertNotNull(UI.getCurrent().getLocale());
+            assertNotNull(UI.getCurrent().getElement());
+            assertNotNull(UI.getCurrent().getSession());
+            assertSame(VaadinSession.getCurrent(),
+                    UI.getCurrent().getSession());
+            assertNotNull(UI.getCurrent().getSession().getSession());
+            assertNotNull(UI.getCurrent().getLoadingIndicatorConfiguration());
+            assertNotNull(UI.getCurrent().getPushConfiguration());
+            assertNotNull(UI.getCurrent().getReconnectDialogConfiguration());
+            assertNotNull(UI.getCurrent().getInternals());
+            assertNotNull(UI.getCurrent().getPage());
+            assertNotNull(UI.getCurrent().getInternals().getRouter());
+        }
+
+        @Test
+        void setup_uiAndSessionSurviveSerialization() {
+            cloneBySerialization(UI.getCurrent());
+            cloneBySerialization(VaadinSession.getCurrent());
+            // even though they say they are Serializable, VaadinService,
+            // VaadinRequest and VaadinResponse really are not.
+        }
+
+        @Test
+        void setup_calledTwiceInARow_succeeds() {
+            MockVaadin.setup();
+            MockVaadin.setup();
+        }
+
+        @Test
+        void setup_calledAgain_createsANewUi() {
+            MockVaadin.setup();
+            UI ui = UI.getCurrent();
+            MockVaadin.setup();
+            assertNotSame(ui, UI.getCurrent());
+        }
+
+        @Test
+        void tearDown_clearsAllTheVaadinCurrentInstances() {
+            MockVaadin.tearDown();
+            assertNull(VaadinSession.getCurrent());
+            assertNull(VaadinService.getCurrent());
+            assertNull(VaadinRequest.getCurrent());
+            assertNull(VaadinResponse.getCurrent());
+            assertNull(UI.getCurrent());
+        }
+
+        @Test
+        void tearDown_calledRepeatedly_succeeds() {
+            MockVaadin.tearDown();
+            MockVaadin.tearDown();
+            MockVaadin.tearDown();
+        }
+
+        @Test
+        void tearDown_callsUiDetachListenersExactlyOnce() {
+            UI ui = UI.getCurrent();
+            ui.add(new VerticalLayout());
+            AtomicInteger firstListenerCalls = new AtomicInteger();
+            ui.addDetachListener(event -> assertEquals(1,
+                    firstListenerCalls.incrementAndGet(),
+                    "detach should be called only once"));
+            AtomicInteger secondListenerCalls = new AtomicInteger();
+            UI.getCurrent()
+                    .addDetachListener(event -> assertEquals(1,
+                            secondListenerCalls.incrementAndGet(),
+                            "detach should be called only once"));
+
+            MockVaadin.tearDown();
+
+            assertEquals(1, firstListenerCalls.get(),
+                    "detach should be called exactly once");
+            assertEquals(1, secondListenerCalls.get(),
+                    "detach should be called exactly once");
+        }
+    }
+
+    @Nested
+    class ProperMocking {
+
+        @Test
+        void configuration_isNotInProductionMode() {
+            assertFalse(VaadinSession.getCurrent().getConfiguration()
+                    .isProductionMode());
+        }
+
+        @Test
+        void attachAndDetach_callBothTheOverridesAndTheListeners() {
+            AtomicInteger attachCallCount = new AtomicInteger();
+            AtomicInteger detachCallCount = new AtomicInteger();
+            VerticalLayout vl = new VerticalLayout() {
+                @Override
+                protected void onAttach(AttachEvent attachEvent) {
+                    super.onAttach(attachEvent);
+                    attachCallCount.incrementAndGet();
+                }
+
+                @Override
+                protected void onDetach(DetachEvent detachEvent) {
+                    super.onDetach(detachEvent);
+                    detachCallCount.incrementAndGet();
+                }
+            };
+            vl.addAttachListener(event -> {
+                assertTrue(vl.isAttached());
+                attachCallCount.incrementAndGet();
+            });
+            vl.addDetachListener(event -> {
+                // a bug in Vaadin? I'd expect the node to be detached (null
+                // parent etc) at this point...
+                // See https://github.com/vaadin/flow/issues/8809
+                assertTrue(vl.isAttached());
+                detachCallCount.incrementAndGet();
+            });
+
+            // attach
+            UI.getCurrent().add(vl);
+            assertEquals(2, attachCallCount.get());
+            assertTrue(vl.isAttached());
+            assertEquals(0, detachCallCount.get());
+
+            // close UI - detach is not called.
+            UI.getCurrent().close();
+            assertEquals(2, attachCallCount.get());
+            assertTrue(vl.isAttached());
+            assertEquals(0, detachCallCount.get());
+
+            // detach
+            vl.removeFromParent();
+            assertEquals(2, attachCallCount.get());
+            assertFalse(vl.isAttached());
+            assertEquals(2, detachCallCount.get());
+        }
+
+        @Test
+        void closeUi_detachHappensOnlyWhenTheRequestIsDone() {
+            UI ui = UI.getCurrent();
+            ui.add(new VerticalLayout());
+            AtomicInteger detachCalled = new AtomicInteger();
+            ui.addDetachListener(event -> detachCalled.incrementAndGet());
+            assertTrue(ui.isAttached());
+
+            // close UI - detach is not called.
+            UI.getCurrent().close();
+            assertTrue(ui.isAttached());
+            assertEquals(0, detachCalled.get());
+            assertTrue(UI.getCurrent().isAttached());
+
+            // Mock closing of UI after request handled
+            BasicUtils._close(UI.getCurrent());
+            assertFalse(ui.isAttached());
+            assertEquals(1, detachCalled.get());
+            assertFalse(UI.getCurrent().isAttached());
+        }
+
+        @Test
+        void routeConfiguration_resolvesTheUrlsOfTheDiscoveredViews() {
+            RouteConfiguration routeConfig = RouteConfiguration.forRegistry(
+                    UI.getCurrent().getInternals().getRouter().getRegistry());
+            assertEquals("helloworld",
+                    routeConfig.getUrl(HelloWorldView.class));
+            assertEquals("params/1",
+                    routeConfig.getUrl(ParametrizedView.class, 1));
+            assertEquals("parent/child", routeConfig.getUrl(ChildView.class));
+
+            RouteConfiguration applicationScope = RouteConfiguration
+                    .forApplicationScope();
+            assertEquals("helloworld",
+                    applicationScope.getUrl(HelloWorldView.class));
+            assertEquals("params/1",
+                    applicationScope.getUrl(ParametrizedView.class, 1));
+            assertEquals("parent/child",
+                    applicationScope.getUrl(ChildView.class));
+        }
+    }
+
+    @Nested
+    class Dialogs {
+
+        @Test
+        void cleanupDialogs_closedDialog_isRemovedFromTheComponentTree() {
+            Dialog dialog = new Dialog(new Div(new Text("Dialog Text")));
+            dialog.open();
+            dialog.close();
+
+            TestingLifecycleHooks.cleanupDialogs();
+
+            expectWelcomeTree();
+        }
+    }
+
+    @Nested
+    class PageReloading {
+
+        @Test
+        void reload_recreatesTheUi() {
+            UI ui = UI.getCurrent();
+            AtomicInteger detachCalled = new AtomicInteger();
+            ui.addDetachListener(
+                    event -> assertEquals(1, detachCalled.incrementAndGet(),
+                            "detach should be called only once"));
+
+            UI.getCurrent().getPage().reload();
+
+            // a new UI must be created; but the Session must stay the same.
+            assertNotNull(UI.getCurrent());
+            assertNotSame(ui, UI.getCurrent());
+            // the old UI must be detached properly
+            assertEquals(1, detachCalled.get());
+        }
+
+        @Test
+        void reload_preservesTheSession() {
+            VaadinSession session = VaadinSession.getCurrent();
+            session.setAttribute("foo", "bar");
+
+            UI.getCurrent().getPage().reload();
+
+            assertSame(session, VaadinSession.getCurrent());
+            assertEquals("bar", VaadinSession.getCurrent().getAttribute("foo"));
+        }
+    }
+
+    @Test
+    void sessionClose_recreatesTheSessionAndTheUi() {
+        UI ui = UI.getCurrent();
+        AtomicBoolean detachCalled = new AtomicBoolean();
+        ui.addDetachListener(event -> detachCalled.set(true));
+        VaadinSession session = VaadinSession.getCurrent();
+        session.setAttribute("foo", "bar");
+
+        session.close();
+
+        // a new UI+Session must be created
+        assertNotNull(UI.getCurrent());
+        assertNotNull(VaadinSession.getCurrent());
+        assertNotSame(ui, UI.getCurrent());
+        assertNotSame(session, VaadinSession.getCurrent());
+        // the old UI must be detached properly
+        assertTrue(detachCalled.get());
+        // the new session must not inherit attributes from the old one
+        assertNull(VaadinSession.getCurrent().getAttribute("foo"));
+    }
+
+    @Test
+    void setup_reusingAUiInstance_failsWithHelpfulMessage() {
+        MockedUI ui = new MockedUI();
+        MockVaadin.setup(() -> ui);
+
+        expectThrows(IllegalArgumentException.class,
+                "which is already attached to a Session",
+                () -> MockVaadin.setup(() -> ui));
+    }
+
+    @Nested
+    class InitListeners {
+
+        @BeforeEach
+        void restartWithClearFlags() {
+            MockVaadin.tearDown();
+            TestInitListener.clearInitFlags();
+            MockVaadin.setup(routes);
+        }
+
+        @Test
+        void initListeners_areInvokedOnSetup() {
+            assertTrue(TestInitListener.isServiceInitCalled());
+            assertTrue(TestInitListener.isUiInitCalled());
+            assertTrue(TestInitListener.isUiBeforeEnterCalled());
+        }
+    }
+
+    @Nested
+    class Request {
+
+        @Test
+        void cookies_addedToTheRequest_areVisibleOnTheCurrentRequest() {
+            Utils.mock(Utils.currentRequest())
+                    .addCookie(new Cookie("foo", "bar"));
+
+            assertEquals(List.of("bar"),
+                    Arrays.stream(Utils.currentRequest().getCookies())
+                            .map(Cookie::getValue).toList());
+        }
+    }
+
+    @Nested
+    class Response {
+
+        @Test
+        void cookies_addedToTheResponse_areRecordedOnTheMockResponse() {
+            Utils.currentResponse().addCookie(new Cookie("foo", "bar"));
+
+            assertEquals("bar", Utils.mock(Utils.currentResponse())
+                    .getCookie("foo").getValue());
+        }
+
+        @Test
+        void cookies_addedBeforeUiInit_areVisibleFromUiInit() {
+            MockVaadin.tearDown();
+            AtomicInteger initCalled = new AtomicInteger();
+            MockVaadin.setup(() -> {
+                Utils.mock(Utils.currentRequest())
+                        .addCookie(new Cookie("foo", "bar"));
+                return new UI() {
+                    @Override
+                    protected void init(VaadinRequest request) {
+                        assertEquals(List.of("bar"), Arrays
+                                .stream(Utils.currentRequest().getCookies())
+                                .map(Cookie::getValue).toList());
+                        initCalled.incrementAndGet();
+                    }
+                };
+            });
+
+            assertEquals(1, initCalled.get());
+        }
+    }
+
+    @Nested
+    class Session {
+
+        @Test
+        void attributes_setOnTheHttpSession_areReadableThroughTheMock() {
+            VaadinSession.getCurrent().getSession().setAttribute("foo", "bar");
+
+            assertEquals("bar",
+                    Utils.mock(VaadinSession.getCurrent()).getAttribute("foo"));
+        }
+
+        @Test
+        void changeSessionId_keepsTheVaadinSessionAndItsAttributes() {
+            // How an app without Spring Security protects against session
+            // fixation after a successful login. Unlike reinitializeSession()
+            // the very same HttpSession is kept and only its ID changes, so
+            // the VaadinSession bound to it survives.
+            VaadinSession session = VaadinSession.getCurrent();
+            String id = session.getSession().getId();
+            session.getSession().setAttribute("foo", "bar");
+            String vaadinSessionAttribute = VaadinSession.class.getName() + "."
+                    + VaadinService.getCurrent().getServiceName();
+
+            VaadinServletRequest request = (VaadinServletRequest) VaadinService
+                    .getCurrentRequest();
+            String newId = request.getHttpServletRequest().changeSessionId();
+
+            assertNotEquals(id, newId);
+            assertEquals(newId, session.getSession().getId());
+            assertEquals("bar", session.getSession().getAttribute("foo"));
+            assertSame(session,
+                    session.getSession().getAttribute(vaadinSessionAttribute));
+            assertTrue(session.hasLock());
+        }
+
+        @Test
+        void reinitializeSession_newHttpSessionIdButAttributesArePreserved() {
+            String id = VaadinSession.getCurrent().getSession().getId();
+            VaadinSession.getCurrent().getSession().setAttribute("foo", "bar");
+            assertTrue(VaadinSession.getCurrent().hasLock());
+
+            VaadinService.reinitializeSession(VaadinRequest.getCurrent());
+
+            assertEquals("bar", VaadinSession.getCurrent().getSession()
+                    .getAttribute("foo"));
+            assertNotEquals(id,
+                    VaadinSession.getCurrent().getSession().getId());
+            assertTrue(VaadinSession.getCurrent().hasLock());
+
+            id = VaadinSession.getCurrent().getSession().getId();
+            // reinitialize again
+            VaadinService.reinitializeSession(VaadinRequest.getCurrent());
+
+            assertEquals("bar", VaadinSession.getCurrent().getSession()
+                    .getAttribute("foo"));
+            assertNotEquals(id,
+                    VaadinSession.getCurrent().getSession().getId());
+            assertTrue(VaadinSession.getCurrent().hasLock());
+        }
+    }
+
+    @Nested
+    class MultipleThreads {
+
+        @Test
+        void setup_inSeparateThreads_createsSeparateUisAndSessions()
+                throws InterruptedException {
+            AtomicReference<UI> firstUi = new AtomicReference<>();
+            AtomicReference<VaadinSession> firstSession = new AtomicReference<>();
+            newVaadinThread(firstUi, firstSession);
+            AtomicReference<UI> secondUi = new AtomicReference<>();
+            AtomicReference<VaadinSession> secondSession = new AtomicReference<>();
+            newVaadinThread(secondUi, secondSession);
+
+            assertNotSame(firstUi.get(), secondUi.get());
+            assertNotSame(firstSession.get(), secondSession.get());
+        }
+
+        private void newVaadinThread(AtomicReference<UI> ui,
+                AtomicReference<VaadinSession> session)
+                throws InterruptedException {
+            Thread thread = new Thread(() -> {
+                MockVaadin.setup();
+                ui.set(UI.getCurrent());
+                session.set(VaadinSession.getCurrent());
+            });
+            thread.start();
+            thread.join();
+            assertNotNull(ui.get());
+            assertNotNull(session.get());
+        }
+    }
+
+    @Nested
+    class CustomVaadinService {
+
+        @Test
+        void setup_customVaadinService_isTheCurrentService() {
+            MockVaadin.tearDown();
+            MockVaadin.setup(new MockVaadinServlet(routes) {
+                @Override
+                protected VaadinServletService createServletService(
+                        DeploymentConfiguration deploymentConfiguration)
+                        throws ServiceException {
+                    VaadinServletService service = new MyMockService(this,
+                            deploymentConfiguration);
+                    service.init();
+                    return service;
+                }
+            });
+
+            assertEquals(MyMockService.class,
+                    VaadinService.getCurrent().getClass());
+        }
+
+        @Test
+        void setup_serviceListeners_areInvokedOnSetupAndTearDown() {
+            MockVaadin.tearDown();
+            AtomicInteger sessionInit = new AtomicInteger();
+            AtomicInteger uiInit = new AtomicInteger();
+            AtomicInteger sessionDestroy = new AtomicInteger();
+            AtomicInteger serviceDestroy = new AtomicInteger();
+            MockVaadin.setup(new MockVaadinServlet(routes) {
+                @Override
+                protected VaadinServletService createServletService(
+                        DeploymentConfiguration deploymentConfiguration)
+                        throws ServiceException {
+                    MockService service = new MockService(this,
+                            deploymentConfiguration);
+                    service.init();
+                    service.addSessionInitListener(
+                            event -> sessionInit.incrementAndGet());
+                    service.addUIInitListener(
+                            event -> uiInit.incrementAndGet());
+                    service.addSessionDestroyListener(
+                            event -> sessionDestroy.incrementAndGet());
+                    service.addServiceDestroyListener(
+                            event -> serviceDestroy.incrementAndGet());
+                    return service;
+                }
+            });
+
+            assertEquals(1, sessionInit.get());
+            assertEquals(1, uiInit.get());
+            assertEquals(0, sessionDestroy.get());
+            assertEquals(0, serviceDestroy.get());
+
+            MockVaadin.tearDown();
+
+            assertEquals(1, sessionInit.get());
+            assertEquals(1, uiInit.get());
+            assertEquals(1, sessionDestroy.get());
+            assertEquals(1, serviceDestroy.get());
+        }
+    }
+
+    private static class MyMockService extends VaadinServletService {
+
+        MyMockService(VaadinServlet servlet,
+                DeploymentConfiguration deploymentConfiguration) {
+            super(servlet, deploymentConfiguration);
+        }
+
+        @Override
+        public boolean isAtmosphereAvailable() {
+            return false;
+        }
+
+        @Override
+        public String getMainDivId(VaadinSession session,
+                VaadinRequest request) {
+            return "ROOT-1";
+        }
+
+        @Override
+        public VaadinSession createVaadinSession(VaadinRequest request) {
+            return new MockVaadinSession(this, MockedUI::new);
+        }
+    }
+
+    private static void expectWelcomeTree() {
+        assertEquals(withSortedThemeNames(WELCOME_TREE), withSortedThemeNames(
+                PrettyPrintTree.toPrettyTree(UI.getCurrent()).trim()));
+    }
+
+    /**
+     * Sorts the names within every {@code @theme='...'} of a pretty printed
+     * component tree.
+     * <p>
+     * A component's theme names are a set, so the order they are printed in is
+     * whatever order the component happened to add them in — nothing a test
+     * should assert on. Sorting both sides keeps a tree assertion about the
+     * tree.
+     */
+    private static String withSortedThemeNames(String tree) {
+        Matcher matcher = Pattern.compile("@theme='([^']*)'").matcher(tree);
+        StringBuilder result = new StringBuilder();
+        while (matcher.find()) {
+            String sorted = Arrays.stream(matcher.group(1).split(" ")).sorted()
+                    .collect(Collectors.joining(" "));
+            matcher.appendReplacement(result,
+                    Matcher.quoteReplacement("@theme='" + sorted + "'"));
+        }
+        matcher.appendTail(result);
+        return result.toString();
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/PrettyPrintTreeTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/PrettyPrintTreeTest.java
new file mode 100644
index 00000000..08241eaa
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/PrettyPrintTreeTest.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.List;
+
+import com.example.base.HelloWorldView;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Html;
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.contextmenu.ContextMenu;
+import com.vaadin.flow.component.formlayout.FormLayout;
+import com.vaadin.flow.component.html.Anchor;
+import com.vaadin.flow.component.html.Div;
+import com.vaadin.flow.component.html.Image;
+import com.vaadin.flow.component.html.Span;
+import com.vaadin.flow.component.icon.VaadinIcon;
+import com.vaadin.flow.component.textfield.TextArea;
+import com.vaadin.flow.component.textfield.TextField;
+import com.vaadin.flow.router.BeforeEnterEvent;
+import com.vaadin.flow.router.ErrorParameter;
+import com.vaadin.flow.router.InternalServerError;
+import com.vaadin.flow.router.Location;
+import com.vaadin.flow.router.NavigationEvent;
+import com.vaadin.flow.router.NavigationTrigger;
+import com.vaadin.flow.router.RouterLink;
+import com.vaadin.flow.server.VaadinService;
+
+import static com.vaadin.browserless.internal.PrettyPrintTree.toPrettyString;
+import static com.vaadin.browserless.internal.PrettyPrintTree.toPrettyTree;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+class PrettyPrintTreeTest {
+
+    private static Routes routes;
+
+    @BeforeAll
+    static void discoverRoutes() {
+        routes = new Routes().autoDiscoverViews("com.example.base");
+    }
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup(routes);
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void toPrettyTree_divWithText_rendersBothLevels() {
+        Div div = new Div();
+        div.add(new Text("Foo"));
+        assertEquals("""
+                └── Div[text='Foo']
+                    └── Text[text='Foo']""", toPrettyTree(div).trim());
+    }
+
+    @Test
+    void toPrettyString_htmlComponents_dumpTextVisibilityAndSlot() {
+        assertEquals("Text[text='foo']", toPrettyString(new Text("foo")));
+
+        Div invisible = new Div();
+        invisible.setVisible(false);
+        assertEquals("Div[INVIS]", toPrettyString(invisible));
+
+        assertEquals("Html[<b>foo bar baz <i>foobar</i></b>]", toPrettyString(
+                new Html("\n    <b>foo\nbar\n    baz\n<i>foobar</i></b>")));
+
+        assertEquals("HtmlSpan[innerHTML='aaa<b>bbbb</b>ccc']",
+                toPrettyString(new HtmlSpan("aaa<b>bbbb</b>ccc")));
+
+        Div tooltipped = new Div();
+        ComponentUtils.tooltip(tooltipped, "foobar");
+        assertEquals("Div[@title='foobar']", toPrettyString(tooltipped));
+
+        Span testSpan = new Span("hi");
+        new TextField().setPrefixComponent(testSpan);
+        assertEquals("Span[text='hi', @slot='prefix']",
+                toPrettyString(testSpan));
+    }
+
+    @Test
+    void toPrettyString_textFields_dumpIdLabelValueAndErrorMessage() {
+        TextField withId = new TextField();
+        BasicUtils.id_(withId, "25");
+        assertMatches(toPrettyString(withId), "TextField\\[#25, value=''.*]");
+
+        TextArea area = new TextArea("label");
+        area.setValue("some text");
+        assertMatches(toPrettyString(area),
+                "TextArea\\[label='label', value='some text'.*]");
+
+        TextField invalid = new TextField();
+        BasicUtils.id_(invalid, "25");
+        invalid.setErrorMessage("failed validation");
+        assertMatches(toPrettyString(invalid),
+                "TextField\\[#25, value='', errorMessage='failed validation'.*]");
+
+        assertMatches(toPrettyString(new TextField("foobar")),
+                "TextField\\[label='foobar', value=''.*]");
+    }
+
+    @Test
+    void toPrettyString_button_dumpsCaptionAndIcon() {
+        assertEquals("Button[caption='click me']",
+                toPrettyString(new Button("click me")));
+        assertEquals("Button[icon='vaadin:abacus', @theme='icon']",
+                toPrettyString(new Button(VaadinIcon.ABACUS.create())));
+    }
+
+    @Test
+    void toPrettyString_anchor_dumpsHrefHoweverItIsDeclared() {
+        assertEquals("Anchor[]", toPrettyString(new Anchor()));
+        assertEquals("Anchor[href='vaadin.com']",
+                toPrettyString(new Anchor("vaadin.com")));
+        // the href is dumped for any component declaring it, also when it is
+        // inherited or declared as a plain href() method
+        assertEquals("MyAnchor[href='vaadin.com']",
+                toPrettyString(new MyAnchor("vaadin.com")));
+        assertEquals("ComponentWithHrefFunction[href='vaadin.com']",
+                toPrettyString(new ComponentWithHrefFunction()));
+        assertEquals("ComponentWithHrefField[href='vaadin.com']",
+                toPrettyString(new ComponentWithHrefField()));
+        assertEquals("ComponentWithHrefInterface[href='vaadin.com']",
+                toPrettyString(new ComponentWithHrefInterface()));
+        // a bean getter is consulted as well
+        assertEquals("ComponentWithComputedHref[href='vaadin.com']",
+                toPrettyString(new ComponentWithComputedHref()));
+        // a blank member doesn't end the lookup, the getter still gets its turn
+        assertEquals("ComponentWithBlankHrefField[href='vaadin.com']",
+                toPrettyString(new ComponentWithBlankHrefField()));
+    }
+
+    @Test
+    void toPrettyString_routerLink_blankHrefIsNotDumped() {
+        // getHref() reports a missing href as an empty string, which is not
+        // dumped
+        assertEquals("RouterLink[]", toPrettyString(new RouterLink()));
+        assertEquals("RouterLink[text='Hello', href='helloworld']",
+                toPrettyString(new RouterLink("Hello", HelloWorldView.class)));
+    }
+
+    @Test
+    void toPrettyString_image_dumpsSrc() {
+        assertEquals("Image[]", toPrettyString(new Image()));
+        assertEquals("Image[@src='vaadin.com']",
+                toPrettyString(new Image("vaadin.com", "")));
+    }
+
+    @Test
+    void toPrettyString_icon_dumpsTheIconName() {
+        assertEquals("Icon[@icon='vaadin:abacus']",
+                toPrettyString(VaadinIcon.ABACUS.create()));
+    }
+
+    @Test
+    void toPrettyString_formItem_dumpsItsLabel() {
+        assertEquals("FormItem[label='foo']", toPrettyString(
+                new FormLayout().addFormItem(new TextField(), "foo")));
+    }
+
+    @Test
+    void toPrettyString_componentWithCustomToString_usesIt() {
+        assertEquals("MyComponentWithToString[my-div(25)]",
+                toPrettyString(new MyComponentWithToString()));
+    }
+
+    @Test
+    void toPrettyString_styles_areNotDuplicated() {
+        Div div = new Div();
+        assertEquals("Div[]", toPrettyString(div));
+        div.setWidthFull();
+        assertEquals("Div[@style='width:100%']", toPrettyString(div));
+        div.getStyle().set("flex-shrink", "1");
+        assertEquals("Div[@style='width:100%;flex-shrink:1']",
+                toPrettyString(div));
+    }
+
+    @Test
+    void toPrettyTree_contextMenu_rendersItemsAndSubItems() {
+        Div div = new Div();
+        UI.getCurrent().add(div);
+        ContextMenu cm = new ContextMenu(div);
+        var menu = cm.addItem("menu");
+        menu.setEnabled(false);
+        menu.getSubMenu().addItem("click me", e -> fail("shouldn't be called"));
+        cm.addItem("save as");
+
+        assertEquals("""
+                └── ContextMenu[opened='false']
+                    ├── MenuItem[DISABLED, text='menu']
+                    │   └── MenuItem[text='click me']
+                    └── MenuItem[text='save as']""", toPrettyTree(cm).trim());
+    }
+
+    @Nested
+    class ToPrettyStringInternalServerError {
+
+        private BeforeEnterEvent createEvent() {
+            var router = VaadinService.getCurrent().getRouter();
+            NavigationEvent navigationEvent = new NavigationEvent(router,
+                    new Location("helloworld"), UI.getCurrent(),
+                    NavigationTrigger.UI_NAVIGATE);
+            return new BeforeEnterEvent(navigationEvent, HelloWorldView.class,
+                    List.of());
+        }
+
+        private InternalServerError createErrorComponent(Exception error,
+                String message) {
+            MockInternalSeverError errorView = new MockInternalSeverError();
+            ErrorParameter<Exception> errorParam = new ErrorParameter<>(
+                    Exception.class, error, message);
+            errorView.setErrorParameter(createEvent(), errorParam);
+            return errorView;
+        }
+
+        @Test
+        void noCauseException_dumpsTargetViewMessageAndType() {
+            String pretty = toPrettyString(
+                    createErrorComponent(new RuntimeException("OOPS!"), null))
+                    .trim();
+            assertTrue(pretty.contains("targetView='helloworld'"));
+            assertTrue(pretty.contains("failureMessage='OOPS!'"));
+            assertTrue(pretty
+                    .contains("exceptionType='java.lang.RuntimeException'"));
+        }
+
+        @Test
+        void customMessage_isDumpedInsteadOfTheExceptionMessage() {
+            String pretty = toPrettyString(createErrorComponent(
+                    new RuntimeException("BOOM!"), "Something failed")).trim();
+            assertTrue(pretty.contains("targetView='helloworld'"));
+            assertTrue(pretty.contains("failureMessage='Something failed'"));
+            assertTrue(pretty
+                    .contains("exceptionType='java.lang.RuntimeException'"));
+        }
+    }
+
+    @Test
+    void toPrettyTree_nullProperty_isNotDumped() {
+        Div div = new Div();
+        div.getElement().setProperty("null-property", (String) null);
+        div.getElement().setProperty("nonnull-property", "OK");
+        assertEquals("└── Div[nonnull-property='OK']",
+                toPrettyTree(div).trim());
+    }
+
+    private static void assertMatches(String actual, String regex) {
+        assertTrue(actual.matches(regex),
+                "Expected '" + actual + "' to match '" + regex + "'");
+    }
+
+    static class MyComponentWithToString extends Div {
+        @Override
+        public String toString() {
+            return "my-div(25)";
+        }
+    }
+
+    /** Inherits the private {@code href} field from {@link Anchor}. */
+    static class MyAnchor extends Anchor {
+        MyAnchor(String href) {
+            super(href);
+        }
+    }
+
+    /** Declares {@code href} as a plain no-arg method. */
+    static class ComponentWithHrefFunction extends Div {
+        public String href() {
+            return "vaadin.com";
+        }
+    }
+
+    /** Declares {@code href} as a field. */
+    static class ComponentWithHrefField extends Div {
+        public String href = "vaadin.com";
+    }
+
+    /** Has a blank {@code href} field, but a real one through its getter. */
+    static class ComponentWithBlankHrefField extends Anchor {
+        ComponentWithBlankHrefField() {
+            super("");
+        }
+
+        @Override
+        public String getHref() {
+            return "vaadin.com";
+        }
+    }
+
+    /** Inherits {@code href} as a default method from an interface. */
+    interface HasHrefFunction {
+        default String href() {
+            return "vaadin.com";
+        }
+    }
+
+    static class ComponentWithHrefInterface extends Div
+            implements HasHrefFunction {
+    }
+
+    /** Declares {@code href} through a bean getter only. */
+    static class ComponentWithComputedHref extends Div {
+        public String getHref() {
+            return "vaadin.com";
+        }
+    }
+
+    /**
+     * Populates its contents with a given html snippet, without wrapping it in
+     * a single root element the way {@link Html} requires.
+     */
+    static class HtmlSpan extends Span {
+        HtmlSpan(String innerHTML) {
+            removeAll();
+            getElement().setProperty("innerHTML", innerHTML);
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/RoutesTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/RoutesTest.java
new file mode 100644
index 00000000..5684ce73
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/RoutesTest.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import com.example.base.ErrorView;
+import com.example.base.HelloWorldView;
+import com.example.base.ParametrizedView;
+import com.example.base.WelcomeView;
+import com.example.base.child.ChildView;
+import com.example.base.navigation.NavigationPostponeView;
+import com.example.base.signals.SignalsView;
+import com.testapp.MyRouteNotFoundError;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.browserless.mocks.MockVaadinHelper;
+import com.vaadin.browserless.viewscan.byannotatedclass.ViewPackagesTestView;
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.HasElement;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.router.HasErrorParameter;
+import com.vaadin.flow.router.NotFoundException;
+import com.vaadin.flow.router.RouteAccessDeniedError;
+import com.vaadin.flow.router.RouteNotFoundError;
+import com.vaadin.flow.server.VaadinContext;
+import com.vaadin.flow.server.startup.ApplicationRouteRegistry;
+
+import static com.vaadin.browserless.TestAssertions.expectThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@SuppressWarnings("deprecation")
+class RoutesTest {
+
+    // TODO: restrict scan until we have component wrapper test views on this
+    // codebase
+    private static final String[] PACKAGES_TO_SCAN = { "com.example.base",
+            "com.vaadin.browserless.viewscan",
+            "com.vaadin.browserless.viewscan4" };
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void autoDiscoverViews_scannedPackages_findsEveryViewAndErrorRoute() {
+        Routes routes = new Routes().autoDiscoverViews(PACKAGES_TO_SCAN);
+        assertEquals(TestViews.ALL_VIEWS, Set.copyOf(routes.getRoutes()));
+        assertEquals(TestViews.ALL_ERROR_ROUTES,
+                Set.copyOf(routes.getErrorRoutes()));
+    }
+
+    @Test
+    void autoDiscoverViews_packagePrivateView_isDiscovered() {
+        Routes routes = new Routes().autoDiscoverViews(PACKAGES_TO_SCAN);
+        assertTrue(
+                routes.getRoutes().stream()
+                        .anyMatch(c -> c.getName()
+                                .equals("com.example.base.PackagePrivateView")),
+                "PackagePrivateView should be discovered");
+    }
+
+    @Test
+    void autoDiscoverViews_calledRepeatedly_yieldsTheSameViews() {
+        assertEquals(TestViews.ALL_VIEWS, Set.copyOf(
+                new Routes().autoDiscoverViews(PACKAGES_TO_SCAN).getRoutes()));
+        assertEquals(TestViews.ALL_VIEWS, Set.copyOf(
+                new Routes().autoDiscoverViews(PACKAGES_TO_SCAN).getRoutes()));
+    }
+
+    // https://github.com/mvysny/karibu-testing/issues/50
+    @Test
+    void autoDiscoverViews_appHandlesNotFoundItself_dropsMockRouteNotFoundError() {
+        Routes routes = new Routes().autoDiscoverViews("com.example.base",
+                "com.testapp", "com.vaadin.flow.router");
+        assertEquals(
+                Set.of(ErrorView.class, MockInternalSeverError.class,
+                        MyRouteNotFoundError.class, RouteNotFoundError.class,
+                        RouteAccessDeniedError.class),
+                Set.copyOf(routes.getErrorRoutes()));
+        // make sure that Vaadin initializes properly with this set of views
+        MockVaadin.setup(routes);
+    }
+
+    @Test
+    void register_byDefault_skipsPwaInitialization() {
+        Routes routes = new Routes().autoDiscoverViews("com.example.base");
+        VaadinContext ctx = MockVaadinHelper.createMockVaadinContext();
+        routes.register(ctx);
+        assertNull(ApplicationRouteRegistry.getInstance(ctx)
+                .getPwaConfigurationClass());
+    }
+
+    @Test
+    void register_skipPwaInitDisabled_discoversThePwaClass() {
+        Routes routes = new Routes().autoDiscoverViews("com.example.base");
+        routes.setSkipPwaInit(false);
+        VaadinContext ctx = MockVaadinHelper.createMockVaadinContext();
+        routes.register(ctx);
+        assertEquals(WelcomeView.class, ApplicationRouteRegistry
+                .getInstance(ctx).getPwaConfigurationClass());
+    }
+
+    @Test
+    void navigate_unknownRoute_rendersErrorNamingTheAvailableRoutes() {
+        Routes routes = new Routes().autoDiscoverViews("com.example.base");
+        MockVaadin.setup(routes);
+        UI.getCurrent().navigate("A_VIEW_THAT_DOESNT_EXIST");
+        HasElement view = UI.getCurrent().getInternals()
+                .getActiveRouterTargetsChain().get(0);
+        assertEquals(MockRouteNotFoundError.class, view.getClass());
+        expectThrows(NotFoundException.class,
+                "No route found for 'A_VIEW_THAT_DOESNT_EXIST': Couldn't find route for 'A_VIEW_THAT_DOESNT_EXIST'\nAvailable routes:",
+                () -> {
+                    throw ((MockRouteNotFoundError) view).getCause();
+                });
+        String errorMessage = ElementUtils.textRecursively2(view.getElement());
+        assertTrue(errorMessage
+                .contains("Could not navigate to 'A_VIEW_THAT_DOESNT_EXIST'"));
+    }
+
+    @Test
+    void merge_twoRouteSets_containsTheUnion() {
+        Set<Class<? extends Component>> routes1Views = new LinkedHashSet<>(
+                Set.of(HelloWorldView.class, WelcomeView.class,
+                        ViewPackagesTestView.class, SignalsView.class,
+                        TestViews.PACKAGE_PRIVATE_VIEW));
+        Set<Class<? extends HasErrorParameter<?>>> routes1Errors = new LinkedHashSet<>(
+                Set.of(ErrorView.class));
+        Routes routes1 = new Routes(routes1Views, routes1Errors);
+
+        Set<Class<? extends Component>> routes2Views = new LinkedHashSet<>(
+                Set.of(ParametrizedView.class, ChildView.class,
+                        NavigationPostponeView.class));
+        Set<Class<? extends HasErrorParameter<?>>> routes2Errors = new LinkedHashSet<>(
+                Set.of(MockRouteNotFoundError.class,
+                        MockInternalSeverError.class));
+        Routes routes2 = new Routes(routes2Views, routes2Errors);
+
+        Routes merged = routes1.merge(routes2);
+        assertEquals(TestViews.ALL_VIEWS, Set.copyOf(merged.getRoutes()));
+        assertEquals(TestViews.ALL_ERROR_ROUTES,
+                Set.copyOf(merged.getErrorRoutes()));
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/SearchSpecTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/SearchSpecTest.java
new file mode 100644
index 00000000..375c9e3c
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/SearchSpecTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.function.Predicate;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.Text;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.checkbox.Checkbox;
+import com.vaadin.flow.component.checkbox.CheckboxGroup;
+import com.vaadin.flow.component.combobox.ComboBox;
+import com.vaadin.flow.component.customfield.CustomField;
+import com.vaadin.flow.component.datepicker.DatePicker;
+import com.vaadin.flow.component.html.Input;
+import com.vaadin.flow.component.html.Span;
+import com.vaadin.flow.component.listbox.ListBox;
+import com.vaadin.flow.component.radiobutton.RadioButtonGroup;
+import com.vaadin.flow.component.select.Select;
+import com.vaadin.flow.component.textfield.TextArea;
+import com.vaadin.flow.component.textfield.TextField;
+import com.vaadin.flow.component.timepicker.TimePicker;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SearchSpecTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void clazz_matchesOnlyTheGivenType() {
+        Predicate<Component> p = new SearchSpec<>(Button.class).toPredicate();
+        assertTrue(p.test(new Button()));
+        assertFalse(p.test(new Span()));
+    }
+
+    @Test
+    void id_matchesTheComponentId() {
+        SearchSpec<Component> spec = new SearchSpec<>(Component.class);
+        spec.setId("25");
+        Predicate<Component> p = spec.toPredicate();
+
+        Button matching = new Button();
+        matching.setId("25");
+        assertTrue(p.test(matching));
+
+        Button other = new Button();
+        other.setId("42");
+        assertFalse(p.test(other));
+
+        assertFalse(p.test(new Button()));
+    }
+
+    @Test
+    void caption_resolvedAcrossEveryComponentKindThatHasOne() {
+        SearchSpec<Component> spec = new SearchSpec<>(Component.class);
+        spec.setCaption("foo");
+        Predicate<Component> p = spec.toPredicate();
+
+        assertTrue(p.test(new Button("foo")));
+        assertFalse(p.test(new Button("bar")));
+        assertFalse(p.test(new Button()));
+
+        assertTrue(p.test(new Checkbox("foo")));
+        assertFalse(p.test(new Checkbox("bar")));
+        assertFalse(p.test(new Checkbox()));
+
+        assertTrue(p.test(labelled(new CheckboxGroup<Integer>(), "foo")));
+        assertFalse(p.test(labelled(new CheckboxGroup<Integer>(), "bar")));
+        assertFalse(p.test(new CheckboxGroup<Integer>()));
+
+        assertTrue(p.test(labelled(new Select<Integer>(), "foo")));
+        assertFalse(p.test(labelled(new Select<Integer>(), "bar")));
+        assertFalse(p.test(new Select<Integer>()));
+
+        assertTrue(p.test(labelled(new ListBox<Integer>(), "foo")));
+        assertFalse(p.test(labelled(new ListBox<Integer>(), "bar")));
+        assertFalse(p.test(new ListBox<Integer>()));
+
+        assertTrue(p.test(labelled(new RadioButtonGroup<Integer>(), "foo")));
+        assertFalse(p.test(labelled(new RadioButtonGroup<Integer>(), "bar")));
+        assertFalse(p.test(new RadioButtonGroup<Integer>()));
+
+        // tests CustomField
+        assertTrue(p.test(labelled(new StringCustomField(), "foo")));
+        assertFalse(p.test(labelled(new StringCustomField(), "bar")));
+        assertFalse(p.test(new StringCustomField()));
+
+        assertTrue(p.test(labelled(new Input(), "foo")));
+        assertFalse(p.test(labelled(new Input(), "bar")));
+        assertFalse(p.test(new Input()));
+
+        assertTrue(p.test(new TextField("foo")));
+        assertFalse(p.test(new TextField("bar")));
+        assertFalse(p.test(new TextField()));
+
+        assertTrue(p.test(new TextArea("foo")));
+        assertFalse(p.test(new TextArea("bar")));
+        assertFalse(p.test(new TextArea()));
+
+        assertTrue(p.test(new TimePicker("foo")));
+        assertFalse(p.test(new TimePicker("bar")));
+        assertFalse(p.test(new TimePicker()));
+
+        assertTrue(p.test(new DatePicker("foo")));
+        assertFalse(p.test(new DatePicker("bar")));
+        assertFalse(p.test(new DatePicker()));
+
+        assertTrue(p.test(new ComboBox<Integer>("foo")));
+        assertFalse(p.test(new ComboBox<Integer>("bar")));
+        assertFalse(p.test(new ComboBox<Integer>()));
+    }
+
+    @Test
+    void text_matchesTheElementText() {
+        SearchSpec<Component> spec = new SearchSpec<>(Component.class);
+        spec.setText("foo");
+        Predicate<Component> p = spec.toPredicate();
+
+        assertTrue(p.test(new Button("foo")));
+        assertFalse(p.test(new Button("bar")));
+        assertFalse(p.test(new Button()));
+
+        assertTrue(p.test(new Text("foo")));
+        assertFalse(p.test(new Text("bar")));
+        assertFalse(p.test(new Text("")));
+    }
+
+    @Test
+    void predicates_customPredicateIsApplied() {
+        SearchSpec<Component> spec = new SearchSpec<>(Component.class);
+        spec.getPredicates().add(c -> c instanceof Button);
+        Predicate<Component> p = spec.toPredicate();
+
+        assertTrue(p.test(new Button()));
+        assertFalse(p.test(new Span()));
+    }
+
+    private static <T extends Component> T labelled(T component, String label) {
+        ComponentUtils.label(component, label);
+        return component;
+    }
+
+    /**
+     * Stands in for any {@link CustomField}, to check that a caption is
+     * resolved for one.
+     */
+    private static class StringCustomField extends CustomField<String> {
+        @Override
+        protected String generateModelValue() {
+            return "";
+        }
+
+        @Override
+        protected void setPresentationValue(String newPresentationValue) {
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/ShortcutsTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/ShortcutsTest.java
new file mode 100644
index 00000000..5a8aa60c
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/ShortcutsTest.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Key;
+import com.vaadin.flow.component.KeyModifier;
+import com.vaadin.flow.component.button.Button;
+
+import static com.vaadin.browserless.internal.Shortcuts.fireShortcut;
+import static com.vaadin.browserless.internal.Utils.currentUI;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ShortcutsTest {
+
+    private final AtomicBoolean clicked = new AtomicBoolean();
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void fireShortcut_noListenerRegistered_doesNothing() {
+        fireShortcut(Key.ENTER);
+    }
+
+    /**
+     * Adds a button to the current UI which records a click, and binds the
+     * given click shortcut to it.
+     */
+    private void buttonWithClickShortcut(Key key, KeyModifier... modifiers) {
+        Button button = new Button();
+        button.addClickListener(e -> clicked.set(true));
+        button.addClickShortcut(key, modifiers);
+        currentUI().add(button);
+    }
+
+    private void shortcutListener(Key key, KeyModifier... modifiers) {
+        com.vaadin.flow.component.Shortcuts.addShortcutListener(currentUI(),
+                () -> clicked.set(true), key, modifiers);
+    }
+
+    @Nested
+    class ButtonAddClickShortcut {
+
+        @Test
+        void matchingKey_clicksTheButton() {
+            buttonWithClickShortcut(Key.ENTER);
+            fireShortcut(Key.ENTER);
+            assertTrue(clicked.get());
+        }
+
+        @Test
+        void differentKey_doesNotClickTheButton() {
+            buttonWithClickShortcut(Key.KEY_A);
+            fireShortcut(Key.ENTER);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE);
+            assertFalse(clicked.get());
+        }
+
+        @Test
+        void differentModifiers_doesNotClickTheButton() {
+            buttonWithClickShortcut(Key.KEY_A, KeyModifier.ALT);
+            fireShortcut(Key.KEY_A);
+            assertFalse(clicked.get());
+            fireShortcut(Key.KEY_A, KeyModifier.CONTROL);
+            assertFalse(clicked.get());
+            fireShortcut(Key.KEY_A, KeyModifier.CONTROL, KeyModifier.ALT);
+            assertFalse(clicked.get());
+            fireShortcut(Key.KEY_A, KeyModifier.ALT);
+            assertTrue(clicked.get());
+        }
+
+        @Test
+        void space_multipleKeyBindings_clicksTheButton() {
+            // Key.SPACE has multiple key bindings, test that out.
+            buttonWithClickShortcut(Key.SPACE);
+            fireShortcut(Key.SPACE);
+            assertTrue(clicked.get());
+        }
+
+        @Test
+        void spaceWithDifferentModifiers_doesNotClickTheButton() {
+            buttonWithClickShortcut(Key.SPACE, KeyModifier.ALT);
+            fireShortcut(Key.ENTER);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE, KeyModifier.CONTROL);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE, KeyModifier.CONTROL, KeyModifier.ALT);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE, KeyModifier.ALT);
+            assertTrue(clicked.get());
+        }
+    }
+
+    @Nested
+    class ShortcutsAddShortcutListener {
+
+        @Test
+        void matchingKey_runsTheCommand() {
+            shortcutListener(Key.ENTER);
+            fireShortcut(Key.ENTER);
+            assertTrue(clicked.get());
+        }
+
+        @Test
+        void differentKey_doesNotRunTheCommand() {
+            shortcutListener(Key.KEY_A);
+            fireShortcut(Key.ENTER);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE);
+            assertFalse(clicked.get());
+        }
+
+        @Test
+        void differentModifiers_doesNotRunTheCommand() {
+            shortcutListener(Key.KEY_A, KeyModifier.ALT);
+            fireShortcut(Key.KEY_A);
+            assertFalse(clicked.get());
+            fireShortcut(Key.KEY_A, KeyModifier.CONTROL);
+            assertFalse(clicked.get());
+            fireShortcut(Key.KEY_A, KeyModifier.CONTROL, KeyModifier.ALT);
+            assertFalse(clicked.get());
+            fireShortcut(Key.KEY_A, KeyModifier.ALT);
+            assertTrue(clicked.get());
+        }
+
+        @Test
+        void space_multipleKeyBindings_runsTheCommand() {
+            // Key.SPACE has multiple key bindings, test that out.
+            shortcutListener(Key.SPACE);
+            fireShortcut(Key.SPACE);
+            assertTrue(clicked.get());
+        }
+
+        @Test
+        void spaceWithDifferentModifiers_doesNotRunTheCommand() {
+            shortcutListener(Key.SPACE, KeyModifier.ALT);
+            fireShortcut(Key.ENTER);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE, KeyModifier.CONTROL);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE, KeyModifier.CONTROL, KeyModifier.ALT);
+            assertFalse(clicked.get());
+            fireShortcut(Key.SPACE, KeyModifier.ALT);
+            assertTrue(clicked.get());
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/TestClasspathTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/TestClasspathTest.java
new file mode 100644
index 00000000..e631226a
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/TestClasspathTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.net.URL;
+
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.button.Button;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Asserts the things this module's tests take for granted about their own
+ * classpath.
+ */
+class TestClasspathTest {
+
+    @Test
+    void flowBuildInfo_isNotOnTheTestClasspath() {
+        URL resource = Thread.currentThread().getContextClassLoader()
+                .getResource("META-INF/VAADIN/config/flow-build-info.json");
+        assertNull(resource, "flow-build-info.json exists on the classpath!");
+    }
+
+    @Test
+    void isTemplate_withoutThePolymerTemplateDependency_returnsFalse() {
+        assertFalse(TestingLifecycleHook.isTemplate(new Button("foo")));
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/TestViews.java b/junit6/src/test/java/com/vaadin/browserless/internal/TestViews.java
new file mode 100644
index 00000000..6e282745
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/TestViews.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import java.util.Set;
+
+import com.example.base.ErrorView;
+import com.example.base.HelloWorldView;
+import com.example.base.ParametrizedView;
+import com.example.base.WelcomeView;
+import com.example.base.child.ChildView;
+import com.example.base.navigation.NavigationPostponeView;
+import com.example.base.signals.SignalsView;
+
+import com.vaadin.browserless.viewscan.byannotatedclass.ViewPackagesTestView;
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.router.HasErrorParameter;
+
+/**
+ * The views route discovery is expected to find, shared by the tests that
+ * assert on it.
+ */
+public final class TestViews {
+
+    private TestViews() {
+    }
+
+    /**
+     * Loaded by name because the view is package private on purpose: discovery
+     * has to find it anyway.
+     */
+    public static final Class<? extends Component> PACKAGE_PRIVATE_VIEW = packagePrivateView();
+
+    public static final Set<Class<? extends Component>> ALL_VIEWS = Set.of(
+            HelloWorldView.class, WelcomeView.class, ParametrizedView.class,
+            ChildView.class, NavigationPostponeView.class,
+            ViewPackagesTestView.class, SignalsView.class,
+            PACKAGE_PRIVATE_VIEW);
+
+    public static final Set<Class<? extends HasErrorParameter<?>>> ALL_ERROR_ROUTES = Set
+            .of(ErrorView.class, MockRouteNotFoundError.class,
+                    MockInternalSeverError.class);
+
+    private static Class<? extends Component> packagePrivateView() {
+        try {
+            return Class.forName("com.example.base.PackagePrivateView")
+                    .asSubclass(Component.class);
+        } catch (ClassNotFoundException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/mocks/MockContextTest.java b/junit6/src/test/java/com/vaadin/browserless/mocks/MockContextTest.java
new file mode 100644
index 00000000..c215f643
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/mocks/MockContextTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.browserless.TestSerialization;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MockContextTest {
+
+    private MockContext ctx;
+
+    @BeforeEach
+    void setUp() {
+        ctx = new MockContext();
+    }
+
+    @Test
+    void attributes_setToNullOrRemoved_dropTheAttribute() {
+        assertNull(ctx.getAttribute("foo"));
+        assertEquals(List.of(), names());
+        ctx.setAttribute("foo", "bar");
+        assertEquals("bar", ctx.getAttribute("foo"));
+        assertEquals(List.of("foo"), names());
+        ctx.setAttribute("foo", null);
+        assertNull(ctx.getAttribute("foo"));
+        assertEquals(List.of(), names());
+        ctx.setAttribute("foo", "bar");
+        assertEquals(List.of("foo"), names());
+        assertEquals("bar", ctx.getAttribute("foo"));
+        ctx.removeAttribute("foo");
+        assertEquals(List.of(), names());
+        assertNull(ctx.getAttribute("foo"));
+    }
+
+    @Test
+    void setInitParameter_alreadySet_keepsTheFirstValue() {
+        assertNull(ctx.getInitParameter("foo"));
+        assertEquals(List.of(), initParameterNames());
+        assertTrue(ctx.setInitParameter("foo", "bar"));
+        assertEquals(List.of("foo"), initParameterNames());
+        assertEquals("bar", ctx.getInitParameter("foo"));
+        assertFalse(ctx.setInitParameter("foo", "baz"));
+        assertEquals("bar", ctx.getInitParameter("foo"));
+        assertEquals(List.of("foo"), initParameterNames());
+    }
+
+    @Test
+    void getRealPath_pathOutsideTheRoots_returnsNull() {
+        ctx.setRealPathRoots(List.of("src/main/webapp/frontend",
+                "src/main/webapp", "src/test/webapp"));
+        assertNull(ctx.getRealPath("/index.html"));
+        assertTrue(ctx.getRealPath("/VAADIN/themes/default/img/1.txt")
+                .replace('\\', '/')
+                .endsWith("/VAADIN/themes/default/img/1.txt"));
+        assertTrue(ctx.getRealPath("/VAADIN/themes/valo/../default/img/1.txt")
+                .replace('\\', '/')
+                .endsWith("/VAADIN/themes/default/img/1.txt"));
+        // stepping out of root is not allowed and returns null. Avoids browsing
+        // through the filesystem
+        assertNull(ctx.getRealPath("/../../../build.gradle.kts"));
+    }
+
+    @Test
+    void serialization_contextWithAttributes_roundTrips() {
+        ctx.setAttribute("foo", "bar");
+        ctx.setInitParameter("foo", "bar");
+        TestSerialization.cloneBySerialization(ctx);
+    }
+
+    private List<String> names() {
+        return Collections.list(ctx.getAttributeNames());
+    }
+
+    private List<String> initParameterNames() {
+        return Collections.list(ctx.getInitParameterNames());
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/mocks/MockHttpSessionTest.java b/junit6/src/test/java/com/vaadin/browserless/mocks/MockHttpSessionTest.java
new file mode 100644
index 00000000..7168c980
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/mocks/MockHttpSessionTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.http.HttpSession;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.browserless.TestSerialization;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class MockHttpSessionTest {
+
+    private HttpSession session;
+
+    @BeforeEach
+    void setUp() {
+        session = MockHttpSession.create(new MockContext());
+    }
+
+    @Test
+    void attributes_setToNullOrRemoved_dropTheAttribute() {
+        assertNull(session.getAttribute("foo"));
+        assertEquals(List.of(), names());
+        session.setAttribute("foo", "bar");
+        assertEquals(List.of("foo"), names());
+        assertEquals("bar", session.getAttribute("foo"));
+        session.setAttribute("foo", null);
+        assertNull(session.getAttribute("foo"));
+        assertEquals(List.of(), names());
+        session.setAttribute("foo", "bar");
+        assertEquals("bar", session.getAttribute("foo"));
+        assertEquals(List.of("foo"), names());
+        session.removeAttribute("foo");
+        assertNull(session.getAttribute("foo"));
+        assertEquals(List.of(), names());
+    }
+
+    @Test
+    void serialization_sessionWithAttributes_roundTrips() {
+        session.setAttribute("foo", "bar");
+        TestSerialization.cloneBySerialization((MockHttpSession) session);
+    }
+
+    @Nested
+    class Invalidate {
+
+        @Test
+        void invalidate_marksTheSessionInvalid() {
+            session.invalidate();
+            assertFalse(((MockHttpSession) session).isValid());
+        }
+
+        @Test
+        void invalidate_calledTwice_throws() {
+            session.invalidate();
+            assertThrows(IllegalStateException.class,
+                    () -> session.invalidate());
+        }
+
+        @Test
+        void getAttribute_invalidatedSession_throws() {
+            session.invalidate();
+            assertThrows(IllegalStateException.class,
+                    () -> session.getAttribute("foo"));
+        }
+
+        @Test
+        void getId_invalidatedSession_stillReadable() {
+            session.invalidate();
+            session.getId();
+        }
+
+        @Test
+        void getServletContext_invalidatedSession_stillReadable() {
+            session.invalidate();
+            session.getServletContext();
+        }
+
+        @Test
+        void maxInactiveInterval_invalidatedSession_stillWritable() {
+            session.invalidate();
+            session.setMaxInactiveInterval(
+                    session.getMaxInactiveInterval() + 1);
+        }
+
+        @Test
+        void getCreationTime_invalidatedSession_throws() {
+            session.invalidate();
+            assertThrows(IllegalStateException.class,
+                    () -> session.getCreationTime());
+        }
+
+        @Test
+        void getLastAccessedTime_invalidatedSession_throws() {
+            session.invalidate();
+            assertThrows(IllegalStateException.class,
+                    () -> session.getLastAccessedTime());
+        }
+
+        @Test
+        void getAttributeNames_invalidatedSession_throws() {
+            session.invalidate();
+            assertThrows(IllegalStateException.class,
+                    () -> session.getAttributeNames());
+        }
+    }
+
+    private List<String> names() {
+        return Collections.list(session.getAttributeNames());
+    }
+}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/Utils.kt b/junit6/src/test/java/com/vaadin/browserless/mocks/MockPrincipal.java
similarity index 53%
rename from junit6/src/test/kotlin/com/vaadin/browserless/mocks/Utils.kt
rename to junit6/src/test/java/com/vaadin/browserless/mocks/MockPrincipal.java
index 50c667d8..54a6221c 100644
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/Utils.kt
+++ b/junit6/src/test/java/com/vaadin/browserless/mocks/MockPrincipal.java
@@ -13,12 +13,28 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.vaadin.browserless.mocks
+package com.vaadin.browserless.mocks;
 
-import java.security.Principal
+import java.security.Principal;
+import java.util.List;
 
-data class MockPrincipal(private val name: String, val allowedRoles: List<String> = listOf()) : Principal {
-    override fun getName(): String = name
+/**
+ * A {@link Principal} with a fixed name and a fixed set of roles, for the
+ * request mocks to report.
+ */
+record MockPrincipal(String name,
+        List<String> allowedRoles) implements Principal {
+
+    MockPrincipal(String name) {
+        this(name, List.of());
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
 
-    fun isUserInRole(role: String): Boolean = allowedRoles.contains(role)
+    boolean isUserInRole(String role) {
+        return allowedRoles.contains(role);
+    }
 }
diff --git a/junit6/src/test/java/com/vaadin/browserless/mocks/MockRequestTest.java b/junit6/src/test/java/com/vaadin/browserless/mocks/MockRequestTest.java
new file mode 100644
index 00000000..9e183863
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/mocks/MockRequestTest.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiPredicate;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MockRequestTest {
+
+    private MockRequest request;
+
+    @BeforeEach
+    void setUp() {
+        request = new MockRequest(MockHttpSession.create(new MockContext()));
+    }
+
+    @Test
+    void attributes_setToNullOrRemoved_dropTheAttribute() {
+        assertNull(request.getAttribute("foo"));
+        request.setAttribute("foo", "bar");
+        assertEquals("bar", request.getAttribute("foo"));
+        request.setAttribute("foo", null);
+        assertNull(request.getAttribute("foo"));
+        request.setAttribute("foo", "bar");
+        assertEquals("bar", request.getAttribute("foo"));
+        request.removeAttribute("foo");
+        assertNull(request.getAttribute("foo"));
+    }
+
+    @Test
+    void parameters_setSinglyOrInBulk_reportedBackToTheCaller() {
+        assertNull(request.getParameter("foo"));
+        assertEquals(List.of(), parameterNames());
+        assertNull(request.getParameterValues("foo"));
+
+        request.setParameter("foo", "bar");
+        assertEquals("bar", request.getParameter("foo"));
+        assertEquals(List.of("foo"), parameterNames());
+        assertEquals(List.of("bar"),
+                List.of(request.getParameterValues("foo")));
+
+        request.getParameters().put("foo", new String[] { "bar", "baz" });
+        assertEquals("bar", request.getParameter("foo"));
+        assertEquals(List.of("foo"), parameterNames());
+        assertEquals(List.of("bar", "baz"),
+                List.of(request.getParameterValues("foo")));
+    }
+
+    @Test
+    void getSession_invalidatedSessionAndNoCreate_returnsNull() {
+        // Mirrors the servlet container contract: after invalidation there is
+        // no current session, so getSession(false) must return null rather than
+        // the stale, invalidated session. See issue #115.
+        MockHttpSession session = (MockHttpSession) request.getSession();
+        assertTrue(session.isValid());
+        session.setAttribute("foo", "bar");
+        session.invalidate();
+        assertNull(request.getSession(false));
+        assertFalse(session.isValid());
+    }
+
+    @Test
+    void getSession_invalidatedSessionAndCreate_returnsAFreshSessionKeepingTheRequestedId() {
+        MockHttpSession session = (MockHttpSession) request.getSession();
+        String requestedId = request.getRequestedSessionId();
+        assertTrue(session.isValid());
+        session.setAttribute("foo", "bar");
+        session.invalidate();
+        assertFalse(session.isValid());
+        assertNotSame(session, request.getSession(true));
+        session = (MockHttpSession) request.getSession(true);
+        assertTrue(session.isValid());
+        assertNull(session.getAttribute("foo"));
+        // the replacement session has its own ID, but the ID the client asked
+        // for stays the same for the lifetime of the request
+        assertNotEquals(requestedId, session.getId());
+        assertEquals(requestedId, request.getRequestedSessionId());
+    }
+
+    @Test
+    void getSession_invalidatedSession_returnsAFreshEmptySession() {
+        MockHttpSession session = (MockHttpSession) request.getSession();
+        assertTrue(session.isValid());
+        session.setAttribute("foo", "bar");
+        session.invalidate();
+        assertFalse(session.isValid());
+        assertNotSame(session, request.getSession());
+        session = (MockHttpSession) request.getSession();
+        assertTrue(session.isValid());
+        assertNull(session.getAttribute("foo"));
+    }
+
+    @Test
+    void changeSessionId_afterLogin_rotatesTheIdButKeepsTheSessionAndItsAttributes() {
+        // Apps which do not use Spring Security do session-fixation protection
+        // themselves by calling changeSessionId() after a successful login; the
+        // session (and thus the VaadinSession stored in it) must survive that.
+        MockHttpSession session = (MockHttpSession) request.getSession();
+        String oldId = session.getId();
+        session.setAttribute("foo", "bar");
+
+        String newId = request.changeSessionId();
+
+        assertNotEquals(oldId, newId);
+        assertEquals(newId, session.getId());
+        assertSame(session, request.getSession());
+        assertEquals("bar", session.getAttribute("foo"));
+        // the client keeps sending the ID it was given until it picks up the
+        // new one, so the requested ID does not change
+        assertEquals(oldId, request.getRequestedSessionId());
+    }
+
+    @Test
+    void changeSessionId_invalidatedSession_throws() {
+        ((MockHttpSession) request.getSession()).invalidate();
+        assertThrows(IllegalStateException.class,
+                () -> request.changeSessionId());
+    }
+
+    @Test
+    void getUserPrincipal_principalSet_reportsIt() {
+        assertNull(request.getUserPrincipal());
+        request.setUserPrincipalInt(new MockPrincipal("foo"));
+        assertEquals(new MockPrincipal("foo"), request.getUserPrincipal());
+    }
+
+    @Test
+    void isUserInRole_withoutRoleChecker_grantsNothing() {
+        assertFalse(request.isUserInRole("foo"));
+        request.setUserPrincipalInt(new MockPrincipal("foo"));
+        assertFalse(request.isUserInRole("foo"));
+        request.setUserPrincipalInt(new MockPrincipal("foo", List.of("foo")));
+        assertFalse(request.isUserInRole("foo"));
+        request.setUserInRole((BiPredicate<java.security.Principal, String>) (p,
+                r) -> ((MockPrincipal) p).isUserInRole(r));
+        assertTrue(request.isUserInRole("foo"));
+    }
+
+    private List<String> parameterNames() {
+        return Collections.list(request.getParameterNames());
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/mocks/MockResponseTest.java b/junit6/src/test/java/com/vaadin/browserless/mocks/MockResponseTest.java
new file mode 100644
index 00000000..3d9230eb
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/mocks/MockResponseTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import jakarta.servlet.http.Cookie;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class MockResponseTest {
+
+    private MockResponse response;
+
+    @BeforeEach
+    void setUp() {
+        response = new MockResponse();
+    }
+
+    @Test
+    void headers_setAndOverwrite_reportedBackToTheCaller() {
+        assertNull(response.getHeader("foo"));
+        assertEquals(List.of(), List.copyOf(response.getHeaderNames()));
+        assertEquals(List.of(), List.copyOf(response.getHeaders("foo")));
+
+        response.setHeader("foo", "bar");
+        assertEquals("bar", response.getHeader("foo"));
+        assertEquals(List.of("foo"), List.copyOf(response.getHeaderNames()));
+        assertEquals(List.of("bar"), List.copyOf(response.getHeaders("foo")));
+
+        response.getHeaders().put("foo", new String[] { "bar", "baz" });
+        assertEquals("bar", response.getHeader("foo"));
+        assertEquals(List.of("foo"), List.copyOf(response.getHeaderNames()));
+        assertEquals(List.of("bar", "baz"),
+                List.copyOf(response.getHeaders("foo")));
+    }
+
+    @Test
+    void cookies_addedCookie_foundByNameAndMissingOneThrows() {
+        Collections.addAll(response.getCookies(), new Cookie("foo", "bar"));
+        assertEquals("bar", response.getCookie("foo").getValue());
+        assertNull(response.findCookie("qqq"));
+
+        IllegalStateException ex = assertThrows(IllegalStateException.class,
+                () -> response.getCookie("baz"));
+        assertEquals("no such cookie with name baz. Available cookies: foo=bar",
+                ex.getMessage());
+    }
+}
diff --git a/junit6/src/test/java/com/vaadin/browserless/mocks/SessionAttributeMapTest.java b/junit6/src/test/java/com/vaadin/browserless/mocks/SessionAttributeMapTest.java
new file mode 100644
index 00000000..2f481cfd
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/mocks/SessionAttributeMapTest.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SessionAttributeMapTest {
+
+    private MockHttpSession session;
+
+    private Map<String, Object> attrs;
+
+    @BeforeEach
+    void setUp() {
+        session = MockHttpSession.create(new MockContext());
+        attrs = new SessionAttributeMap(session);
+    }
+
+    @Nested
+    class Size {
+
+        @Test
+        void newMap_isZero() {
+            assertEquals(0, attrs.size());
+        }
+
+        @Test
+        void put_growsByOne() {
+            attrs.put("foo", "bar");
+            assertEquals(1, attrs.size());
+        }
+
+        @Test
+        void setAttributeOnSession_growsByOne() {
+            session.setAttribute("foo", "bar");
+            assertEquals(1, attrs.size());
+        }
+
+        @Test
+        void clear_dropsToZero() {
+            attrs.put("foo", "bar");
+            attrs.clear();
+            assertEquals(0, attrs.size());
+        }
+    }
+
+    @Nested
+    class IsEmpty {
+
+        @Test
+        void newMap_isEmpty() {
+            assertTrue(attrs.isEmpty());
+        }
+
+        @Test
+        void put_isNoLongerEmpty() {
+            attrs.put("foo", "bar");
+            assertFalse(attrs.isEmpty());
+        }
+
+        @Test
+        void setAttributeOnSession_isNoLongerEmpty() {
+            session.setAttribute("foo", "bar");
+            assertFalse(attrs.isEmpty());
+        }
+
+        @Test
+        void clear_isEmptyAgain() {
+            attrs.put("foo", "bar");
+            attrs.clear();
+            assertTrue(attrs.isEmpty());
+        }
+    }
+
+    @Nested
+    class Get {
+
+        @Test
+        void emptyMap_returnsNull() {
+            assertNull(attrs.get("foo"));
+        }
+
+        @Test
+        void unknownKey_returnsNull() {
+            session.setAttribute("foo", "bar");
+            assertNull(attrs.get("bar"));
+        }
+
+        @Test
+        void keySetOnSession_returnsItsValue() {
+            session.setAttribute("foo", "bar");
+            assertEquals("bar", attrs.get("foo"));
+        }
+
+        @Test
+        void removedKey_returnsNull() {
+            session.setAttribute("foo", "bar");
+            attrs.remove("foo");
+            assertNull(attrs.get("foo"));
+        }
+    }
+
+    @Nested
+    class Remove {
+
+        @Test
+        void emptyMap_returnsNull() {
+            assertNull(attrs.remove("foo"));
+            assertTrue(attrs.isEmpty());
+        }
+
+        @Test
+        void unknownKey_leavesOtherEntriesAlone() {
+            attrs.put("bar", "foo");
+            assertNull(attrs.remove("foo"));
+            assertEquals("foo", attrs.get("bar"));
+            assertEquals("foo", session.getAttribute("bar"));
+        }
+
+        @Test
+        void existingKey_returnsOldValueAndClearsTheSessionAttribute() {
+            attrs.put("bar", "foo");
+            assertEquals("foo", attrs.remove("bar"));
+            assertTrue(attrs.isEmpty());
+            assertNull(session.getAttribute("bar"));
+        }
+    }
+
+    @Nested
+    class Clear {
+
+        @Test
+        void emptyMap_staysEmpty() {
+            attrs.clear();
+            assertTrue(attrs.isEmpty());
+        }
+
+        @Test
+        void singleEntry_isRemoved() {
+            attrs.put("foo", "bar");
+            attrs.clear();
+            assertTrue(attrs.isEmpty());
+        }
+
+        @Test
+        void manyEntries_allClearedFromTheSession() {
+            for (int i = 0; i <= 1000; i++) {
+                session.setAttribute(Integer.toString(i), i);
+            }
+            assertFalse(attrs.isEmpty());
+            attrs.clear();
+            assertTrue(attrs.isEmpty());
+            for (int i = 0; i <= 1000; i++) {
+                assertNull(session.getAttribute(Integer.toString(i)));
+            }
+        }
+    }
+}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/TestInitListener.kt b/junit6/src/test/kotlin/com/vaadin/browserless/TestInitListener.kt
deleted file mode 100644
index 5e536755..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/TestInitListener.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless
-
-import com.vaadin.flow.server.ServiceInitEvent
-import com.vaadin.flow.server.VaadinServiceInitListener
-
-/**
- * This class is picked up automatically by Vaadin (since it's registered via META-INF/services). We then test elsewhere
- * that MockVaadin-mocked env indeed picked up this init listener and executed it.
- */
-class TestInitListener : VaadinServiceInitListener {
-    override fun serviceInit(event: ServiceInitEvent) {
-        serviceInitCalled = true
-        event.source.addUIInitListener { e ->
-            uiInitCalled = true
-            e.ui.addBeforeEnterListener { uiBeforeEnterCalled = true }
-        }
-    }
-
-    companion object {
-        var serviceInitCalled: Boolean = false
-        var uiInitCalled = false
-        var uiBeforeEnterCalled = false
-        fun clearInitFlags() {
-            serviceInitCalled = false
-            uiInitCalled = false
-            uiBeforeEnterCalled = false
-        }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/TestUtils.kt b/junit6/src/test/kotlin/com/vaadin/browserless/TestUtils.kt
deleted file mode 100644
index 9db790d9..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/TestUtils.kt
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless
-
-import kotlin.reflect.KClass
-import kotlin.test.assertFailsWith
-import com.vaadin.browserless.internal.allViews
-import kotlin.test.expect
-
-/**
- * Expects that [actual] list of objects matches [expected] list of objects. Fails otherwise.
- */
-fun <T> expectList(vararg expected: T, actual: ()->List<T>) {
-    expect(expected.toList(), actual)
-}
-
-
-/**
- * Expects that given block fails with an exception of type [clazz] (or its subtype).
- *
- * Note that this is different from [assertFailsWith] since this function
- * also asserts on [Throwable.message].
- * @param expectMessage regular expression which the [Throwable.message] must match.
- * @throws AssertionError if the block completed successfully or threw some other exception.
- * @return the exception thrown, so that you can assert on it.
- */
-fun <T: Throwable> expectThrows(clazz: KClass<out T>, expectMessage: Regex, block: ()->Unit): T {
-    // tests for this function are present in the dynatest-engine project
-    val ex = assertFailsWith(clazz, block)
-    if (!(ex.message ?: "").contains(expectMessage)) {
-        throw AssertionError("${clazz.javaObjectType.name} message: Expected '$expectMessage' but was '${ex.message}'", ex)
-    }
-    return ex
-}
-
-/**
- * Expects that given block fails with an exception of type [T] (or its subtype).
- *
- * Note that this is different from [assertFailsWith] since this function
- * also asserts on [Throwable.message].
- * @param expectMessage regular expression which the [Throwable.message] must match.
- * @throws AssertionError if the block completed successfully or threw some other exception.
- * @return the exception thrown, so that you can assert on it.
- */
-inline fun <reified T: Throwable> expectThrows(expectMessage: Regex, noinline block: ()->Unit): T =
-    expectThrows(T::class, expectMessage, block)
-
-
-object TestRoutes {
-    val views = allViews;
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
deleted file mode 100644
index f3dd4b82..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.github.mvysny.dynatest.DynaTest
-import java.net.URL
-import java.util.*
-import kotlin.test.expect
-import com.vaadin.flow.component.button.Button
-
-class AllTests : DynaTest({
-
-    beforeEach {
-        // make sure that Validator produces messages in English
-        Locale.setDefault(Locale.ENGLISH)
-    }
-
-    test("flow-build-info.json doesn't exist") {
-        val res: URL? = Thread.currentThread().contextClassLoader.getResource("META-INF/VAADIN/config/flow-build-info.json")
-        expect(null, "flow-build-info.json exists on the classpath!") { res }
-    }
-
-    group("Depth First Tree Iterator") {
-        depthFirstTreeIteratorTests()
-    }
-
-    group("basic utils") {
-        basicUtilsTestbatch()
-    }
-
-    group("Element Utils") {
-        elementUtilsTests()
-    }
-
-    group("Component Utils") {
-        componentUtilsTests()
-    }
-
-    group("routes test") {
-        routesTestBatch()
-    }
-
-    group("mock vaadin") {
-        mockVaadinTest()
-    }
-
-    group("pretty print tree") {
-        prettyPrintTreeTest()
-    }
-
-    group("locator") {
-        group("with lifecycle hook testing") {
-            locatorTest()
-        }
-        group("no lifecycle hook testing") {
-            locatorTest2()
-        }
-    }
-
-    group("Composite") {
-        compositeTests()
-    }
-
-    group("search spec") {
-        searchSpecTest()
-    }
-
-    group("shortcuts") {
-        shortcutsTestBatch()
-    }
-
-    test("Component.isTemplate does not fail without polymer templates dependency") {
-        expect(false) { TestingLifecycleHook.isTemplate(Button("foo")) }
-    }
-
-
-})
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AsyncTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/AsyncTest.kt
deleted file mode 100644
index 019ebaa1..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/AsyncTest.kt
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.expectThrows
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.server.*
-import java.util.concurrent.ExecutionException
-import java.util.concurrent.ExecutorService
-import java.util.concurrent.Executors
-import java.util.concurrent.TimeUnit
-import kotlin.test.expect
-import kotlin.test.fail
-
-internal fun DynaNodeGroup.asyncTestbatch() {
-    group("from UI thread") {
-        test("calling access() won't throw exception but the block won't be called immediately") {
-            var checkAccess = true
-            UI.getCurrent().access { if (checkAccess) fail("Shouldn't be called now") }
-            checkAccess = false
-        }
-
-        test("calling accessSynchronously() calls the block immediately because the tests hold UI lock") {
-            var called = false
-            UI.getCurrent().accessSynchronously { called = true }
-            expect(true) { called }
-        }
-
-        /* TODO: uncomment after importing Locator APIs
-        test("_get() processes access()") {
-            var called = false
-            UI.getCurrent().access { called = true }
-            expect(false) { called }
-            _get<UI>()
-            expect(true) { called }
-        }
-         */
-
-        test("clientRoundtrip() processes all access() calls") {
-            var calledCount = 0
-            UI.getCurrent().access(object : Command {
-                override fun execute() {
-                    if (calledCount < 4) {
-                        calledCount++
-                        UI.getCurrent().access(this)
-                    }
-                }
-            })
-            expect(0) { calledCount }
-            MockVaadin.clientRoundtrip()
-            expect(4) { calledCount }
-        }
-
-        test("clientRoundtrip() propagates failures") {
-            UI.getCurrent().access { throw RuntimeException("simulated") }
-            expectThrows(ExecutionException::class, "simulated") {
-                MockVaadin.clientRoundtrip()
-            }
-        }
-
-        test("access() has properly mocked instances") {
-            UI.getCurrent().access {
-                expect(true) { VaadinSession.getCurrent() != null }
-                expect(true) { VaadinService.getCurrent() != null }
-                expect(true) { UI.getCurrent() != null }
-                // Request and response are never available in access() commands
-                expect(true) { VaadinRequest.getCurrent() == null }
-                expect(true) { VaadinResponse.getCurrent() == null }
-            }
-            MockVaadin.clientRoundtrip()
-        }
-
-        // https://github.com/mvysny/karibu-testing/issues/80
-        test("push() does nothing but can be called") {
-            UI.getCurrent().push()
-            UI.getCurrent().access {
-                UI.getCurrent().push()
-            }
-            MockVaadin.clientRoundtrip()
-            UI.getCurrent().accessSynchronously {
-                UI.getCurrent().push()
-            }
-        }
-    }
-    group("from bg thread") {
-        lateinit var executor: ExecutorService
-        beforeEach { executor = Executors.newCachedThreadPool() }
-        afterEach {
-            executor.shutdown()
-            executor.awaitTermination(4, TimeUnit.SECONDS)
-        }
-        fun asyncAwait(block: (UI) -> Unit) {
-            val ui = UI.getCurrent()
-            executor.submit { block(ui) } .get()
-        }
-
-        test("calling access() won't throw exception but the block won't be called immediately because the tests hold UI lock") {
-            asyncAwait { ui ->
-                var checkAccess = true
-                ui.access { if (checkAccess) fail("Shouldn't be called now") }
-                checkAccess = false
-            }
-        }
-
-        test("clientRoundtrip() processes all access() calls") {
-            var calledCount = 0
-           asyncAwait { ui ->
-                ui.access(object : Command {
-                    override fun execute() {
-                        if (calledCount < 4) {
-                            calledCount++
-                            UI.getCurrent().access(this)
-                        }
-                    }
-                })
-            }
-            expect(0) { calledCount }
-            MockVaadin.clientRoundtrip()
-            expect(4) { calledCount }
-        }
-
-        test("access() has properly mocked instances") {
-            asyncAwait { ui ->
-                ui.access {
-                    expect(true) { VaadinSession.getCurrent() != null }
-                    expect(true) { VaadinService.getCurrent() != null }
-                    expect(true) { UI.getCurrent() != null }
-                    // Request and response are never available in access() commands
-                    expect(true) { VaadinRequest.getCurrent() == null }
-                    expect(true) { VaadinResponse.getCurrent() == null }
-                }
-            }
-            MockVaadin.clientRoundtrip()
-        }
-
-        // https://github.com/mvysny/karibu-testing/issues/80
-        test("push() does nothing but can be called") {
-            asyncAwait { ui ->
-                ui.access {
-                    UI.getCurrent().push()
-                }
-            }
-            MockVaadin.clientRoundtrip()
-        }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt
deleted file mode 100644
index 0b3189ab..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.kt
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.karibudsl.v10.textField
-import com.vaadin.browserless.expectThrows
-import com.vaadin.browserless.internal.BasicUtils._blur
-import com.vaadin.browserless.internal.BasicUtils._fireDomEvent
-import com.vaadin.browserless.internal.BasicUtils._focus
-import com.vaadin.browserless.internal.BasicUtils.checkEditableByUser
-import com.vaadin.browserless.internal.BasicUtils.expectNotEditableByUser
-import com.vaadin.flow.component.ClickEvent
-import com.vaadin.flow.component.html.Div
-import com.vaadin.flow.component.orderedlayout.VerticalLayout
-import com.vaadin.flow.component.textfield.TextField
-import com.vaadin.flow.dom.DomEvent
-import com.vaadin.flow.internal.JacksonUtils
-import kotlin.test.expect
-
-@DynaTestDsl
-internal fun DynaNodeGroup.basicUtilsTestbatch() {
-
-    group("checkEditableByUser") {
-        test("disabled textfield fails") {
-            expectThrows(java.lang.IllegalStateException::class, "The AttachedTextField\\[DISABLED,.*] is not enabled".toRegex()) {
-                checkEditableByUser(AttachedTextField().apply { isEnabled = false })
-            }
-        }
-        test("invisible textfield fails") {
-            expectThrows(
-                java.lang.IllegalStateException::class,
-                "The AttachedTextField\\[INVIS,.*] is not effectively visible".toRegex()
-            ) {
-                checkEditableByUser(AttachedTextField().apply { isVisible = false })
-            }
-        }
-        test("non attached textfield fails") {
-            expectThrows(
-                java.lang.IllegalStateException::class,
-                "The TextField\\[.*] is not attached".toRegex()
-            ) {
-                checkEditableByUser(TextField())
-            }
-        }
-        test("textfield in invisible layout fails") {
-            expectThrows(java.lang.IllegalStateException::class, "The TextField\\[.*] is not effectively visible".toRegex()) {
-                VerticalLayout().apply {
-                    isVisible = false
-                    textField().also { checkEditableByUser(it) }
-                }
-            }
-        }
-        test("textfield succeeds") {
-            checkEditableByUser(AttachedTextField())
-        }
-    }
-
-    group("expectNotEditableByUser") {
-        test("disabled textfield fails") {
-            expectNotEditableByUser(AttachedTextField().apply { isEnabled = false })
-        }
-        test("invisible textfield fails") {
-            expectNotEditableByUser(AttachedTextField().apply { isVisible = false })
-        }
-        test("textfield in invisible layout fails") {
-            VerticalLayout().apply {
-                isVisible = false
-                textField().also { expectNotEditableByUser(it) }
-            }
-        }
-        test("textfield succeeds") {
-            expectThrows(AssertionError::class, "The AttachedTextField\\[.*] is editable".toRegex()) {
-                expectNotEditableByUser(AttachedTextField())
-            }
-        }
-    }
-
-    group("fireDomEvent()") {
-        test("smoke") {
-            _fireDomEvent(Div(), "click")
-        }
-        test("listeners are called") {
-            val div = Div()
-            lateinit var event: DomEvent
-            div.element.addEventListener("click") { e -> event = e }
-            _fireDomEvent(div, "click")
-            expect("click") { event.type }
-        }
-        test("higher-level listeners are called") {
-            val div = Div()
-            lateinit var event: ClickEvent<Div>
-            div.addClickListener { e -> event = e }
-            _fireDomEvent(div, "click", JacksonUtils.createObjectNode().apply { put("event.screenX", 20.0) })
-            expect(20) { event.screenX }
-            expect(true) { event.isFromClient }
-        }
-    }
-
-    test("_focus") {
-        val f = AttachedTextField()
-        var called = false
-        f.addFocusListener { called = true }
-        _focus(f)
-        expect(true) { called }
-    }
-
-    test("_blur") {
-        val f = AttachedTextField()
-        var called = false
-        f.addBlurListener { called = true }
-        _blur(f)
-        expect(true) { called }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt
deleted file mode 100644
index 5168ff6b..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.expectThrows
-import com.vaadin.browserless.internal.BasicUtils._text
-import com.vaadin.browserless.internal.ComponentUtils.addClassNames2
-import com.vaadin.browserless.internal.ComponentUtils.addContextMenuListener
-import com.vaadin.browserless.internal.ComponentUtils.caption
-import com.vaadin.browserless.internal.ComponentUtils.findAncestor
-import com.vaadin.browserless.internal.ComponentUtils.findAncestorOrSelf
-import com.vaadin.browserless.internal.ComponentUtils.hasChildren
-import com.vaadin.browserless.internal.ComponentUtils.insertBefore
-import com.vaadin.browserless.internal.ComponentUtils.isAttached
-import com.vaadin.browserless.internal.ComponentUtils.isNestedIn
-import com.vaadin.browserless.internal.ComponentUtils.label
-import com.vaadin.browserless.internal.ComponentUtils.placeholder
-import com.vaadin.browserless.internal.ComponentUtils.removeClassNames2
-import com.vaadin.browserless.internal.ComponentUtils.removeFromParent
-import com.vaadin.browserless.internal.ComponentUtils.serverClick
-import com.vaadin.browserless.internal.ComponentUtils.setClassNames2
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.Text
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.checkbox.Checkbox
-import com.vaadin.flow.component.formlayout.FormLayout
-import com.vaadin.flow.component.html.Div
-import com.vaadin.flow.component.html.Span
-import com.vaadin.flow.component.orderedlayout.FlexLayout
-import com.vaadin.flow.component.orderedlayout.HorizontalLayout
-import com.vaadin.flow.component.textfield.TextArea
-import com.vaadin.flow.component.textfield.TextField
-import kotlin.test.expect
-
-fun DynaNodeGroup.componentUtilsTests() {
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-    group("removeFromParent()") {
-        test("component with no parent") {
-            val t = Text("foo")
-            removeFromParent(t)
-            expect(null) { t.parent.orElse(null) }
-        }
-        test("nested component") {
-            val fl = FlexLayout().apply { add(Span("foo")) }
-            val label = fl.getComponentAt(0)
-            expect(fl) { label.parent.get() }
-            removeFromParent(label)
-            expect(null) { label.parent.orElse(null) }
-            expect(0) { fl.componentCount }
-        }
-        test("reattach") {
-            val fl = FlexLayout().apply { add(Span("foo")) }
-            val label = fl.getComponentAt(0)
-            removeFromParent(label)
-            fl.add(label)
-            expect(fl) { label.parent.orElse(null) }
-            expect(1) { fl.componentCount }
-        }
-    }
-
-    test("serverClick()") {
-        val b = Button()
-        var clicked = 0
-        b.addClickListener { clicked++ }
-        serverClick(b)
-        expect(1) { clicked }
-    }
-
-    test("tooltip") {
-        val b = Button()
-        expect(null) { b.tooltip.text }
-        b.setTooltipText("")
-        expect<String?>("") { b.tooltip.text } // https://youtrack.jetbrains.com/issue/KT-32501
-        b.setTooltipText("foo")
-        expect<String?>("foo") { b.tooltip.text } // https://youtrack.jetbrains.com/issue/KT-32501
-        b.setTooltipText(null)
-        expect(null) { b.tooltip.text }
-    }
-
-    test("addContextMenuListener smoke") {
-        addContextMenuListener(Button(), {})
-    }
-
-    group("findAncestor") {
-        test("null on no parent") {
-            expect(null) { findAncestor(Button()) { false } }
-        }
-        test("null on no acceptance") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(null) { findAncestor(button) { false } }
-        }
-        test("finds UI") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(UI.getCurrent()) { findAncestor(button) { it is UI } }
-        }
-        test("doesn't find self") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(UI.getCurrent()) { findAncestor(button) { true } }
-        }
-    }
-
-    group("findAncestorOrSelf") {
-        test("null on no parent") {
-            expect(null) { findAncestorOrSelf(Button()) { false } }
-        }
-        test("null on no acceptance") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(null) { findAncestorOrSelf(button) { false } }
-        }
-        test("finds self") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(button) { findAncestorOrSelf(button) { true } }
-        }
-    }
-
-    test("isNestedIn") {
-        expect(false) { isNestedIn(Button(), UI.getCurrent()) }
-        val button = Button()
-        UI.getCurrent().add(button)
-        expect(true) { isNestedIn(button, UI.getCurrent()) }
-    }
-
-    test("isAttached") {
-        expect(true) { isAttached(UI.getCurrent()) }
-        expect(false) { isAttached(Button("foo")) }
-        expect(true) {
-            val button = Button()
-            UI.getCurrent().add(button)
-            isAttached(button)
-        }
-        UI.getCurrent().close()
-        expect(true) { isAttached(UI.getCurrent()) }
-    }
-
-    test("insertBefore") {
-        val l = HorizontalLayout()
-        val first = Span("first")
-        l.addComponentAsFirst(first)
-        val second = Span("second")
-        insertBefore(l, second, first)
-        expect("second, first") { l.children.toList().map { _text(it) } .joinToString() }
-        insertBefore(l, Span("third"), first)
-        expect("second, third, first") { l.children.toList().map { _text(it) } .joinToString() }
-    }
-
-    test("hasChildren") {
-        val l = HorizontalLayout()
-        expect(false) { hasChildren(l) }
-        l.addComponentAsFirst(Span("first"))
-        expect(true) { hasChildren(l) }
-        l.removeAll()
-        expect(false) { hasChildren(l) }
-    }
-
-    group("classnames2") {
-        test("addClassNames2") {
-            val div = Div().apply { addClassNames2(this, "foo  bar    baz") }
-            expect(true) {
-                div.classNames.containsAll(listOf("foo", "bar", "baz"))
-            }
-        }
-        test("addClassNames2(vararg)") {
-            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
-            expect(true) {
-                div.classNames.containsAll(listOf("foo", "bar", "baz", "one", "two"))
-            }
-        }
-        test("setClassNames2") {
-            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
-            setClassNames2(div, "  three four  ")
-            expect(true) {
-                div.classNames.containsAll(listOf("three", "four"))
-            }
-        }
-        test("setClassNames2(vararg)") {
-            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
-            setClassNames2(div, "  three ", "four  ")
-            expect(true) {
-                div.classNames.containsAll(listOf("three", "four"))
-            }
-        }
-        test("removeClassNames2") {
-            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
-            removeClassNames2(div, "  bar baz  ")
-            expect(true) {
-                div.classNames.containsAll(listOf("foo", "one", "two"))
-            }
-        }
-        test("removeClassNames2(vararg)") {
-            val div = Div().apply { addClassNames2(this, "foo  bar    baz", "  one  two") }
-            removeClassNames2(div, "  bar ", "baz  ")
-            expect(true) {
-                div.classNames.containsAll(listOf("foo", "one", "two"))
-            }
-        }
-    }
-
-    test("placeholder") {
-        var c: Component = TextField().apply { setPlaceholder("foo") }
-        expect("foo") { placeholder(c) }
-        placeholder(c, "")
-        expect("") { placeholder(c) }
-        c = TextArea().apply { setPlaceholder("foo") }
-        expect("foo") { placeholder(c) }
-        placeholder(c, "")
-        expect("") { placeholder(c) }
-        c = Button() // doesn't support placeholder
-        expect(null) { placeholder(c) }
-        expectThrows(IllegalStateException::class, "Button doesn't support setting placeholder") {
-            placeholder(c, "foo")
-        }
-    }
-
-    group("label") {
-        test("TextField") {
-            val c: Component = TextField()
-            expect("") { label(c) }
-            label(c, "foo")
-            expect("foo") { label(c) }
-            label(c, "")
-            expect("") { label(c) }
-        }
-        test("Checkbox") {
-            val c: Component = Checkbox()
-            expect("") { label(c) }
-            label(c, "foo")
-            expect("foo") { label(c) }
-            label(c, "")
-            expect("") { label(c) }
-        }
-    }
-
-    test("caption") {
-        var c: Component = Button("foo")
-        expect("foo") { caption(c) }
-        caption(c, "")
-        expect("") { caption(c) }
-        c = Checkbox().also { caption(it, "foo") }
-        expect("foo") { caption(c) }
-        caption(c, "")
-        expect("") { caption(c) }
-        expect("") { label(FormLayout.FormItem()) }
-        val fl = FormLayout()
-        c = fl.addFormItem(Button(), "foo")
-        expect("foo") { caption(c) }
-    }
-
-    test("Button.caption") {
-        val c = Button("foo")
-        expect("foo") { caption(c) }
-        caption(c, "")
-        expect("") { caption(c) }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/CompositeTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/CompositeTest.kt
deleted file mode 100644
index dd45c09b..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/CompositeTest.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.Composite
-import com.vaadin.flow.component.Tag
-import com.vaadin.flow.component.html.Span
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-
-@DynaTestDsl
-internal fun DynaNodeGroup.compositeTests() {
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-    test("Composite<*> causes virtual children to be fetched twice") {
-        class MyComposite : Composite<VirtualChildComponent>()
-
-        val comp = MyComposite()
-        comp._expectOne<Span> { text = "virtual child" }
-    }
-}
-
-@Tag("my-test")
-class VirtualChildComponent : Component() {
-    init {
-        val child = Span("virtual child")
-        element.appendVirtualChild(child.element)
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt
deleted file mode 100644
index f2c05426..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/DepthFirstTreeIteratorTest.kt
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import kotlin.test.expect
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.html.Span
-import com.vaadin.flow.component.orderedlayout.HorizontalLayout
-import com.vaadin.flow.component.orderedlayout.VerticalLayout
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.expectList
-import com.vaadin.flow.component.Text
-
-fun DynaNodeGroup.depthFirstTreeIteratorTests() {
-    test("DepthFirstTreeIterator") {
-        val i = DepthFirstTreeIterator("0") { if (it.length > 2) listOf() else listOf("${it}0", "${it}1", "${it}2")}
-        expectList("0", "00", "000", "001", "002", "01", "010", "011", "012", "02", "020", "021", "022") { i.asSequence().toList() }
-    }
-
-    test("walk") {
-        val expected = mutableListOf<Component>()
-        val root = VerticalLayout().apply {
-            expected.add(this)
-            add(Button("Foo").apply {
-                expected.add(this)
-                // In Vaadin 25.1, Button also has a text node
-                this.children.filter { it is Text }
-                    .findFirst()
-                    .ifPresent { expected.add(it) }
-            })
-            add(HorizontalLayout().apply {
-                expected.add(this)
-                add(Span().apply { expected.add(this) })
-            })
-            add(VerticalLayout().apply { expected.add(this) })
-        }
-        expect(expected) { DepthFirstTreeIterator.walk(root).toList() }
-        expect(root) { DepthFirstTreeIterator.walk(root).toList()[0] }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt
deleted file mode 100644
index 68b3b9bf..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.vaadin.browserless.expectList
-import com.vaadin.browserless.internal.ElementUtils._fireDomEvent
-import com.vaadin.browserless.internal.ElementUtils.clearSlot
-import com.vaadin.browserless.internal.ElementUtils.getChildrenInSlot
-import com.vaadin.browserless.internal.ElementUtils.getVirtualChildren
-import com.vaadin.browserless.internal.ElementUtils.insertBefore
-import com.vaadin.browserless.internal.ElementUtils.setOrRemoveAttribute
-import com.vaadin.browserless.internal.ElementUtils.textRecursively2
-import com.vaadin.browserless.internal.ElementUtils.toggle
-import com.vaadin.flow.component.Text
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.html.Div
-import com.vaadin.flow.component.html.Paragraph
-import com.vaadin.flow.component.html.Span
-import com.vaadin.flow.component.textfield.TextField
-import com.vaadin.flow.dom.DomEvent
-import com.vaadin.flow.dom.Element
-import com.vaadin.flow.internal.JacksonUtils
-import kotlin.test.expect
-
-fun DynaNodeGroup.elementUtilsTests() {
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-    test("setOrRemoveAttribute") {
-        val t = Div().element
-        expect(null) { t.getAttribute("foo") }
-        setOrRemoveAttribute(t, "foo", "bar")
-        expect("bar") { t.getAttribute("foo") }
-        setOrRemoveAttribute(t, "foo", null)
-        expect(null) { t.getAttribute("foo") }
-    }
-
-    group("toggle class name") {
-        test("add") {
-            val t = Div()
-            toggle(t.classNames, "test")
-            expect(setOf("test")) { t.classNames }
-        }
-        test("remove") {
-            val t = Div()
-            t.classNames.add("test")
-            toggle(t.classNames, "test")
-            expect(setOf<String>()) { t.classNames }
-        }
-    }
-
-    test("insertBefore") {
-        val l = Div().element
-        val first: Element = Span("first").element
-        l.appendChild(first)
-        val second: Element = Span("second").element
-        insertBefore(l, second, first)
-        expect("second, first") { l.children.toList().joinToString { it.text } }
-        insertBefore(l, Span("third").element, first)
-        expect("second, third, first") { l.children.toList().joinToString { it.text } }
-    }
-
-    test("textRecursively2") {
-        expect("foo") { textRecursively2(Span("foo").element) }
-        expect("foobarbaz") {
-            val div = Div()
-            div.add(Span("foo"), Text("bar"), Paragraph("baz"))
-            textRecursively2(div.element)
-        }
-        expect("foo") { textRecursively2(Element("div").apply { setProperty("innerHTML", "foo") }) }
-    }
-
-    group("getVirtualChildren()") {
-        test("initially empty") {
-            expectList<Element>() { getVirtualChildren(Div().element) }
-            expectList<Element>() { getVirtualChildren(Span().element) }
-            expectList<Element>() {
-                val b = Button()
-                UI.getCurrent().add(b)
-                getVirtualChildren(b.element)
-            }
-        }
-        test("add virtual child") {
-            val span = Span().element
-            val parent = Div()
-            parent.element.appendVirtualChild(span)
-            expectList(span) { getVirtualChildren(parent.element) }
-        }
-    }
-
-    test("getChildrenInSlot") {
-        expectList<Element>() { getChildrenInSlot(TextField().element, "prefix") }
-        val div = Div()
-        expectList(div.element) { getChildrenInSlot(TextField().apply { prefixComponent = div }.element, "prefix") }
-    }
-
-    test("clearSlot") {
-        val tf = TextField()
-        tf.prefixComponent = Div()
-        clearSlot(tf.element, "prefix")
-        expectList<Element>() { getChildrenInSlot(tf.element, "prefix") }
-        expect(null) { tf.prefixComponent }
-    }
-
-    test("fireDomEvent() smoke") {
-        val element = Div().element
-        _fireDomEvent(element, DomEvent(element, "click", JacksonUtils.createObjectNode()))
-    }
-
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt
deleted file mode 100644
index 9a28aba3..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorDsl.kt
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-@file:Suppress("FunctionName")
-
-package com.vaadin.browserless.internal
-
-import java.util.function.Consumer
-import com.vaadin.flow.component.Component
-
-/**
- * Kotlin DSL conveniences over the Java [Locator] engine, preserving the
- * `_get<Reified> { id = "foo" }` syntax for the Kotlin tests in this module.
- *
- * Java has no equivalent of `inline fun <reified T>` or of a receiver lambda,
- * so this is test-scope sugar rather than published API: the engine itself
- * takes a `Class<T>` and a `Consumer<SearchSpec<T>>`.
- */
-
-/**
- * Checks whether this component matches given spec. All rules are matched except the [SearchSpec.count] rule. The
- * rules are matched against given component only (not against its children).
- */
-public fun Component.matches(spec: SearchSpec<Component>.() -> Unit): Boolean =
-    SearchSpec(Component::class.java).apply(spec).toPredicate().test(this)
-
-/**
- * Removes nulls and blank strings from this iterable. Used by the Grid pretty-tree
- * dumper; mirrors the helper that used to live in `Locator.kt`.
- */
-public fun Iterable<String?>.filterNotBlank(): List<String> =
-    filterNotNull().filter { it.isNotBlank() }
-
-// ---------------------------------------------------------------------------
-// Inline reified + DSL block conveniences over the Java [Locator] engine.
-// ---------------------------------------------------------------------------
-
-public inline fun <reified T : Component> Component._get(noinline block: SearchSpec<T>.() -> Unit = {}): T =
-    Locator._get(this, T::class.java, Consumer { it.block() })
-
-public inline fun <reified T : Component> _get(noinline block: SearchSpec<T>.() -> Unit = {}): T =
-    Locator._get(T::class.java, Consumer { it.block() })
-
-public inline fun <reified T : Component> Component._find(noinline block: SearchSpec<T>.() -> Unit = {}): List<T> =
-    Locator._find(this, T::class.java, Consumer { it.block() })
-
-public inline fun <reified T : Component> _find(noinline block: SearchSpec<T>.() -> Unit = {}): List<T> =
-    Locator._find(T::class.java, Consumer { it.block() })
-
-public inline fun <reified T : Component> Component._expectNone(noinline block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectNone(this, T::class.java, Consumer { it.block() })
-}
-
-public inline fun <reified T : Component> _expectNone(noinline block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectNone(T::class.java, Consumer { it.block() })
-}
-
-public inline fun <reified T : Component> Component._expectOne(noinline block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectOne(this, T::class.java, Consumer { it.block() })
-}
-
-public inline fun <reified T : Component> _expectOne(noinline block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectOne(T::class.java, Consumer { it.block() })
-}
-
-public inline fun <reified T : Component> Component._expect(count: Int = 1, noinline block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expect(this, T::class.java, count, Consumer { it.block() })
-}
-
-public inline fun <reified T : Component> _expect(count: Int = 1, noinline block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expect(T::class.java, count, Consumer { it.block() })
-}
-
-// ---------------------------------------------------------------------------
-// Non-reified Class-receiving extension overloads. These mirror the original
-// Kotlin signatures so existing Kotlin callers like `button._get(Button::class.java)`
-// keep compiling.
-// ---------------------------------------------------------------------------
-
-public fun <T : Component> Component._get(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): T =
-    Locator._get(this, clazz, Consumer { it.block() })
-
-public fun <T : Component> _get(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): T =
-    Locator._get(clazz, Consumer { it.block() })
-
-public fun <T : Component> Component._find(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): List<T> =
-    Locator._find(this, clazz, Consumer { it.block() })
-
-public fun <T : Component> _find(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}): List<T> =
-    Locator._find(clazz, Consumer { it.block() })
-
-public fun <T : Component> Component._expectNone(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectNone(this, clazz, Consumer { it.block() })
-}
-
-public fun <T : Component> _expectNone(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectNone(clazz, Consumer { it.block() })
-}
-
-public fun <T : Component> Component._expectOne(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectOne(this, clazz, Consumer { it.block() })
-}
-
-public fun <T : Component> _expectOne(clazz: Class<T>, block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expectOne(clazz, Consumer { it.block() })
-}
-
-public fun <T : Component> Component._expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expect(this, clazz, count, Consumer { it.block() })
-}
-
-public fun <T : Component> _expect(clazz: Class<T>, count: Int = 1, block: SearchSpec<T>.() -> Unit = {}) {
-    Locator._expect(clazz, count, Consumer { it.block() })
-}
-
-/**
- * Re-exports a few non-reified helpers under their familiar names so that
- * Kotlin callers don't need to import `Locator`.
- */
-public fun _expectNoDialogs(): Unit = Locator._expectNoDialogs()
-
-public fun _expectInternalServerError(expectedErrorMessage: String = ""): Unit =
-    Locator._expectInternalServerError(expectedErrorMessage)
-
-public val currentPath: String? get() = Locator.currentPath()
-
-public fun Component._walkAll(): Iterable<Component> = Locator._walkAll(this)
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt
deleted file mode 100644
index b514d8cf..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.util.function.Predicate
-import kotlin.streams.asSequence
-import kotlin.test.expect
-import com.vaadin.browserless.internal.BasicUtils.id_
-import com.vaadin.browserless.internal.Utils.currentUI
-import com.vaadin.flow.component.Text
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.combobox.ComboBox
-import com.vaadin.flow.component.dialog.Dialog
-import com.vaadin.flow.component.html.Span
-import com.vaadin.flow.component.orderedlayout.VerticalLayout
-import com.vaadin.flow.component.textfield.PasswordField
-import com.vaadin.flow.component.textfield.TextField
-import com.vaadin.browserless.expectList
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.dynatest.expectThrows
-import com.github.mvysny.karibudsl.v10.button
-import com.github.mvysny.karibudsl.v10.text
-import com.github.mvysny.karibudsl.v10.textField
-import com.github.mvysny.karibudsl.v10.verticalLayout
-
-@DynaTestDsl
-internal fun DynaNodeGroup.locatorTest2() {
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-    test("_expectNoDialogs()") {
-        _expectNoDialogs() // should succeed on no dialogs
-        val dlg = Dialog()
-        dlg.open()
-        val exception = expectThrows(AssertionError::class,
-            "Too many visible Dialogs (1) in MockedUI[] matching Dialog and count=0..0:") {
-            _expectNoDialogs()
-        }
-        expect(true) {
-            val msg = exception.message!!
-            println(msg)
-            msg.matches(""".*Too many visible Dialogs \(1\) in MockedUI\[] matching Dialog and count=0\.\.0: \[Dialog\[.*]]\. Component tree:
-└── MockedUI\[]
-\s+└── Dialog\[.*].*
-""".toRegex(RegexOption.MULTILINE)
-            )
-        }
-        dlg.close()
-        _expectNoDialogs()
-    }
-
-    group("InternalServerError handling") {
-        test("component lookup fails on navigation error") {
-            // Vaadin shows InternalServerError when an exception occurs during the navigation phase.
-            // the _expect*() functions should detect this and fail fast.
-            currentUI().addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
-            UI.getCurrent().navigate("")
-            expectThrows<AssertionError>("An internal server error occurred; please check log for the actual stack-trace. Error text: There was an exception while trying to navigate to") {
-                _expectOne<UI>()
-            }
-        }
-        group("_expectInternalServerError") {
-            test("fails on no error") {
-                expectThrows<java.lang.AssertionError>(
-                    """Expected an internal server error but none happened. Component tree:
-└── MockedUI[]"""
-                ) { _expectInternalServerError() }
-            }
-            test("succeeds on error") {
-                currentUI().addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
-                UI.getCurrent().navigate("")
-                _expectInternalServerError()
-            }
-            test("matches error message correctly") {
-                currentUI().addBeforeEnterListener { event -> event.rerouteToError(RuntimeException("Simulated"), "Simulated") }
-                UI.getCurrent().navigate("")
-                _expectInternalServerError("Simulated")
-            }
-        }
-    }
-}
-
-@DynaTestDsl
-internal fun DynaNodeGroup.locatorTest() {
-
-    beforeEach { MockVaadin.setup() }
-    beforeEach { TestingLifecycleHooks.setCurrent(MyLifecycleHook()) }
-    afterEach { TestingLifecycleHooks.setCurrent(TestingLifecycleHook.DEFAULT) }
-    afterEach { MockVaadin.tearDown() }
-
-    group("_get") {
-        test("fails when no component match") {
-            expectThrows(AssertionError::class) {
-                Button()._get(TextField::class.java)
-            }
-            expectAfterLookupCalled()
-        }
-
-        test("fail when multiple component match") {
-            expectThrows(AssertionError::class) {
-                UI.getCurrent().verticalLayout {
-                    verticalLayout { }
-                }._get(VerticalLayout::class.java)
-            }
-            expectAfterLookupCalled()
-        }
-
-        test("ReturnsSelf") {
-            val button = Button()
-            expect(button) { button._get(Button::class.java) }
-            expectAfterLookupCalled()
-        }
-
-        test("ReturnsNested") {
-            val button = Button()
-            expect(button) { VerticalLayout(button)._get(Button::class.java) }
-            expectAfterLookupCalled()
-        }
-
-        test("fails on invisible") {
-            val button = Button().apply { isVisible = false }
-            expectThrows(java.lang.AssertionError::class) { button._get(Button::class.java) }
-            expectAfterLookupCalled()
-        }
-    }
-
-    group("_find") {
-        test("findMatchingId") {
-            val button = Button().also { id_(it, "foo") }
-            expectList(button) { VerticalLayout(button, Button())._find<Button> { id = "foo" } }
-            expectAfterLookupCalled()
-        }
-
-        test("doesn't return invisible") {
-            val button = Button().apply { isVisible = false }
-            expectList() { button._find(Button::class.java) }
-            expectAfterLookupCalled()
-        }
-
-        test("returns nested") {
-            val vl = VerticalLayout().apply { verticalLayout {} }
-            expect(2) { vl._find(VerticalLayout::class.java).size }
-            expectAfterLookupCalled()
-        }
-    }
-
-    group("_expectNone") {
-        test("succeeds when no component match") {
-            Button()._expectNone<TextField>()
-            expectAfterLookupCalled()
-        }
-
-        test("fail when multiple component match") {
-            expectThrows(AssertionError::class) {
-                UI.getCurrent().verticalLayout {
-                    verticalLayout { }
-                }._expectNone<VerticalLayout>()
-                expectAfterLookupCalled()
-            }
-        }
-
-        test("fails if self matches") {
-            val button = Button()
-            expectThrows(AssertionError::class) { button._expectNone<Button>() }
-            expectAfterLookupCalled()
-        }
-
-        test("fails if nested matches") {
-            val button = Button()
-            expectThrows(AssertionError::class) { VerticalLayout(button)._expectNone<Button>() }
-            expectAfterLookupCalled()
-        }
-    }
-
-    test("simpleUITest") {
-        lateinit var layout: VerticalLayout
-        layout = UI.getCurrent().verticalLayout {
-            val name = textField("Type your name here:")
-            button("Click Me") {
-                addClickListener {
-                    println("Thanks ${name.value}, it works!")
-                    layout.text("Thanks ${name.value}, it works!")
-                }
-            }
-        }
-
-        _get<TextField> { caption = "Type your name here:" }.value = "Baron Vladimir Harkonnen"
-        expectAfterLookupCalled()
-
-        // TODO: uncomment after importing _click() method
-        // _get<Button> { caption = "Click Me" }._click()
-        _get<Button> { caption = "Click Me" }.click()
-        expectAfterLookupCalled()
-
-        expect("Thanks Baron Vladimir Harkonnen, it works!") { _get<Text>{
-            // Since Vaadin 25.1, Button contains a Text child
-            this.predicates.add { textComponent -> textComponent.parent.filter { (it is Button) }.isEmpty }
-        }.text }
-        expectAfterLookupCalled()
-        _get<TextField> { value = "Baron Vladimir Harkonnen" }  // test lookup by value
-        expectAfterLookupCalled()
-        expect("Thanks Baron Vladimir Harkonnen, it works!") { (layout.children.asSequence().last() as Text).text }
-        expect(3) { layout.componentCount }
-    }
-
-    group("matcher") {
-        test("id") {
-            expect(true) { Button().matches { } }
-            expect(false) { Button().matches { id = "a" } }
-            expect(true) { Button().also { id_(it, "a") } .matches { } }
-            expect(true) { Button().also { id_(it, "a") } .matches { id = "a" } }
-            expect(false) { Button().also { id_(it, "a b") } .matches { id = "a" } }
-            expect(false) { Button().also { id_(it, "a") } .matches { id = "a b" } }
-        }
-        test("caption") {
-            expect(true) { Button("click me").matches { caption = "click me" } }
-            expect(true) { TextField("name:").matches { caption = "name:" } }
-            expect(true) { Button("click me").matches { } }
-            expect(true) { TextField("name:").matches { } }
-            expect(false) { Button("click me").matches { caption = "Click Me" } }
-            expect(false) { TextField("name:").matches { caption = "Name"} }
-        }
-        test("placeholder") {
-            expect(true) { TextField("name", "the name").matches { placeholder = "the name" } }
-            expect(true) { PasswordField("password", "at least 6 characters").matches { placeholder = "at least 6 characters" } }
-            expect(true) { ComboBox<String>().apply { placeholder = "foo" }.matches { placeholder = "foo" } }
-            expect(false) { TextField("name", "the name").matches { placeholder = "name" } }
-            expect(false) { PasswordField("password", "at least 6 characters").matches { placeholder = "password" } }
-        }
-        test("value") {
-            expect(true) { TextField(null, "Mannerheim", "placeholder").matches { value = "Mannerheim" } }
-            expect(false) { TextField("Mannerheim").matches { value = "Mannerheim" } }
-        }
-        test("styles") {
-            expect(true) { Button().apply { addClassNames("a", "b") } .matches { } }
-            expect(true) { Button().apply { addClassNames("a", "b") } .matches { classes = "a" } }
-            expect(true) { Button().apply { addClassNames("a", "b") } .matches { classes = "b" } }
-            expect(true) { Button().apply { addClassNames("a", "b") } .matches { classes = "a b" } }
-            expect(false) { Button().apply { addClassNames("a", "b") } .matches { classes = "a c" } }
-            expect(false) { Button().apply { addClassNames("a", "b") } .matches { classes = "c" } }
-        }
-        test("withoutStyles") {
-            expect(true) { Button().apply { addClassNames("a", "b") } .matches { } }
-            expect(false) { Button().apply { addClassNames("a", "b") } .matches { withoutClasses = "a" } }
-            expect(false) { Button().apply { addClassNames("a", "b") } .matches { withoutClasses = "b" } }
-            expect(false) { Button().apply { addClassNames("a", "b") } .matches { withoutClasses = "a b" } }
-            expect(false) { Button().apply { addClassNames("a", "b") } .matches { withoutClasses = "a c" } }
-            expect(true) { Button().apply { addClassNames("a", "b") } .matches { withoutClasses = "c" } }
-        }
-        test("predicates") {
-            expect(true) { Button().matches {}}
-            expect(false) { Button().matches { predicates.add(Predicate { false }) }}
-        }
-        test("themes") {
-            expect(true) { Button().apply { addThemeNames("custom-theme", "my-theme") }.matches {} }
-            expect(true) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }.matches { themes = "custom-theme" }
-            }
-            expect(true) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }.matches { themes = "my-theme" }
-            }
-            expect(true) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }
-                    .matches { themes = "custom-theme my-theme" }
-            }
-            expect(false) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }.matches { themes = "no-theme" }
-            }
-        }
-        test("withoutThemes") {
-            expect(true) { Button().apply { addThemeNames("custom-theme", "my-theme") }.matches {} }
-            expect(false) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }.matches { withoutThemes = "custom-theme" }
-            }
-            expect(false) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }.matches { withoutThemes = "my-theme" }
-            }
-            expect(false) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }
-                    .matches { withoutThemes = "custom-theme my-theme" }
-            }
-            expect(true) {
-                Button().apply { addThemeNames("custom-theme", "my-theme") }.matches { withoutThemes = "no-theme" }
-            }
-        }
-    }
-
-    group("unmocked env") {
-        beforeEach { MockVaadin.tearDown(); TestingLifecycleHooks.setCurrent(TestingLifecycleHook.DEFAULT) }
-        test("lookup functions should work in unmocked environment") {
-            Button()._get(Button::class.java)
-            expectThrows(AssertionError::class) {
-                Button()._get(TextField::class.java)
-            }
-        }
-    }
-
-    group("_expectOne") {
-        test("FailsOnNoComponents UI") {
-            expectThrows(AssertionError::class) {
-                _expectOne(Button::class.java)
-            }
-            expectAfterLookupCalled()
-        }
-
-        test("FailsOnNoComponents") {
-            expectThrows(AssertionError::class) {
-                Button()._expectOne(Span::class.java)
-            }
-            expectAfterLookupCalled()
-        }
-
-        test("fails when multiple components match") {
-            expectThrows(AssertionError::class) {
-                UI.getCurrent().verticalLayout {
-                    verticalLayout { }
-                }._expectOne(VerticalLayout::class.java)
-            }
-            expectAfterLookupCalled()
-        }
-
-        test("selects self") {
-            Button()._expectOne(Button::class.java)
-            expectAfterLookupCalled()
-        }
-
-        test("returns nested") {
-            VerticalLayout(Button())._expectOne(Button::class.java)
-            expectAfterLookupCalled()
-        }
-
-        test("spec") {
-            expectThrows(AssertionError::class) {
-                Button("foo")._expectOne<Button> { caption = "bar" }
-            }
-            expectAfterLookupCalled()
-            expectThrows(AssertionError::class) {
-                Button("foo")._expectOne(Button::class.java) { caption = "bar" }
-            }
-        }
-    }
-
-    group("_expect") {
-        test("FailsOnNoComponents UI") {
-            expectThrows(AssertionError::class) { _expect<Span>() }
-            expectAfterLookupCalled()
-        }
-
-        test("FailsOnNoComponents") {
-            expectThrows(AssertionError::class) { Button()._expect<Span>() }
-            expectAfterLookupCalled()
-        }
-
-        test("matching 0 components works") {
-            _expect<Span>(0)
-            expectAfterLookupCalled()
-            Button()._expect<Span>(0)
-        }
-
-        test("fails when the count is wrong") {
-            expectThrows(AssertionError::class) {
-                UI.getCurrent().verticalLayout {
-                    verticalLayout { }
-                }._expect<VerticalLayout>()
-            }
-            expectAfterLookupCalled()
-        }
-
-        test("succeeds when the count is right") {
-            UI.getCurrent().verticalLayout {
-                verticalLayout { }
-            }._expect<VerticalLayout>(2)
-            expectAfterLookupCalled()
-        }
-
-        test("selects self") {
-            Button()._expect<Button>(1)
-            expectAfterLookupCalled()
-        }
-
-        test("returns nested") {
-            VerticalLayout(Button())._expect<Button>(1)
-            expectAfterLookupCalled()
-        }
-
-        test("spec") {
-            expectThrows(AssertionError::class) {
-                Button("foo")._expect<Button> { caption = "bar" }
-            }
-            expectAfterLookupCalled()
-            expectThrows(AssertionError::class) {
-                Button("foo")._expect(Button::class.java) { caption = "bar" }
-            }
-        }
-    }
-}
-
-data class MyLifecycleHook(var isBeforeLookupCalled: Boolean = false, var isAfterLookupCalled: Boolean = false) : TestingLifecycleHook {
-    override fun awaitBeforeLookup() {
-        check(!isBeforeLookupCalled) { "awaitBeforeLookup() has been already called" }
-        check(!isAfterLookupCalled) { "awaitAfterLookup() has been already called" }
-        isBeforeLookupCalled = true
-    }
-
-    override fun awaitAfterLookup() {
-        check(isBeforeLookupCalled) { "awaitBeforeLookup() has not yet been called" }
-        check(!isAfterLookupCalled) { "awaitAfterLookup() has been already called" }
-        isAfterLookupCalled = true
-    }
-}
-
-fun expectAfterLookupCalled() {
-    expect(MyLifecycleHook(true, true)) { TestingLifecycleHooks.getCurrent() }
-    TestingLifecycleHooks.setCurrent(MyLifecycleHook())
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
deleted file mode 100644
index 3cfe1bf1..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
+++ /dev/null
@@ -1,600 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-@file:Suppress("DEPRECATION")
-
-package com.vaadin.browserless.internal
-
-import com.vaadin.browserless.internal.BasicUtils._close
-import com.vaadin.browserless.internal.TestingLifecycleHooks.cleanupDialogs
-import com.vaadin.browserless.internal.Utils.currentRequest
-import com.vaadin.browserless.internal.Utils.currentResponse
-import com.vaadin.browserless.internal.Utils.mock
-
-import com.example.base.HelloWorldView
-import com.example.base.ParametrizedView
-import com.example.base.child.ChildView
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.dynatest.cloneBySerialization
-import com.github.mvysny.dynatest.expectThrows
-import com.vaadin.flow.component.AttachEvent
-import com.vaadin.flow.component.DetachEvent
-import com.vaadin.flow.component.Text
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.dialog.Dialog
-import com.vaadin.flow.component.html.Div
-import com.vaadin.flow.component.orderedlayout.VerticalLayout
-import com.vaadin.flow.function.DeploymentConfiguration
-import com.vaadin.flow.router.RouteConfiguration
-import com.vaadin.flow.server.*
-import com.vaadin.browserless.TestInitListener
-import com.vaadin.browserless.expectList
-import com.vaadin.browserless.mocks.MockService
-import com.vaadin.browserless.mocks.MockVaadinServlet
-import com.vaadin.browserless.mocks.MockVaadinSession
-import com.vaadin.browserless.mocks.MockedUI
-import jakarta.servlet.http.Cookie
-import java.util.concurrent.atomic.AtomicReference
-import kotlin.concurrent.thread
-import kotlin.test.expect
-
-@DynaTestDsl
-internal fun DynaNodeGroup.mockVaadinTest() {
-    lateinit var routes: Routes
-    beforeGroup { routes = Routes().autoDiscoverViews("com.example.base") }
-    beforeEach {
-        MockVaadin.setup(routes)
-        expect("""
-└── MockedUI[]
-    └── WelcomeView[@theme='spacing padding']
-        └── Text[text='Welcome!']
-""".trim().withSortedThemeNames()) { PrettyPrintTree.toPrettyTree(UI.getCurrent()).trim().withSortedThemeNames() }
-    }
-    afterEach { MockVaadin.tearDown() }
-
-    group("setup/teardown tests") {
-        test("smoke test that everything is mocked") {
-            expect(true) { UI.getCurrent() != null }
-            expect(true) { VaadinSession.getCurrent() != null }
-            expect(true) { VaadinService.getCurrent() != null }
-            expect(true) { VaadinRequest.getCurrent() != null }
-            expect(true) { VaadinSession.getCurrent().configuration != null }
-            expect(true) { VaadinSession.getCurrent().service != null }
-            expect(true) { VaadinSession.getCurrent().browser != null }
-            expect(true) { VaadinSession.getCurrent().browser.locale != null }
-            expect(false) { VaadinSession.getCurrent().browser.isIPhone }
-            expect(true) { VaadinSession.getCurrent().browser.isFirefox }
-            expect(false) { VaadinSession.getCurrent().browser.isChrome }
-            expect(false) { VaadinSession.getCurrent().browser.isChromeOS }
-            expect(false) { VaadinSession.getCurrent().browser.isAndroid }
-            expect(false) { VaadinSession.getCurrent().browser.isEdge }
-            expect(true) { VaadinResponse.getCurrent() != null }
-        }
-
-        test("current UI contains sane values") {
-            expect(true) { UI.getCurrent().locale != null }
-            expect(true) { UI.getCurrent().element != null }
-            expect(true) { UI.getCurrent().session != null }
-            expect(VaadinSession.getCurrent()) { UI.getCurrent().session }
-            expect(true) { UI.getCurrent().session.session != null }
-            expect(true) { UI.getCurrent().loadingIndicatorConfiguration != null }
-            expect(true) { UI.getCurrent().pushConfiguration != null }
-            expect(true) { UI.getCurrent().reconnectDialogConfiguration != null }
-            expect(true) { UI.getCurrent().internals != null }
-            expect(true) { UI.getCurrent().page != null }
-            expect(true) { UI.getCurrent().internals.router != null }
-        }
-
-        test("serializable") {
-            UI.getCurrent().cloneBySerialization()
-            VaadinSession.getCurrent().cloneBySerialization()
-            // even that it says it's Serializable it's really not.
-            // VaadinService.getCurrent().cloneBySerialization()
-            // VaadinRequest.getCurrent().cloneBySerialization()
-            // VaadinResponse.getCurrent().cloneBySerialization()
-        }
-
-        test("setup() can be called multiple times in a row") {
-            MockVaadin.setup()
-            MockVaadin.setup()
-        }
-
-        test("setup() always provides new instances") {
-            MockVaadin.setup()
-            val ui = UI.getCurrent()!!
-            MockVaadin.setup()
-            expect(true) { UI.getCurrent()!! !== ui }
-        }
-
-        test("Vaadin.getCurrent() returns null after tearDown()") {
-            MockVaadin.tearDown()
-            expect(null) { VaadinSession.getCurrent() }
-            expect(null) { VaadinService.getCurrent() }
-            expect(null) { VaadinRequest.getCurrent() }
-            expect(null) { UI.getCurrent() }
-            expect(null) { VaadinResponse.getCurrent() }
-        }
-
-        test("tearDown() can be called multiple times") {
-            MockVaadin.tearDown()
-            MockVaadin.tearDown()
-            MockVaadin.tearDown()
-        }
-
-        test("tearDown() calls UI detach listeners") {
-            val vl = UI.getCurrent()
-            vl.add(VerticalLayout())
-            var vldetachCalled = 0
-            vl.addDetachListener {
-                vldetachCalled++
-                expect(1, "detach should be called only once") { vldetachCalled }
-            }
-            var detachCalled = 0
-            UI.getCurrent().addDetachListener {
-                detachCalled++
-                expect(1, "detach should be called only once") { detachCalled }
-            }
-            MockVaadin.tearDown()
-            expect(1, "detach should be called exactly once") { detachCalled }
-            expect(1, "detach should be called exactly once") { vldetachCalled }
-        }
-    }
-
-    group("proper mocking") {
-        test("configuration mocked as well") {
-            expect(false) { VaadinSession.getCurrent().configuration.isProductionMode }
-        }
-
-        test("verifyAttachCalled") {
-            var attachCallCount = 0
-            var detachCallCount = 0
-            val vl = object : VerticalLayout() {
-                override fun onAttach(attachEvent: AttachEvent?) {
-                    super.onAttach(attachEvent)
-                    attachCallCount++
-                }
-
-                override fun onDetach(detachEvent: DetachEvent?) {
-                    super.onDetach(detachEvent)
-                    detachCallCount++
-                }
-            }
-            vl.addAttachListener {
-                expect(true) { vl.isAttached() }
-                attachCallCount++
-            }
-            vl.addDetachListener {
-                // a bug in Vaadin? I'd expect the node to be detached (null parent etc) at this point...
-                // See https://github.com/vaadin/flow/issues/8809
-                expect(true) { vl.isAttached() }
-                detachCallCount++
-            }
-
-            // attach
-            UI.getCurrent().add(vl)
-            expect(2) { attachCallCount }
-            expect(true) { vl.isAttached() }
-            expect(0) { detachCallCount }
-
-            // close UI - detach is not called.
-            UI.getCurrent().close()
-            expect(2) { attachCallCount }
-            expect(true) { vl.isAttached() }
-            expect(0) { detachCallCount }
-
-            // detach
-            vl.removeFromParent()
-            expect(2) { attachCallCount }
-            expect(false) { vl.isAttached() }
-            expect(2) { detachCallCount }
-        }
-
-        test("detach on forceful UI close") {
-            val vl = UI.getCurrent()
-            vl.add(VerticalLayout())
-            var detachCalled = 0
-            vl.addDetachListener { detachCalled++ }
-            expect(true) { vl.isAttached() }
-
-            // close UI - detach is not called.
-            UI.getCurrent().close()
-            expect(true) { vl.isAttached() }
-            expect(0) { detachCalled }
-            expect(true) { UI.getCurrent().isAttached() }
-
-            // Mock closing of UI after request handled
-            _close(UI.getCurrent())
-            expect(false) { vl.isAttached() }
-            expect(1) { detachCalled }
-            expect(false) { UI.getCurrent().isAttached() }
-        }
-
-        /* TODO: uncomment after importing Locator APIs
-        test("navigation works in mocked env") {
-            // when UI is initialized in MockVaadin.setup(), automatic navigation to "" is performed.
-            _get<Text> { text = "Welcome!" }
-            UI.getCurrent().navigate("helloworld")
-            _get<Button> { caption = "Hello, World!" }
-        }
-
-        test("navigation to parametrized view works in mocked env") {
-            UI.getCurrent().navigate("params/1")
-            _get<ParametrizedView>()
-        }
-
-        test("navigation to view with parent route works in mocked env") {
-            UI.getCurrent().navigate("parent/child")
-            _get<ChildView>()
-        }
-         */
-
-        test("UI.getUrl() to view works in mocked env") {
-            val routeConfig = RouteConfiguration.forRegistry(UI.getCurrent().internals.router.registry)
-            expect("helloworld") { routeConfig.getUrl(HelloWorldView::class.java) }
-            expect("params/1") { routeConfig.getUrl(ParametrizedView::class.java, 1) }
-            expect("parent/child") { routeConfig.getUrl(ChildView::class.java) }
-            expect("helloworld") { RouteConfiguration.forApplicationScope().getUrl(HelloWorldView::class.java) }
-            expect("params/1") { RouteConfiguration.forApplicationScope().getUrl(ParametrizedView::class.java, 1) }
-            expect("parent/child") { RouteConfiguration.forApplicationScope().getUrl(ChildView::class.java) }
-        }
-
-        /* TODO: uncomment after importing Locator APIs
-        // tests https://github.com/mvysny/karibu-testing/issues/11
-        group("beforeClientResponse invoked") {
-            test("on an UI") {
-                var ran = false
-                UI.getCurrent().beforeClientResponse(UI.getCurrent()) {
-                    expect(false, "the block was supposed to be run only once") { ran }
-                    ran = true
-                }
-                _get<UI> {} // do the lookup which should trigger the beforeClientResponse run
-                expect(true) { ran }
-            }
-            test("on a button nested within the UI") {
-                var ran = false
-                val button = UI.getCurrent().button()
-                UI.getCurrent().beforeClientResponse(button) {
-                    expect(false, "the block was supposed to be run only once") { ran }
-                    ran = true
-                }
-                _get<UI> {} // do the lookup which should trigger the beforeClientResponse run
-                expect(true) { ran }
-            }
-        }
-         */
-    }
-
-    group("dialogs") {
-        /* TODO: uncomment after importing Locator APIs
-
-            test("open dialog") {
-                // there should be no dialogs in the UI
-                _expectNone<Dialog>()
-                _expectNone<Div> { text = "Dialog Text" }
-                val dialog = Dialog(Div(Text("Dialog Text")))
-                dialog.open()
-                _get<Dialog>()  // should be in the UI, along with its contents
-                _get<Div> { text = "Dialog Text" }
-                dialog.close()
-                // there should be no dialogs in the UI
-                _expectNone<Div> { text = "Dialog Text" }
-                _expectNone<Dialog>()
-            }
-         */
-
-        test("the dialogs must be cleared up from the component tree on close") {
-            val dialog = Dialog(Div(Text("Dialog Text")))
-            dialog.open()
-            dialog.close()
-            cleanupDialogs()
-            expect(
-                    """
-└── MockedUI[]
-    └── WelcomeView[@theme='spacing padding']
-        └── Text[text='Welcome!']
-""".trim().withSortedThemeNames()
-            ) { PrettyPrintTree.toPrettyTree(UI.getCurrent()).trim().withSortedThemeNames() }
-        }
-    }
-
-    group("page reloading") {
-        test("Page reload should re-create the UI") {
-            val ui = UI.getCurrent()
-            var detachCalled = false
-            ui.addDetachListener {
-                expect(false, "detach should be called only once") { detachCalled }
-                detachCalled = true
-            }
-            UI.getCurrent().page.reload()
-            // a new UI must be created; but the Session must stay the same.
-            expect(true) { UI.getCurrent() != null }
-            expect(false) { UI.getCurrent() === ui }
-            // the old UI must be detached properly
-            expect(true) { detachCalled }
-        }
-
-        test("Page reload should preserve session") {
-            val session = VaadinSession.getCurrent()
-            session.setAttribute("foo", "bar")
-            UI.getCurrent().page.reload()
-            expect(true) { VaadinSession.getCurrent() === session }
-            expect("bar") { VaadinSession.getCurrent().getAttribute("foo") }
-        }
-
-        /* TODO: uncomment after importing Locator APIs
-        test("Page reload should automatically navigate to the current URL") {
-            _get<WelcomeView>()
-            UI.getCurrent().page.reload()
-            _get<WelcomeView>()
-            UI.getCurrent().navigate("helloworld")
-            _expectNone<WelcomeView>()
-            _get<HelloWorldView>()
-            UI.getCurrent().page.reload()
-            _expectNone<WelcomeView>()
-            _get<HelloWorldView>()
-        }
-        */
-    }
-
-    test("VaadinSession.close() must re-create the entire session and the UI") {
-        val ui = UI.getCurrent()
-        var detachCalled = false
-        ui.addDetachListener { detachCalled = true }
-        val session = VaadinSession.getCurrent()
-        session.setAttribute("foo", "bar")
-        session.close()
-
-        // a new UI+Session must be created
-        expect(true) { UI.getCurrent() != null }
-        expect(true) { VaadinSession.getCurrent() != null }
-        expect(false) { UI.getCurrent() === ui }
-        expect(false) { VaadinSession.getCurrent() === session }
-        // the old UI must be detached properly
-        expect(true) { detachCalled }
-        // the new session must not inherit attributes from the old one
-        expect(null) { VaadinSession.getCurrent().getAttribute("foo") }
-    }
-
-
-    test("Reusing UI fails with helpful message") {
-        val ui = MockedUI()
-        MockVaadin.setup(UIFactory { ui })
-        expectThrows(IllegalArgumentException::class, "which is already attached to a Session") {
-            MockVaadin.setup(UIFactory { ui })
-        }
-    }
-
-    group("async") {
-        asyncTestbatch()
-    }
-
-    group("init listener") {
-        beforeEach {
-            MockVaadin.tearDown()
-            TestInitListener.clearInitFlags()
-            MockVaadin.setup(routes)
-        }
-        test("init listeners called") {
-            expect(true) { TestInitListener.serviceInitCalled }
-            expect(true) { TestInitListener.uiInitCalled }
-            expect(true) { TestInitListener.uiBeforeEnterCalled }
-        }
-    }
-
-    group("request") {
-        test("cookies") {
-            mock(currentRequest()).addCookie(Cookie("foo", "bar"))
-            expectList("bar") { currentRequest().cookies!!.map { it.value } }
-        }
-    }
-
-    group("response") {
-        test("cookies") {
-            currentResponse().addCookie(Cookie("foo", "bar"))
-            expect("bar") { mock(currentResponse()).getCookie("foo").value }
-        }
-
-        test("cookies in UI.init()") {
-            MockVaadin.tearDown()
-            var initCalled = false
-            MockVaadin.setup(UIFactory {
-                mock(currentRequest()).addCookie(Cookie("foo", "bar"))
-                object : UI() {
-                    override fun init(request: VaadinRequest) {
-                        expectList("bar") { currentRequest().cookies!!.map { it.value } }
-                        initCalled = true
-                    }
-                }
-            })
-            expect(true) { initCalled }
-        }
-    }
-
-    group("session") {
-        test("attributes") {
-            VaadinSession.getCurrent().session.setAttribute("foo", "bar")
-            expect("bar") { mock(VaadinSession.getCurrent()).getAttribute("foo") }
-        }
-        test("changeSessionId() keeps the VaadinSession") {
-            // How an app without Spring Security protects against session
-            // fixation after a successful login. Unlike reinitializeSession()
-            // the very same HttpSession is kept and only its ID changes, so
-            // the VaadinSession bound to it survives.
-            val session = VaadinSession.getCurrent()
-            val id = session.session.id
-            session.session.setAttribute("foo", "bar")
-            val vaadinSessionAttribute =
-                    VaadinSession::class.java.name + "." + VaadinService.getCurrent().serviceName
-
-            val request = VaadinService.getCurrentRequest() as VaadinServletRequest
-            val newId = request.httpServletRequest.changeSessionId()
-
-            expect(true) { id != newId }
-            expect(newId) { session.session.id }
-            expect("bar") { session.session.getAttribute("foo") }
-            expect(session) { session.session.getAttribute(vaadinSessionAttribute) }
-            expect(true) { session.hasLock() }
-        }
-        test("reinitializeSession()") {
-            var id = VaadinSession.getCurrent().session.id
-            VaadinSession.getCurrent().session.setAttribute("foo", "bar")
-            expect(true) { VaadinSession.getCurrent().hasLock() }
-
-            VaadinService.reinitializeSession(VaadinRequest.getCurrent())
-            // test that attributes are preserved
-            expect("bar") { VaadinSession.getCurrent().session.getAttribute("foo") }
-            expect(true) { id != VaadinSession.getCurrent().session.id }
-            expect(true) { VaadinSession.getCurrent().hasLock() }
-
-            id = VaadinSession.getCurrent().session.id
-            // reinitialize again
-            VaadinService.reinitializeSession(VaadinRequest.getCurrent())
-            // test that attributes are preserved
-            expect("bar") { VaadinSession.getCurrent().session.getAttribute("foo") }
-            expect(true) { id != VaadinSession.getCurrent().session.id }
-            expect(true) { VaadinSession.getCurrent().hasLock() }
-        }
-    }
-
-    group("multiple threads") {
-        // don't extract this into a testBatch method - references 'lateinit routes'
-        test("UIs/Sessions not reused between threads") {
-            fun newVaadinThread(): Pair<UI, VaadinSession> {
-                val uiref = AtomicReference<UI>()
-                val sessionref = AtomicReference<VaadinSession>()
-                thread {
-                    MockVaadin.setup()
-                    uiref.set(UI.getCurrent())
-                    sessionref.set(VaadinSession.getCurrent())
-                }.join()
-                return uiref.get()!! to sessionref.get()!!
-            }
-
-            val pair1 = newVaadinThread()
-            val pair2 = newVaadinThread()
-            expect(false) { pair1.first == pair2.first }
-            expect(false) { pair1.second == pair2.second }
-        }
-
-/* TODO: uncomment after importing Locator APIs
-        test("executor example") {
-            // a simple service which only counts the number of calls
-            class MyService {
-                private var count = 0
-                private val lock = ReentrantReadWriteLock()
-
-                fun callService() {
-                    lock.write { Thread.sleep(10); count++ }
-                }
-
-                fun getCount(): Int = lock.read { count }
-            }
-
-            val service = MyService()
-
-            // an ExecutorService which configures Vaadin for every thread created.
-            val e: ExecutorService = Executors.newFixedThreadPool(4) { runnable ->
-                Thread {
-                    MockVaadin.setup(routes)
-                    runnable.run()
-                    MockVaadin.tearDown()
-                }
-            }
-
-            try {
-                // submit a task to all threads
-                repeat(4) {
-                    e.submit {
-                        try {
-                            UI.getCurrent().navigate("helloworld")
-                            _get<Button> { caption = "Hello, World!" }.onLeftClick {
-                                service.callService()
-                            }
-                            _get<Button> { caption = "Hello, World!" }._click()
-                        } catch (e: Throwable) {
-                            e.printStackTrace()
-                        }
-                    }
-                }
-            } finally {
-                e.shutdown()
-                e.awaitTermination(10, TimeUnit.SECONDS)
-            }
-
-            // make sure that every thread called the service
-            expect(4) { service.getCount() }
-        }
- */
-    }
-
-    group("VaadinService") {
-        test("Registering custom VaadinService is possible") {
-            open class MyMockService(servlet: VaadinServlet, deploymentConfiguration: DeploymentConfiguration) : VaadinServletService(servlet, deploymentConfiguration) {
-                override fun isAtmosphereAvailable(): Boolean = false
-                override fun getMainDivId(session: VaadinSession, request: VaadinRequest): String = "ROOT-1"
-                override fun createVaadinSession(request: VaadinRequest): VaadinSession = MockVaadinSession(this) { MockedUI() }
-            }
-            MockVaadin.tearDown()
-            MockVaadin.setup(object : MockVaadinServlet(routes) {
-                override fun createServletService(deploymentConfiguration: DeploymentConfiguration): VaadinServletService {
-                    val service = MyMockService(this, deploymentConfiguration)
-                    service.init()
-                    return service
-                }
-            })
-            expect<Class<*>>(MyMockService::class.java) { VaadinService.getCurrent().javaClass }
-        }
-        test("VaadinService listeners should be invoked") {
-            MockVaadin.tearDown()
-            var sessionInitListenerInvocationCount = 0
-            var uiInitListenerInvocationCount = 0
-            var sessionDestroyListenerInvocationCount = 0
-            var serviceDestroyListenerInvocationCount = 0
-            MockVaadin.setup(object : MockVaadinServlet(routes) {
-                override fun createServletService(deploymentConfiguration: DeploymentConfiguration): VaadinServletService {
-                    val service = MockService(this, deploymentConfiguration)
-                    service.init()
-                    service.addSessionInitListener { sessionInitListenerInvocationCount++ }
-                    service.addUIInitListener { uiInitListenerInvocationCount++ }
-                    service.addSessionDestroyListener { sessionDestroyListenerInvocationCount++ }
-                    service.addServiceDestroyListener { serviceDestroyListenerInvocationCount++ }
-                    return service
-                }
-            })
-            expect(1) { sessionInitListenerInvocationCount }
-            expect(1) { uiInitListenerInvocationCount }
-            expect(0) { sessionDestroyListenerInvocationCount }
-            expect(0) { serviceDestroyListenerInvocationCount }
-            MockVaadin.tearDown()
-            expect(1) { sessionInitListenerInvocationCount }
-            expect(1) { uiInitListenerInvocationCount }
-            expect(1) { sessionDestroyListenerInvocationCount }
-            expect(1) { serviceDestroyListenerInvocationCount }
-        }
-    }
-}
-/**
- * Sorts the names within every `@theme='...'` of a pretty printed component
- * tree.
- *
- * A component's theme names are a set, so the order they are printed in is
- * whatever order the component happened to add them in — nothing a test should
- * assert on. Sorting both sides keeps a tree assertion about the tree.
- */
-private fun String.withSortedThemeNames(): String =
-        Regex("@theme='([^']*)'").replace(this) { match ->
-            "@theme='" + match.groupValues[1].split(' ').sorted().joinToString(" ") + "'"
-        }
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
deleted file mode 100644
index 249e2fc6..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
+++ /dev/null
@@ -1,373 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.vaadin.browserless.internal.BasicUtils.id_
-
-import com.example.base.HelloWorldView
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.karibudsl.v10.contextMenu
-import com.github.mvysny.karibudsl.v10.div
-import com.github.mvysny.karibudsl.v10.item
-import com.github.mvysny.karibudsl.v10.text
-import com.github.mvysny.karibudsl.v10.tooltip
-import com.vaadin.flow.component.Html
-import com.vaadin.flow.component.Text
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.contextmenu.ContextMenu
-import com.vaadin.flow.component.formlayout.FormLayout
-import com.vaadin.flow.component.html.Anchor
-import com.vaadin.flow.component.html.Div
-import com.vaadin.flow.component.html.Image
-import com.vaadin.flow.component.html.Span
-import com.vaadin.flow.component.icon.VaadinIcon
-import com.vaadin.flow.component.textfield.TextArea
-import com.vaadin.flow.component.textfield.TextField
-import com.vaadin.flow.router.*
-import com.vaadin.flow.server.VaadinService
-import org.intellij.lang.annotations.Language
-import kotlin.test.assertContains
-import kotlin.test.expect
-import kotlin.test.fail
-
-@DynaTestDsl
-internal fun DynaNodeGroup.prettyPrintTreeTest() {
-    lateinit var routes: Routes
-    beforeGroup { routes = Routes().autoDiscoverViews("com.example.base") }
-    beforeEach { MockVaadin.setup(routes) }
-    afterEach { MockVaadin.tearDown() }
-
-    test("Simple dump") {
-        val div = Div().apply {
-            text("Foo")
-        }
-        expect("""
-└── Div[text='Foo']
-    └── Text[text='Foo']
-""".trim()) { div.toPrettyTree().trim() }
-    }
-
-    test("toPrettyStringHtmlComponent()") {
-        expect("Text[text='foo']") { Text("foo").toPrettyString() }
-        expect("Div[INVIS]") { Div().apply { isVisible = false }.toPrettyString() }
-        expect("Html[<b>foo bar baz <i>foobar</i></b>]") {
-            Html("\n    <b>foo\nbar\n    baz\n<i>foobar</i></b>").toPrettyString()
-        }
-        expect("HtmlSpan[innerHTML='aaa<b>bbbb</b>ccc']") {
-            HtmlSpan("aaa<b>bbbb</b>ccc").toPrettyString()
-        }
-        expect("Div[@title='foobar']") {
-            Div().apply { tooltip = "foobar" }.toPrettyString()
-        }
-        expect("Span[text='hi', @slot='prefix']") {
-            val testSpan = Span("hi")
-            TextField().prefixComponent = testSpan
-            testSpan.toPrettyString()
-        }
-    }
-    test("toPrettyStringTextField()") {
-        assertContains(TextField().also { id_(it, "25") }.toPrettyString(),"TextField\\[#25, value=''.*]".toRegex())
-        assertContains(TextArea("label").apply { value = "some text" }.toPrettyString(),"TextArea\\[label='label', value='some text'.*]".toRegex())
-        assertContains(TextField().also { id_(it, "25"); it.errorMessage = "failed validation" }.toPrettyString(),"TextField\\[#25, value='', errorMessage='failed validation'.*]".toRegex())
-        assertContains(TextField("foobar").toPrettyString(), "TextField\\[label='foobar', value=''.*]".toRegex() )
-    }
-    test("toPrettyStringButton()") {
-        expect("Button[caption='click me']") { Button("click me").toPrettyString() }
-        expect("Button[icon='vaadin:abacus', @theme='icon']") { Button(VaadinIcon.ABACUS.create()).toPrettyString() }
-
-    }
-//    test("toPrettyStringGrid()") {
-        /* TODO: uncomment when importing Grid stuff
-        expect("Grid[<String>, dataprovider='ListDataProvider2{0 items}']") { Grid<String>(String::class.java).apply { setItems2(listOf()) }.toPrettyString() }
-        expect("Column[header='My Header']") {
-            Grid<Any>().run { addColumn { it }.apply { header2 = "My Header" } }.toPrettyString()
-        }
-        expect("Column[header='My Header', key='foo']") {
-            Grid<Any>().run { addColumn { it }.apply { header2 = "My Header"; key = "foo" } }.toPrettyString()
-        }
-         */
-//    }
-    test("toPrettyStringAnchor()") {
-        expect("Anchor[]") { Anchor().toPrettyString() }
-        expect("Anchor[href='vaadin.com']") { Anchor("vaadin.com").toPrettyString() }
-        // the href is dumped for any component declaring it, also when it is
-        // inherited or declared as a plain href() method or a Kotlin property
-        expect("MyAnchor[href='vaadin.com']") { MyAnchor("vaadin.com").toPrettyString() }
-        expect("ComponentWithHrefFunction[href='vaadin.com']") {
-            ComponentWithHrefFunction().toPrettyString()
-        }
-        expect("ComponentWithHrefProperty[href='vaadin.com']") {
-            ComponentWithHrefProperty().toPrettyString()
-        }
-        expect("ComponentWithHrefInterface[href='vaadin.com']") {
-            ComponentWithHrefInterface().toPrettyString()
-        }
-        // a bean getter is consulted as well, which is all a Kotlin href property
-        // without a backing field compiles to
-        expect("ComponentWithComputedHref[href='vaadin.com']") {
-            ComponentWithComputedHref().toPrettyString()
-        }
-        // a blank member doesn't end the lookup, the getter still gets its turn
-        expect("ComponentWithBlankHrefField[href='vaadin.com']") {
-            ComponentWithBlankHrefField().toPrettyString()
-        }
-    }
-    test("toPrettyStringRouterLink()") {
-        // getHref() reports a missing href as an empty string, which is not dumped
-        expect("RouterLink[]") { RouterLink().toPrettyString() }
-        expect("RouterLink[text='Hello', href='helloworld']") {
-            RouterLink("Hello", HelloWorldView::class.java).toPrettyString()
-        }
-    }
-    test("toPrettyStringImage()") {
-        expect("Image[]") { Image().toPrettyString() }
-        expect("Image[@src='vaadin.com']") { Image("vaadin.com", "").toPrettyString() }
-    }
-    test("toPrettyStringIcon()") {
-        expect("Icon[@icon='vaadin:abacus']") { VaadinIcon.ABACUS.create().toPrettyString() }
-    }
-    test("toPrettyStringForm()") {
-        expect("FormItem[label='foo']") { FormLayout().addFormItem(TextField(), "foo").toPrettyString() }
-    }
-    test("toPrettyStringCustomComponent()") {
-        expect("MyComponentWithToString[my-div(25)]") {
-            MyComponentWithToString().toPrettyString()
-        }
-    }
-
-    test("styles not duplicated") {
-        val div = Div()
-        expect("Div[]") { div.toPrettyString() }
-        div.setWidthFull()
-        expect("Div[@style='width:100%']") { div.toPrettyString() }
-        div.style.set("flex-shrink", "1")
-        expect("Div[@style='width:100%;flex-shrink:1']") { div.toPrettyString() }
-    }
-
-    test("menu dump") {
-        lateinit var cm: ContextMenu
-        UI.getCurrent().div {
-            cm = contextMenu {
-                item("menu") {
-                    isEnabled = false
-                    item("click me", { fail("shouldn't be called") })
-                }
-                item("save as")
-            }
-        }
-        expect("""
-└── ContextMenu[opened='false']
-    ├── MenuItem[DISABLED, text='menu']
-    │   └── MenuItem[text='click me']
-    └── MenuItem[text='save as']""".trim()) { cm.toPrettyTree().trim() }
-
-    }
-
-    /* TODO: uncomment when importing Grid stuff
-    group("grid") {
-        test("column headers") {
-            val grid: Grid<String> = UI.getCurrent().grid<String> {
-                addColumn(karibuDslI18n).setHeader("Hello!")
-                setItems2(listOf())
-            }
-            expect("""
-└── Grid[<String>, dataprovider='ListDataProvider2{0 items}']
-    └── Column[header='Hello!']
-""".trim()) { grid.toPrettyTree().trim() }
-        }
-
-        test("grid menu dump") {
-            lateinit var cm: GridContextMenu<String>
-            UI.getCurrent().grid<String> {
-                cm = gridContextMenu {
-                    item("menu") {
-                        isEnabled = false
-                        item("click me", { fail("shouldn't be called") })
-                    }
-                    item("save as")
-                }
-            }
-            expect("""
-└── GridContextMenu[]
-    ├── GridMenuItem[DISABLED, text='menu']
-    │   └── GridMenuItem[text='click me']
-    └── GridMenuItem[text='save as']""".trim()) { cm.toPrettyTree().trim() }
-        }
-
-        // tests https://github.com/mvysny/karibu-testing/issues/37
-        test("grid filters dump") {
-            val grid: Grid<String> = UI.getCurrent().grid<String> {
-                val col: Grid.Column<String> = addColumn(karibuDslI18n)
-                appendHeaderRow().getCell(col).setComponent(TextField("Filter:"))
-                setItems2(listOf())
-            }
-            expect("""
-└── Grid[<String>, dataprovider='ListDataProvider2{0 items}']
-    ├── TextField[label='Filter:', value='']
-    └── Column[]""".trim()) { grid.toPrettyTree().trim() }
-        }
-
-        // tests https://github.com/mvysny/karibu-testing/issues/37
-        test("grid filters dump for joined column") {
-            val grid: Grid<String> = UI.getCurrent().grid<String> {
-                val col1: Grid.Column<String> = addColumn(karibuDslI18n).setHeader("foo")
-                val col2: Grid.Column<String> = addColumn(karibuDslI18n).setHeader("bar")
-                appendHeaderRow()
-                prependHeaderRow().join(col1, col2).setComponent(TextField("Filter:"))
-                setItems2(listOf())
-            }
-            expect("""
-└── Grid[<String>, dataprovider='ListDataProvider2{0 items}']
-    ├── TextField[label='Filter:', value='']
-    └── ColumnGroup[]
-        ├── ColumnGroup[]
-        │   └── Column[header='foo']
-        └── ColumnGroup[]
-            └── Column[header='bar']""".trim()) { grid.toPrettyTree().trim() }
-        }
-    }
-         */
-
-    group("toPrettyStringInternalServerError()") {
-        fun createEvent(): BeforeEnterEvent {
-            val router = VaadinService.getCurrent().router
-            val navigationEvent = NavigationEvent(router, Location("helloworld"), UI.getCurrent(), NavigationTrigger.UI_NAVIGATE)
-            val event = BeforeEnterEvent(navigationEvent, HelloWorldView::class.java, emptyList())
-            return event
-        }
-
-        fun createErrorComponent(error: Exception?, message: String? = null): InternalServerError {
-            val errorView = MockInternalSeverError()
-            val errorParam = ErrorParameter(Exception::class.java, error, message)
-            errorView.setErrorParameter(createEvent(), errorParam)
-            return errorView;
-        }
-        test("no cause exception") {
-            val error = createErrorComponent(RuntimeException("OOPS!"))
-            val pretty = error.toPrettyString().trim()
-            assertContains(pretty, "targetView='helloworld'")
-            assertContains(pretty, "failureMessage='OOPS!'")
-            assertContains(pretty, "exceptionType='java.lang.RuntimeException'")
-        }
-        test("custom message") {
-            val error = createErrorComponent(RuntimeException("BOOM!"), "Something failed")
-            val pretty = error.toPrettyString().trim()
-            assertContains(pretty, "targetView='helloworld'")
-            assertContains(pretty, "failureMessage='Something failed'")
-            assertContains(pretty, "exceptionType='java.lang.RuntimeException'")
-        }
-    }
-
-    test("Handle null properties") {
-        val div = Div().apply {
-            element.setProperty("null-property", null)
-            element.setProperty("nonnull-property", "OK")
-        }
-        expect("""
-└── Div[nonnull-property='OK']
-""".trim()) { div.toPrettyTree().trim() }
-    }
-
-}
-
-class MyComponentWithToString : Div() {
-    override fun toString(): String = "my-div(25)"
-}
-
-/**
- * Inherits the private `href` field from [Anchor].
- */
-private class MyAnchor(href: String) : Anchor(href)
-
-/**
- * Declares `href` as a plain no-arg function, the way a record-style accessor would.
- */
-private class ComponentWithHrefFunction : Div() {
-    fun href(): String = "vaadin.com"
-}
-
-/**
- * Declares `href` as a Kotlin property, which compiles to an `href` field.
- */
-private class ComponentWithHrefProperty : Div() {
-    var href: String = "vaadin.com"
-}
-
-/**
- * Has a blank `href` field, but reports a real one through its getter.
- */
-private class ComponentWithBlankHrefField : Anchor("") {
-    override fun getHref(): String = "vaadin.com"
-}
-
-/**
- * Inherits `href` as a default method from an interface.
- */
-private interface HasHrefFunction {
-    fun href(): String = "vaadin.com"
-}
-
-private class ComponentWithHrefInterface : Div(), HasHrefFunction
-
-/**
- * Declares `href` as a Kotlin property without a backing field, which compiles to a
- * bean getter, exactly like [com.vaadin.flow.router.RouterLink.getHref] is one.
- */
-private class ComponentWithComputedHref : Div() {
-    val href: String get() = "vaadin.com"
-}
-
-/**
- * Populates its contents with given html snippet. The advantage over [com.vaadin.flow.component.Html]
- * is that any html is accepted - it doesn't have to be wrapped in a single root element.
- *
- * Note that it is the developer's responsibility to sanitize and remove any
- * dangerous parts of the HTML before sending it to the user through this
- * component. Passing raw input data to the user will possibly lead to
- * cross-site scripting attacks.
- *
- * This component does not expand the HTML fragment into a server side DOM tree
- * so you cannot traverse or modify the HTML on the server. The root element can
- * be accessed through [element] and the inner HTML through
- * [innerHTML].
- * @param innerHTML the HTML snippet to populate the span with.
- */
-private class HtmlSpan(@Language("html") innerHTML: String = "") : Span() {
-    /**
-     * Sets the inner html. Removes any children added via [add].
-     */
-    @get:Language("html")
-    @set:Language("html")
-    var innerHTML: String
-        get() = element.getProperty("innerHTML", "")
-        set(value) {
-            removeAll()
-            element.setProperty("innerHTML", value)
-        }
-
-    init {
-        this.innerHTML = innerHTML
-    }
-}
-
-// Extension shims over the Java statics, so the assertions below keep reading
-// as `component.toPrettyString()` instead of wrapping every one of them.
-private fun Component.toPrettyString(): String = PrettyPrintTree.toPrettyString(this)
-
-private fun Component.toPrettyTree(): String = PrettyPrintTree.toPrettyTree(this)
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
deleted file mode 100644
index a686536a..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.example.base.ErrorView
-import com.example.base.HelloWorldView
-import com.example.base.ParametrizedView
-import com.example.base.WelcomeView
-import com.example.base.child.ChildView
-import com.example.base.navigation.NavigationPostponeView
-import com.example.base.signals.SignalsView
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.dynatest.expectThrows
-import com.testapp.MyRouteNotFoundError
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.UI
-import com.vaadin.flow.router.HasErrorParameter
-import com.vaadin.flow.router.NotFoundException
-import com.vaadin.flow.router.RouteAccessDeniedError
-import com.vaadin.flow.router.RouteNotFoundError
-import com.vaadin.flow.server.VaadinContext
-import com.vaadin.flow.server.startup.ApplicationRouteRegistry
-import com.vaadin.browserless.mocks.MockVaadinHelper
-import com.vaadin.browserless.viewscan.byannotatedclass.ViewPackagesTestView
-import kotlin.test.expect
-
-
-val packagePrivateViewClass: Class<out Component> = Class.forName("com.example.base.PackagePrivateView").asSubclass(Component::class.java)
-val allViews: Set<Class<out Component>> = setOf<Class<out Component>>(
-        HelloWorldView::class.java, WelcomeView::class.java,
-        ParametrizedView::class.java, ChildView::class.java, NavigationPostponeView::class.java,
-        ViewPackagesTestView::class.java, SignalsView::class.java, packagePrivateViewClass)
-val allErrorRoutes: Set<Class<out HasErrorParameter<*>>> = setOf(ErrorView::class.java, MockRouteNotFoundError::class.java, MockInternalSeverError::class.java)
-
-@DynaTestDsl
-fun DynaNodeGroup.routesTestBatch() {
-    afterEach { MockVaadin.tearDown() }
-
-    // TODO: restrict scan until we have component wrapper test views on this codebase
-    val packagesToScan = arrayOf("com.example.base", "com.vaadin.browserless.viewscan",
-            "com.vaadin.browserless.viewscan4")
-
-    test("All views discovered") {
-        val routes: Routes = Routes().autoDiscoverViews(*packagesToScan)
-        expect(allViews) { routes.routes.toSet() }
-        expect(allErrorRoutes) { routes.errorRoutes.toSet() }
-    }
-
-    test("package-private views are discovered") {
-        val routes: Routes = Routes().autoDiscoverViews(*packagesToScan)
-        expect(true, "PackagePrivateView should be discovered") {
-            routes.routes.any { it.name == "com.example.base.PackagePrivateView" }
-        }
-    }
-
-    test("calling autoDiscoverViews() multiple times won't fail") {
-        expect(allViews) { Routes().autoDiscoverViews(*packagesToScan).routes }
-        expect(allViews) { Routes().autoDiscoverViews(*packagesToScan).routes }
-    }
-
-    // https://github.com/mvysny/karibu-testing/issues/50
-    test("app-specific NotFoundException handler removes MockRouteNotFoundError") {
-        val routes: Routes = Routes().autoDiscoverViews("com.example.base", "com.testapp", "com.vaadin.flow.router")
-        expect(setOf(ErrorView::class.java, MockInternalSeverError::class.java, MyRouteNotFoundError::class.java, RouteNotFoundError::class.java, RouteAccessDeniedError::class.java)) { routes.errorRoutes.toSet() }
-        // make sure that Vaadin initializes properly with this set of views
-        MockVaadin.setup(routes)
-    }
-
-    test("PWA is ignored by default") {
-        val routes: Routes = Routes().autoDiscoverViews("com.example.base")
-        val ctx: VaadinContext = MockVaadinHelper.createMockVaadinContext()
-        routes.register(ctx)
-        expect(null) {
-            @Suppress("DEPRECATION")
-            ApplicationRouteRegistry.getInstance(ctx).pwaConfigurationClass
-        }
-    }
-
-    test("PWA is discovered properly if need be") {
-        val routes: Routes = Routes().autoDiscoverViews("com.example.base")
-        routes.skipPwaInit = false
-        val ctx: VaadinContext = MockVaadinHelper.createMockVaadinContext()
-        routes.register(ctx)
-        expect(WelcomeView::class.java) {
-            @Suppress("DEPRECATION")
-            ApplicationRouteRegistry.getInstance(ctx).pwaConfigurationClass
-        }
-    }
-
-    test("MockRouteNotFoundError is called when the route doesn't exist and it contains informative error message") {
-        val routes: Routes = Routes().autoDiscoverViews("com.example.base")
-        MockVaadin.setup(routes)
-        UI.getCurrent().navigate("A_VIEW_THAT_DOESNT_EXIST")
-        val view = UI.getCurrent().internals.activeRouterTargetsChain.first();
-        expect(MockRouteNotFoundError::class.java) {
-            view::class.java
-        }
-        expectThrows(NotFoundException::class, "No route found for 'A_VIEW_THAT_DOESNT_EXIST': Couldn't find route for 'A_VIEW_THAT_DOESNT_EXIST'\nAvailable routes:") {
-            throw (view as MockRouteNotFoundError).cause!!
-        }
-        expect(true) {
-            val errorMessage = ElementUtils.textRecursively2(view.element)
-            errorMessage.contains("Could not navigate to 'A_VIEW_THAT_DOESNT_EXIST'")
-        }
-    }
-
-    test("merge routes") {
-        val routes1 = Routes(
-                mutableSetOf<Class<out Component>>(HelloWorldView::class.java, WelcomeView::class.java,
-                        ViewPackagesTestView::class.java, SignalsView::class.java, packagePrivateViewClass),
-                mutableSetOf<Class<out HasErrorParameter<*>>>(ErrorView::class.java))
-        val routes2 = Routes(
-                mutableSetOf<Class<out Component>>(ParametrizedView::class.java, ChildView::class.java, NavigationPostponeView::class.java),
-                mutableSetOf<Class<out HasErrorParameter<*>>>(MockRouteNotFoundError::class.java, MockInternalSeverError::class.java))
-        val merged = routes1.merge(routes2);
-        expect(allViews) { merged.routes.toSet() }
-        expect(allErrorRoutes) { merged.errorRoutes.toSet() }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
deleted file mode 100644
index 19a85be1..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/SearchSpecTest.kt
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import java.util.function.Predicate
-import kotlin.test.expect
-import com.vaadin.flow.component.Component
-import com.vaadin.flow.component.Text
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.checkbox.Checkbox
-import com.vaadin.flow.component.checkbox.CheckboxGroup
-import com.vaadin.flow.component.combobox.ComboBox
-import com.vaadin.flow.component.datepicker.DatePicker
-import com.vaadin.flow.component.html.Input
-import com.vaadin.flow.component.html.Span
-import com.vaadin.flow.component.listbox.ListBox
-import com.vaadin.flow.component.radiobutton.RadioButtonGroup
-import com.vaadin.flow.component.select.Select
-import com.vaadin.flow.component.textfield.TextArea
-import com.vaadin.flow.component.textfield.TextField
-import com.vaadin.flow.component.timepicker.TimePicker
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.karibudsl.v10.DateRangePopup
-
-@DynaTestDsl
-internal fun DynaNodeGroup.searchSpecTest() {
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-    test("clazz") {
-        val spec = SearchSpec(Button::class.java)
-        expect(true) { spec.toPredicate().test(Button()) }
-        expect(false) { spec.toPredicate().test(Span()) }
-    }
-
-    test("id") {
-        val spec = SearchSpec(Component::class.java).apply { id = "25" }
-        expect(true) { spec.toPredicate().test(Button().apply { setId("25") }) }
-        expect(false) { spec.toPredicate().test(Button().apply { setId("42") }) }
-        expect(false) { spec.toPredicate().test(Button()) }
-    }
-
-    test("caption") {
-        val spec = SearchSpec(Component::class.java).apply { caption = "foo" }
-        expect(true) { spec.toPredicate().test(Button("foo")) }
-        expect(false) { spec.toPredicate().test(Button("bar")) }
-        expect(false) { spec.toPredicate().test(Button()) }
-        expect(true) { spec.toPredicate().test(Checkbox("foo")) }
-        expect(false) { spec.toPredicate().test(Checkbox("bar")) }
-        expect(false) { spec.toPredicate().test(Checkbox()) }
-        expect(true) {
-            spec.toPredicate().test(CheckboxGroup<Int>().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate().test(CheckboxGroup<Int>().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate().test(CheckboxGroup<Int>()) }
-        expect(true) {
-            spec.toPredicate().test(Select<Int>().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate().test(Select<Int>().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate().test(Select<Int>()) }
-        expect(true) {
-            spec.toPredicate().test(ListBox<Int>().also {
-                ComponentUtils.label(it, "foo")
-            })
-        }
-        expect(false) {
-            spec.toPredicate().test(ListBox<Int>().also {
-                ComponentUtils.label(it, "bar")
-            })
-        }
-        expect(false) { spec.toPredicate().test(ListBox<Int>()) }
-        expect(true) {
-            spec.toPredicate().test(RadioButtonGroup<Int>().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate().test(RadioButtonGroup<Int>().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate().test(RadioButtonGroup<Int>()) }
-        // tests CustomField
-        expect(true) {
-            spec.toPredicate().test(DateRangePopup().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate().test(DateRangePopup().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate().test(DateRangePopup()) }
-
-        expect(true) { spec.toPredicate().test(Input().also { ComponentUtils.label(it, "foo") }) }
-        expect(false) { spec.toPredicate().test(Input().also { ComponentUtils.label(it, "bar") }) }
-        expect(false) { spec.toPredicate().test(Input()) }
-        expect(true) { spec.toPredicate().test(TextField("foo")) }
-        expect(false) { spec.toPredicate().test(TextField("bar")) }
-        expect(false) { spec.toPredicate().test(TextField()) }
-        expect(true) { spec.toPredicate().test(TextArea("foo")) }
-        expect(false) { spec.toPredicate().test(TextArea("bar")) }
-        expect(false) { spec.toPredicate().test(TextArea()) }
-        expect(true) { spec.toPredicate().test(TimePicker("foo")) }
-        expect(false) { spec.toPredicate().test(TimePicker("bar")) }
-        expect(false) { spec.toPredicate().test(TimePicker()) }
-        expect(true) { spec.toPredicate().test(DatePicker("foo")) }
-        expect(false) { spec.toPredicate().test(DatePicker("bar")) }
-        expect(false) { spec.toPredicate().test(DatePicker()) }
-        expect(true) { spec.toPredicate().test(ComboBox<Int>("foo")) }
-        expect(false) { spec.toPredicate().test(ComboBox<Int>("bar")) }
-        expect(false) { spec.toPredicate().test(ComboBox<Int>()) }
-    }
-
-    test("text") {
-        val spec = SearchSpec(Component::class.java).apply { text = "foo" }
-        expect(true) { spec.toPredicate().test(Button("foo")) }
-        expect(false) { spec.toPredicate().test(Button("bar")) }
-        expect(false) { spec.toPredicate().test(Button()) }
-        expect(true) { spec.toPredicate().test(Text("foo")) }
-        expect(false) { spec.toPredicate().test(Text("bar")) }
-        expect(false) { spec.toPredicate().test(Text("")) }
-    }
-
-    test("predicates") {
-        var spec = SearchSpec(Component::class.java).apply {
-            predicates.add(Predicate { it is Button })
-        }
-        expect(true) { spec.toPredicate().test(Button()) }
-        expect(false) { spec.toPredicate().test(Span()) }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt
deleted file mode 100644
index 63a92048..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.karibudsl.v10.ModifierKey.Alt
-import com.github.mvysny.karibudsl.v10.addClickShortcut
-import com.github.mvysny.karibudsl.v10.button
-import com.github.mvysny.karibudsl.v10.onLeftClick
-import com.vaadin.browserless.internal.Shortcuts.fireShortcut
-import com.vaadin.browserless.internal.Utils.currentUI
-import com.vaadin.flow.component.Key
-import com.vaadin.flow.component.KeyModifier
-import com.vaadin.flow.component.Shortcuts
-import com.vaadin.flow.server.Command
-import kotlin.test.expect
-
-@DynaTestDsl
-internal fun DynaNodeGroup.shortcutsTestBatch() {
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-    test("smoke") {
-        fireShortcut(Key.ENTER) // nothing should happen
-    }
-
-    group("Button.addClickShortcut()") {
-        test("simple") {
-            var clicked = false
-            currentUI().button {
-                onLeftClick { clicked = true }
-                addClickShortcut(Key.ENTER)
-            }
-            fireShortcut(Key.ENTER)
-            expect(true) { clicked }
-        }
-
-        test("button not triggered on different key press") {
-            var clicked = false
-            currentUI().button {
-                onLeftClick { clicked = true }
-                addClickShortcut(Key.KEY_A)
-            }
-            fireShortcut(Key.ENTER)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE)
-            expect(false) { clicked }
-        }
-
-        test("button not triggered on different modifiers") {
-            var clicked = false
-            currentUI().button {
-                onLeftClick { clicked = true }
-                addClickShortcut(Alt + Key.KEY_A)
-            }
-            fireShortcut(Key.KEY_A)
-            expect(false) { clicked }
-            fireShortcut(Key.KEY_A, KeyModifier.CONTROL)
-            expect(false) { clicked }
-            fireShortcut(Key.KEY_A, KeyModifier.CONTROL, KeyModifier.ALT)
-            expect(false) { clicked }
-            fireShortcut(Key.KEY_A, KeyModifier.ALT)
-            expect(true) { clicked }
-        }
-
-        test("space") {
-            // Key.SPACE has multiple key bindings, test that out.
-            var clicked = false
-            currentUI().button {
-                onLeftClick { clicked = true }
-                addClickShortcut(Key.SPACE)
-            }
-            fireShortcut(Key.SPACE)
-            expect(true) { clicked }
-        }
-
-        test("space not triggered on different modifiers") {
-            var clicked = false
-            currentUI().button {
-                onLeftClick { clicked = true }
-                addClickShortcut(Alt + Key.SPACE)
-            }
-            fireShortcut(Key.ENTER)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE, KeyModifier.CONTROL)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE, KeyModifier.CONTROL, KeyModifier.ALT)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE, KeyModifier.ALT)
-            expect(true) { clicked }
-        }
-    }
-
-    group("Shortcuts.addShortcutListener()") {
-        test("simple") {
-            var clicked = false
-            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.ENTER)
-            fireShortcut(Key.ENTER)
-            expect(true) { clicked }
-        }
-
-        test("button not triggered on different key press") {
-            var clicked = false
-            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.KEY_A)
-            fireShortcut(Key.ENTER)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE)
-            expect(false) { clicked }
-        }
-
-        test("button not triggered on different modifiers") {
-            var clicked = false
-            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.KEY_A, KeyModifier.values()[2] /*ALT*/)
-            fireShortcut(Key.KEY_A)
-            expect(false) { clicked }
-            fireShortcut(Key.KEY_A, KeyModifier.CONTROL)
-            expect(false) { clicked }
-            fireShortcut(Key.KEY_A, KeyModifier.CONTROL, KeyModifier.ALT)
-            expect(false) { clicked }
-            fireShortcut(Key.KEY_A, KeyModifier.ALT)
-            expect(true) { clicked }
-        }
-
-        test("space") {
-            // Key.SPACE has multiple key bindings, test that out.
-            var clicked = false
-            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.SPACE)
-            fireShortcut(Key.SPACE)
-            expect(true) { clicked }
-        }
-
-        test("space not triggered on different modifiers") {
-            var clicked = false
-            Shortcuts.addShortcutListener(currentUI(), Command { clicked = true }, Key.SPACE, KeyModifier.values()[2] /*ALT*/)
-            fireShortcut(Key.ENTER)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE, KeyModifier.CONTROL)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE, KeyModifier.CONTROL, KeyModifier.ALT)
-            expect(false) { clicked }
-            fireShortcut(Key.SPACE, KeyModifier.ALT)
-            expect(true) { clicked }
-        }
-    }
-}
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockContextTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockContextTest.kt
deleted file mode 100644
index 82577b12..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockContextTest.kt
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.github.mvysny.dynatest.DynaTest
-import com.github.mvysny.dynatest.cloneBySerialization
-import com.github.mvysny.dynatest.expectList
-import kotlin.test.expect
-
-class MockContextTest : DynaTest({
-    lateinit var ctx: MockContext
-    beforeEach { ctx = MockContext() }
-
-    test("attributes") {
-        expect(null) { ctx.getAttribute("foo") }
-        expectList() { ctx.attributeNames.toList() }
-        ctx.setAttribute("foo", "bar")
-        expect("bar") { ctx.getAttribute("foo") }
-        expectList("foo") { ctx.attributeNames.toList() }
-        ctx.setAttribute("foo", null)
-        expect(null) { ctx.getAttribute("foo") }
-        expectList() { ctx.attributeNames.toList() }
-        ctx.setAttribute("foo", "bar")
-        expectList("foo") { ctx.attributeNames.toList() }
-        expect("bar") { ctx.getAttribute("foo") }
-        ctx.removeAttribute("foo")
-        expectList() { ctx.attributeNames.toList() }
-        expect(null) { ctx.getAttribute("foo") }
-    }
-
-    test("init parameters") {
-        expect(null) { ctx.getInitParameter("foo") }
-        expectList() { ctx.initParameterNames.toList() }
-        expect(true) { ctx.setInitParameter("foo", "bar") }
-        expectList("foo") { ctx.initParameterNames.toList() }
-        expect("bar") { ctx.getInitParameter("foo") }
-        expect(false) { ctx.setInitParameter("foo", "baz") }
-        expect("bar") { ctx.getInitParameter("foo") }
-        expectList("foo") { ctx.initParameterNames.toList() }
-    }
-
-    test("realPath") {
-        ctx.realPathRoots = listOf("src/main/webapp/frontend", "src/main/webapp", "src/test/webapp")
-        expect(null) { ctx.getRealPath("/index.html") }
-        expect(true) { ctx.getRealPath("/VAADIN/themes/default/img/1.txt")!!.replace('\\', '/').endsWith("/VAADIN/themes/default/img/1.txt") }
-        expect(true) { ctx.getRealPath("/VAADIN/themes/valo/../default/img/1.txt")!!.replace('\\', '/').endsWith("/VAADIN/themes/default/img/1.txt") }
-        // stepping out of root is not allowed and returns null. Avoids browsing through the filesystem
-        expect(null) { ctx.getRealPath("/../../../build.gradle.kts") }
-    }
-
-    test("serializable") {
-        ctx.setAttribute("foo", "bar")
-        ctx.setInitParameter("foo", "bar")
-        ctx.cloneBySerialization()
-    }
-})
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockHttpSessionTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockHttpSessionTest.kt
deleted file mode 100644
index e27e8637..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockHttpSessionTest.kt
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.github.mvysny.dynatest.DynaTest
-import com.github.mvysny.dynatest.cloneBySerialization
-import com.github.mvysny.dynatest.expectList
-import com.github.mvysny.dynatest.expectThrows
-import jakarta.servlet.http.HttpSession
-import java.io.Serializable
-import kotlin.test.expect
-
-class MockHttpSessionTest : DynaTest({
-    lateinit var session: HttpSession
-    beforeEach { session = MockHttpSession.create(MockContext()) }
-
-    test("attributes") {
-        expect(null) { session.getAttribute("foo") }
-        expectList() { session.attributeNames.toList() }
-        session.setAttribute("foo", "bar")
-        expectList("foo") { session.attributeNames.toList() }
-        expect("bar") { session.getAttribute("foo") }
-        session.setAttribute("foo", null)
-        expect(null) { session.getAttribute("foo") }
-        expectList() { session.attributeNames.toList() }
-        session.setAttribute("foo", "bar")
-        expect("bar") { session.getAttribute("foo") }
-        expectList("foo") { session.attributeNames.toList() }
-        session.removeAttribute("foo")
-        expect(null) { session.getAttribute("foo") }
-        expectList() { session.attributeNames.toList() }
-    }
-
-    test("serializable") {
-        session.setAttribute("foo", "bar")
-        (session as Serializable).cloneBySerialization()
-    }
-
-    group("invalidate") {
-        test("smoke") {
-            session.invalidate()
-            expect(false) { (session as MockHttpSession).isValid }
-        }
-        test("calling invalidate() second time throws") {
-            session.invalidate()
-            expectThrows(IllegalStateException::class) {
-                session.invalidate()
-            }
-        }
-        test("getAttribute() fails on invalidated session") {
-            session.invalidate()
-            expectThrows(IllegalStateException::class) {
-                session.getAttribute("foo")
-            }
-        }
-        test("getId() succeeds on invalidated session") {
-            session.invalidate()
-            session.id
-        }
-        test("getServletContext() succeeds on invalidated session") {
-            session.invalidate()
-            session.servletContext
-        }
-        test("maxActiveInterval succeeds on invalidated session") {
-            session.invalidate()
-            session.maxInactiveInterval = session.maxInactiveInterval + 1
-        }
-        test("getCreationTime() fails on invalidated session") {
-            session.invalidate()
-            expectThrows(IllegalStateException::class) {
-                session.creationTime
-            }
-        }
-        test("getLastAccessedTime() fails on invalidated session") {
-            session.invalidate()
-            expectThrows(IllegalStateException::class) {
-                session.lastAccessedTime
-            }
-        }
-        test("getAttributeNames() fails on invalidated session") {
-            session.invalidate()
-            expectThrows(IllegalStateException::class) {
-                session.attributeNames
-            }
-        }
-    }
-})
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt
deleted file mode 100644
index 98d05fb0..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockRequestTest.kt
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.github.mvysny.dynatest.DynaTest
-import com.github.mvysny.dynatest.expectList
-import com.github.mvysny.dynatest.expectThrows
-import kotlin.test.expect
-
-/**
- * @author mavi
- */
-class MockRequestTest : DynaTest({
-    lateinit var request: MockRequest
-    beforeEach { request = MockRequest(MockHttpSession.create(MockContext())) }
-
-    test("attributes") {
-        expect(null) { request.getAttribute("foo") }
-        request.setAttribute("foo", "bar")
-        expect("bar") { request.getAttribute("foo") }
-        request.setAttribute("foo", null)
-        expect(null) { request.getAttribute("foo") }
-        request.setAttribute("foo", "bar")
-        expect("bar") { request.getAttribute("foo") }
-        request.removeAttribute("foo")
-        expect(null) { request.getAttribute("foo") }
-    }
-
-    test("parameters") {
-        expect(null) { request.getParameter("foo") }
-        expectList() { request.parameterNames.toList() }
-        expect(null) { request.getParameterValues("foo") }
-        request.setParameter("foo", "bar")
-        expect("bar") { request.getParameter("foo") }
-        expectList("foo") { request.parameterNames.toList() }
-        expectList("bar") { request.getParameterValues("foo")!!.toList() }
-        request.parameters["foo"] = arrayOf("bar", "baz")
-        expect("bar") { request.getParameter("foo") }
-        expectList("foo") { request.parameterNames.toList() }
-        expectList("bar", "baz") { request.getParameterValues("foo")!!.toList() }
-    }
-
-    test("getSession(false) returns null once the session is invalidated") {
-        // Mirrors the servlet container contract: after invalidation there is
-        // no current session, so getSession(false) must return null rather than
-        // the stale, invalidated session. See issue #115.
-        val session = request.session as MockHttpSession
-        expect(true) { session.isValid }
-        session.setAttribute("foo", "bar")
-        session.invalidate()
-        expect(null) { request.getSession(false) }
-        expect(false) { session.isValid }
-    }
-
-    test("getSession(true) creates a new session when invalidated") {
-        var session = request.session as MockHttpSession
-        val requestedId = request.requestedSessionId
-        expect(true) { session.isValid }
-        session.setAttribute("foo", "bar")
-        session.invalidate()
-        expect(false) { session.isValid }
-        expect(true) { session != request.getSession(true) }
-        session = request.getSession(true) as MockHttpSession
-        expect(true) { session.isValid }
-        expect(null) { session.getAttribute("foo") }
-        // the replacement session has its own ID, but the ID the client asked
-        // for stays the same for the lifetime of the request
-        expect(true) { session.id != requestedId }
-        expect(requestedId) { request.requestedSessionId }
-    }
-
-    test("getSession() creates a new session when invalidated") {
-        var session = request.session as MockHttpSession
-        expect(true) { session.isValid }
-        session.setAttribute("foo", "bar")
-        session.invalidate()
-        expect(false) { session.isValid }
-        expect(true) { session != request.session }
-        session = request.session as MockHttpSession
-        expect(true) { session.isValid }
-        expect(null) { session.getAttribute("foo") }
-    }
-
-    test("changeSessionId() rotates the ID but keeps the session and its attributes") {
-        // Apps which do not use Spring Security do session-fixation protection
-        // themselves by calling changeSessionId() after a successful login; the
-        // session (and thus the VaadinSession stored in it) must survive that.
-        val session = request.session as MockHttpSession
-        val oldId = session.id
-        session.setAttribute("foo", "bar")
-
-        val newId = request.changeSessionId()
-
-        expect(true) { newId != oldId }
-        expect(newId) { session.id }
-        expect(session) { request.session }
-        expect("bar") { session.getAttribute("foo") }
-        // the client keeps sending the ID it was given until it picks up the
-        // new one, so the requested ID does not change
-        expect(oldId) { request.requestedSessionId }
-    }
-
-    test("changeSessionId() fails once the session is invalidated") {
-        (request.session as MockHttpSession).invalidate()
-        expectThrows(IllegalStateException::class) {
-            request.changeSessionId()
-        }
-    }
-
-    test("principal") {
-        expect(null) { request.userPrincipal }
-        request.userPrincipalInt = MockPrincipal("foo")
-        expect(MockPrincipal("foo")) { request.userPrincipal }
-    }
-
-    test("isUserInRole") {
-        expect(false) { request.isUserInRole("foo") }
-        request.userPrincipalInt = MockPrincipal("foo")
-        expect(false) { request.isUserInRole("foo") }
-        request.userPrincipalInt = MockPrincipal("foo", listOf("foo"))
-        expect(false) { request.isUserInRole("foo") }
-        request.isUserInRole = java.util.function.BiPredicate { p, r -> (p as MockPrincipal).isUserInRole(r) }
-        expect(true) { request.isUserInRole("foo") }
-    }
-})
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockResponseTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockResponseTest.kt
deleted file mode 100644
index 413f6ed7..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/MockResponseTest.kt
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.github.mvysny.dynatest.DynaTest
-import com.github.mvysny.dynatest.expectList
-import com.github.mvysny.dynatest.expectThrows
-import jakarta.servlet.http.Cookie
-import kotlin.test.expect
-
-class MockResponseTest : DynaTest({
-    lateinit var request: MockResponse
-    beforeEach { request = MockResponse() }
-
-    test("headers") {
-        expect(null) { request.getHeader("foo") }
-        expectList() { request.headerNames.toList() }
-        expectList() { request.getHeaders("foo").toList() }
-        request.setHeader("foo", "bar")
-        expect("bar") { request.getHeader("foo") }
-        expectList("foo") { request.headerNames.toList() }
-        expectList("bar") { request.getHeaders("foo").toList() }
-        request.headers["foo"] = arrayOf("bar", "baz")
-        expect("bar") { request.getHeader("foo") }
-        expectList("foo") { request.headerNames.toList() }
-        expectList("bar", "baz") { request.getHeaders("foo").toList() }
-    }
-
-    test("cookies") {
-        request.cookies += Cookie("foo", "bar")
-        expect("bar") { request.getCookie("foo").value }
-        expect(null) { request.findCookie("qqq") }
-        expectThrows(IllegalStateException::class, "no such cookie with name baz. Available cookies: foo=bar") {
-            request.getCookie("baz")
-        }
-    }
-})
diff --git a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt b/junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt
deleted file mode 100644
index 6ed3153e..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/mocks/SessionAttributeMapTest.kt
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.github.mvysny.dynatest.DynaTest
-import kotlin.test.expect
-
-/**
- * @author mavi
- */
-class SessionAttributeMapTest : DynaTest({
-    lateinit var session: MockHttpSession
-    lateinit var attrs: MutableMap<String, Any>
-    beforeEach {
-        session = MockHttpSession.create(MockContext())
-        attrs = SessionAttributeMap(session)
-    }
-
-    group("size") {
-        test("Initially zero") {
-            expect(0) { attrs.size }
-        }
-        test("put increases by 1") {
-            attrs["foo"] = "bar"
-            expect(1) { attrs.size }
-        }
-        test("setAttribute increases by 1") {
-            session.setAttribute("foo", "bar")
-            expect(1) { attrs.size }
-        }
-        test("clear sets size to 0") {
-            attrs["foo"] = "bar"
-            attrs.clear()
-            expect(0) { attrs.size }
-        }
-    }
-
-    group("is empty") {
-        test("Initially true") {
-            expect(true) { attrs.isEmpty() }
-        }
-        test("put makes map not empty") {
-            attrs["foo"] = "bar"
-            expect(false) { attrs.isEmpty() }
-        }
-        test("setAttribute makes map not empty") {
-            session.setAttribute("foo", "bar")
-            expect(false) { attrs.isEmpty() }
-        }
-        test("clear sets size to 0") {
-            attrs["foo"] = "bar"
-            attrs.clear()
-            expect(true) { attrs.isEmpty() }
-        }
-    }
-
-    group("get") {
-        test("get from empty map returns null") {
-            expect(null) { attrs["foo"] }
-        }
-        test("get non-existing key returns null") {
-            session.setAttribute("foo", "bar")
-            expect(null) { attrs["bar"] }
-        }
-        test("existing key retrieval") {
-            session.setAttribute("foo", "bar")
-            expect("bar") { attrs["foo"] }
-        }
-        test("get deleted key returns null") {
-            session.setAttribute("foo", "bar")
-            attrs.remove("foo")
-            expect(null) { attrs["foo"] }
-        }
-    }
-
-    group("remove") {
-        test("remove from empty map does nothing") {
-            expect(null) { attrs.remove("foo") }
-            expect(true) { attrs.isEmpty() }
-        }
-        test("remove non-existing key does nothing") {
-            attrs["bar"] = "foo"
-            expect(null) { attrs.remove("foo") }
-            expect("foo") { attrs["bar"] }
-            expect("foo") { session.getAttribute("bar") }
-        }
-        test("remove existing key") {
-            attrs["bar"] = "foo"
-            expect("foo") { attrs.remove("bar") }
-            expect(true) { attrs.isEmpty() }
-            expect(null) { session.getAttribute("bar") }
-        }
-    }
-
-    group("clear") {
-        test("clear empty map does nothing") {
-            attrs.clear()
-            expect(true) { attrs.isEmpty() }
-        }
-        test("clear map with one key") {
-            attrs["foo"] = "bar"
-            attrs.clear()
-            expect(true) { attrs.isEmpty() }
-        }
-        test("clear big map") {
-            (0..1000).forEach { session.setAttribute(it.toString(), it) }
-            expect(false) { attrs.isEmpty() }
-            attrs.clear()
-            expect(true) { attrs.isEmpty() }
-            (0..1000).forEach {
-                expect(null) { session.getAttribute(it.toString()) }
-            }
-        }
-    }
-})
diff --git a/pom.xml b/pom.xml
index 2115215c..3f8d37f5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -42,8 +42,6 @@
         <failsafe.version>3.5.5</failsafe.version>
         <surefire.version>3.5.5</surefire.version>
         <spotless.plugin.version>3.2.1</spotless.plugin.version>
-        <kotlin.version>2.2.20</kotlin.version>
-        <dokka.version>2.1.0</dokka.version>
         <maven.compiler.source>${maven.compiler.release}</maven.compiler.source>
         <maven.compiler.target>${maven.compiler.release}</maven.compiler.target>
         <maven.compiler.plugin.version>3.14.0</maven.compiler.plugin.version>
@@ -122,42 +120,11 @@
                     <artifactId>maven-failsafe-plugin</artifactId>
                     <version>${failsafe.version}</version>
                 </plugin>
-                <plugin>
-                    <groupId>org.jetbrains.kotlin</groupId>
-                    <artifactId>kotlin-maven-plugin</artifactId>
-                    <version>${kotlin.version}</version>
-                </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-compiler-plugin</artifactId>
                     <version>${maven.compiler.plugin.version}</version>
                 </plugin>
-                <plugin>
-                    <groupId>org.jetbrains.dokka</groupId>
-                    <artifactId>dokka-maven-plugin</artifactId>
-                    <version>${dokka.version}</version>
-                    <!-- Javadoc generation for mixed Java/Kotlin modules.
-                         Gated by maven.javadoc.skip (true by default); the
-                         javadocs and release profiles flip it to false. Only
-                         runs in modules that reference this plugin. -->
-                    <configuration>
-                        <skip>${maven.javadoc.skip}</skip>
-                        <jdkVersion>${maven.compiler.source}</jdkVersion>
-                        <sourceDirectories>
-                            <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
-                            <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
-                        </sourceDirectories>
-                    </configuration>
-                    <executions>
-                        <execution>
-                            <id>attach-javadocs</id>
-                            <phase>package</phase>
-                            <goals>
-                                <goal>javadocJar</goal>
-                            </goals>
-                        </execution>
-                    </executions>
-                </plugin>
                 <plugin>
                     <groupId>org.codehaus.mojo</groupId>
                     <artifactId>build-helper-maven-plugin</artifactId>
@@ -216,20 +183,13 @@
                             <file>${maven.multiModuleProjectDirectory}/eclipse/apache2-license-header.txt</file>
                         </licenseHeader>
                     </java>
-                    <kotlin>
-                        <licenseHeader>
-                            <file>${maven.multiModuleProjectDirectory}/eclipse/apache2-license-header.txt</file>
-                        </licenseHeader>
-                    </kotlin>
                 </configuration>
             </plugin>
         </plugins>
     </build>
     <profiles>
         <!-- Activated during CI validation via -Djavadocs. Enables the
-             Javadoc executions declared in pluginManagement; the tool used
-             (Dokka vs maven-javadoc) is selected per module by which plugin
-             that module references. -->
+             Javadoc executions declared in pluginManagement. -->
         <profile>
             <id>javadocs</id>
             <activation>
diff --git a/shared/pom.xml b/shared/pom.xml
index df46c208..600ae1d7 100644
--- a/shared/pom.xml
+++ b/shared/pom.xml
@@ -15,67 +15,18 @@
 
     <build>
         <plugins>
-            <!--
-                To compile projects that include Kotlin and Java source code, the Kotlin compiler should run before
-                the Java compiler.
-                That means that kotlin-maven-plugin definition must be placed before maven-compiler-plugin
-            -->
-            <plugin>
-                <groupId>org.jetbrains.kotlin</groupId>
-                <artifactId>kotlin-maven-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>test-compile</id>
-                        <goals>
-                            <goal>test-compile</goal>
-                        </goals>
-                        <configuration>
-                            <sourceDirs>
-                                <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
-                                <sourceDir>${project.basedir}/src/test/java</sourceDir>
-                            </sourceDirs>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <executions>
-                    <!-- Replacing default-compile as it is treated specially by maven -->
-                    <execution>
-                        <id>default-compile</id>
-                        <phase>none</phase>
-                    </execution>
-                    <!-- Replacing default-testCompile as it is treated specially by maven -->
-                    <execution>
-                        <id>default-testCompile</id>
-                        <phase>none</phase>
-                    </execution>
-                    <execution>
-                        <id>java-compile</id>
-                        <phase>compile</phase>
-                        <goals>
-                            <goal>compile</goal>
-                        </goals>
-                        <configuration>
-                            <annotationProcessorPaths>
-                                <path>
-                                    <groupId>com.vaadin</groupId>
-                                    <artifactId>browserless-test-locator-processor</artifactId>
-                                    <version>${project.version}</version>
-                                </path>
-                            </annotationProcessorPaths>
-                        </configuration>
-                    </execution>
-                    <execution>
-                        <id>java-test-compile</id>
-                        <phase>test-compile</phase>
-                        <goals>
-                            <goal>testCompile</goal>
-                        </goals>
-                    </execution>
-                </executions>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>com.vaadin</groupId>
+                            <artifactId>browserless-test-locator-processor</artifactId>
+                            <version>${project.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
             </plugin>
             <!-- Pure-Java main sources: Javadocs are generated by
                  maven-javadoc-plugin. The attach-javadocs execution is
@@ -159,14 +110,14 @@
             <scope>test</scope>
         </dependency>
 
-        <!-- Only shared/src/test/kotlin needs Kotlin; the main sources are
-             pure Java, so consumers pull no Kotlin runtime. -->
+        <!-- Declared explicitly: this module's tests used to pick JUnit up
+             transitively, through a test dependency that is now gone. -->
         <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kotlin-stdlib</artifactId>
-            <version>${kotlin.version}</version>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
             <scope>test</scope>
         </dependency>
+
         <dependency>
             <groupId>io.github.classgraph</groupId>
             <artifactId>classgraph</artifactId>
@@ -188,13 +139,6 @@
             <optional>true</optional>
         </dependency>
 
-        <dependency>
-            <groupId>com.github.mvysny.dynatest</groupId>
-            <artifactId>dynatest</artifactId>
-            <version>0.25</version>
-            <scope>test</scope>
-        </dependency>
-
         <dependency>
             <groupId>jakarta.servlet</groupId>
             <artifactId>jakarta.servlet-api</artifactId>
diff --git a/shared/src/test/java/com/vaadin/browserless/internal/IsTemplateTest.java b/shared/src/test/java/com/vaadin/browserless/internal/IsTemplateTest.java
new file mode 100644
index 00000000..284c223c
--- /dev/null
+++ b/shared/src/test/java/com/vaadin/browserless/internal/IsTemplateTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.internal;
+
+import org.jsoup.nodes.Element;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.littemplate.LitTemplate;
+import com.vaadin.flow.component.polymertemplate.PolymerTemplate;
+import com.vaadin.flow.component.polymertemplate.TemplateParser;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.templatemodel.TemplateModel;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@SuppressWarnings({ "deprecation", "removal" })
+public class IsTemplateTest {
+
+    @BeforeEach
+    void setUp() {
+        MockVaadin.setup();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockVaadin.tearDown();
+    }
+
+    @Test
+    void isTemplate_litAndPolymerTemplates_trueOnlyForTemplates() {
+        assertFalse(TestingLifecycleHook.isTemplate(new Button("foo")));
+        assertTrue(TestingLifecycleHook.isTemplate(new MyLitTemplate()));
+        assertTrue(TestingLifecycleHook.isTemplate(new MyPolymerTemplate()));
+    }
+
+    public interface MyModel extends TemplateModel {
+    }
+
+    public static class MyTemplateParser implements TemplateParser {
+        @Override
+        public TemplateData getTemplateContent(
+                Class<? extends PolymerTemplate<?>> clazz, String tag,
+                VaadinService service) {
+            return new TemplateData("", new Element(tag));
+        }
+    }
+
+    @Tag("my-polymer")
+    public static class MyPolymerTemplate extends PolymerTemplate<MyModel> {
+        public MyPolymerTemplate() {
+            super(new MyTemplateParser());
+        }
+    }
+
+    @Tag("my-lit")
+    public static class MyLitTemplate extends LitTemplate {
+    }
+}
diff --git a/shared/src/test/java/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.java b/shared/src/test/java/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.java
new file mode 100644
index 00000000..8acf8713
--- /dev/null
+++ b/shared/src/test/java/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.browserless.mocks;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.di.InstantiatorFactory;
+import com.vaadin.flow.di.LookupInitializer;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class BrowserlessLookupInitializerTest {
+
+    @Test
+    void updateServices_addsDefaultImplWhenInterfaceIsAbsent() {
+        TestInitializer initializer = new TestInitializer(
+                Map.of(FakeService.class, FakeServiceImpl.class));
+        Set<Class<?>> services = new LinkedHashSet<>();
+
+        initializer.updateServices(services);
+
+        assertTrue(services.contains(FakeServiceImpl.class));
+    }
+
+    @Test
+    void updateServices_skipsEntryWhenCallerAlreadySuppliedAnImplementation() {
+        TestInitializer initializer = new TestInitializer(
+                Map.of(FakeService.class, FakeServiceImpl.class));
+        Set<Class<?>> services = new LinkedHashSet<>(
+                Set.of(OtherFakeServiceImpl.class));
+
+        initializer.updateServices(services);
+
+        assertTrue(services.contains(OtherFakeServiceImpl.class));
+        assertFalse(services.contains(FakeServiceImpl.class));
+    }
+
+    @Test
+    void updateServices_skipsEntriesWhoseDefaultIsTheObjectPlaceholder() {
+        TestInitializer initializer = new TestInitializer(
+                Map.of(NoDefaultService.class, Object.class));
+        Set<Class<?>> services = new LinkedHashSet<>();
+
+        initializer.updateServices(services);
+
+        assertTrue(services.isEmpty());
+    }
+
+    @Test
+    void getServiceTypes_extendsParentServiceTypesWithAdditionalServicesKeys() {
+        TestInitializer initializer = new TestInitializer(
+                Map.of(FakeService.class, FakeServiceImpl.class));
+
+        Collection<Class<?>> types = initializer.getServiceTypes();
+
+        assertTrue(types.contains(FakeService.class));
+        assertTrue(types.contains(InstantiatorFactory.class));
+    }
+
+    @Test
+    void getServiceTypes_excludesLookupInitializerEvenWhenAddedAsAnAdditionalService() {
+        TestInitializer initializer = new TestInitializer(
+                Map.of(LookupInitializer.class, FakeServiceImpl.class));
+
+        Collection<Class<?>> types = initializer.getServiceTypes();
+
+        assertFalse(types.contains(LookupInitializer.class));
+    }
+
+    private interface FakeService {
+    }
+
+    private static class FakeServiceImpl implements FakeService {
+    }
+
+    private static class OtherFakeServiceImpl implements FakeService {
+    }
+
+    private interface NoDefaultService {
+    }
+
+    private static class TestInitializer
+            extends MockVaadinHelper.BrowserlessLookupInitializer {
+
+        TestInitializer(Map<Class<?>, Class<?>> services) {
+            this.additionalServices = services;
+        }
+
+        @Override
+        public Collection<Class<?>> getServiceTypes() {
+            return super.getServiceTypes();
+        }
+    }
+}
diff --git a/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt b/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
deleted file mode 100644
index 2cf598ad..00000000
--- a/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.internal
-
-import kotlin.test.expect
-import com.vaadin.flow.component.Tag
-import com.vaadin.flow.component.button.Button
-import com.vaadin.flow.component.littemplate.LitTemplate
-import com.vaadin.flow.component.polymertemplate.PolymerTemplate
-import com.vaadin.flow.component.polymertemplate.TemplateParser
-import com.vaadin.flow.server.VaadinService
-import com.vaadin.flow.templatemodel.TemplateModel
-import com.github.mvysny.dynatest.DynaTest
-import org.jsoup.nodes.Element
-
-class AllTests : DynaTest({
-
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-
-    test("Component.isTemplate") {
-        expect(false) { TestingLifecycleHook.isTemplate(Button("foo")) }
-        expect(true) { TestingLifecycleHook.isTemplate(MyLitTemplate()) }
-        expect(true) { TestingLifecycleHook.isTemplate(MyPolymerTemplate()) }
-    }
-
-})
-
-internal interface MyModel : TemplateModel
-internal class MyTemplateParser : TemplateParser {
-    override fun getTemplateContent(
-        clazz: Class<out PolymerTemplate<*>>?,
-        tag: String?,
-        service: VaadinService?
-    ): TemplateParser.TemplateData {
-        return TemplateParser.TemplateData("", Element(tag!!))
-    }
-
-}
-@Tag("my-polymer")
-internal class MyPolymerTemplate : PolymerTemplate<MyModel>(MyTemplateParser()) {
-
-}
-@Tag("my-lit")
-internal class MyLitTemplate : LitTemplate()
\ No newline at end of file
diff --git a/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt b/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt
deleted file mode 100644
index 6cb6200f..00000000
--- a/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright 2000-2026 Vaadin Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.vaadin.browserless.mocks
-
-import com.github.mvysny.dynatest.DynaTest
-import com.vaadin.flow.di.InstantiatorFactory
-import com.vaadin.flow.di.LookupInitializer
-import kotlin.test.expect
-
-class BrowserlessLookupInitializerTest : DynaTest({
-
-    test("updateServices adds default impl when interface is absent") {
-        val initializer = TestInitializer(
-                mapOf(FakeService::class.java to FakeServiceImpl::class.java))
-        val services = mutableSetOf<Class<*>>()
-
-        initializer.updateServices(services)
-
-        expect(true) { services.contains(FakeServiceImpl::class.java) }
-    }
-
-    test("updateServices skips entry when caller already supplied an implementation") {
-        val initializer = TestInitializer(
-                mapOf(FakeService::class.java to FakeServiceImpl::class.java))
-        val services = mutableSetOf<Class<*>>(OtherFakeServiceImpl::class.java)
-
-        initializer.updateServices(services)
-
-        expect(true) { services.contains(OtherFakeServiceImpl::class.java) }
-        expect(false) { services.contains(FakeServiceImpl::class.java) }
-    }
-
-    test("updateServices skips entries whose default is the Object placeholder") {
-        val initializer = TestInitializer(
-                mapOf(NoDefaultService::class.java to Object::class.java))
-        val services = mutableSetOf<Class<*>>()
-
-        initializer.updateServices(services)
-
-        expect(true) { services.isEmpty() }
-    }
-
-    test("getServiceTypes extends parent service types with additionalServices keys") {
-        val initializer = TestInitializer(
-                mapOf(FakeService::class.java to FakeServiceImpl::class.java))
-
-        val types = initializer.serviceTypes
-
-        expect(true) { types.contains(FakeService::class.java) }
-        expect(true) { types.contains(InstantiatorFactory::class.java) }
-    }
-
-    test("getServiceTypes excludes LookupInitializer even when added as an additional service") {
-        val initializer = TestInitializer(
-                mapOf(LookupInitializer::class.java to FakeServiceImpl::class.java))
-
-        val types = initializer.serviceTypes
-
-        expect(false) { types.contains(LookupInitializer::class.java) }
-    }
-})
-
-private interface FakeService
-private class FakeServiceImpl : FakeService
-private class OtherFakeServiceImpl : FakeService
-private interface NoDefaultService
-
-private class TestInitializer(
-        services: Map<Class<*>, Class<*>>
-) : MockVaadinHelper.BrowserlessLookupInitializer() {
-    init {
-        this.additionalServices = services
-    }
-    public override fun getServiceTypes(): Collection<Class<*>?> = super.getServiceTypes()
-}

From 81947c4b760a27519af0b620dd416baa84a319eb Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 19:18:30 +0000
Subject: [PATCH 08/13] docs: fix the doclint issues in `shared`

`shared` now builds clean under doclint, errors and warnings both, so
`<doclint>none</doclint>` is gone from its pom.

The "roughly 200 issues" that setting was added for was javadoc's output
cap, not the count: the tool stops after 100 errors and 100 warnings. The
real number was 935. The root pom now passes `-Xmaxerrs`/`-Xmaxwarns` so
the next reader gets a count rather than a ceiling.

Most of it was missing `@param`, `@return` and member descriptions in the
files the Kotlin port rewrote, since KDoc carries none of those tags. The
genuine defects were unresolvable `@link` and `@throws` targets, `<p/>`
and empty `<p>`, and markup that javadoc read as HTML.

`locator-processor` accounted for 291 of them, because it copies a tester
method's Javadoc into the generated `*Locator`. It now documents the
generated class's type parameters and both constructors, and rewrites a
copied `{@link #member}` to point back at the tester. The generated file
has no imports, so a tester has to spell cross-package `@link` and
`@throws` targets out in full; that rule is now in the guidelines.

Also converts the Javadoc the port left in KDoc markup, `[TreeGrid]` and
`*skip*`, to `{@link}`, `{@code}` and `<em>`.
---
 CONVENTIONS.md                                |   5 +
 de-kotlin-plan.md                             |  44 +-
 guidelines/documenting.md                     |   9 +
 .../locator/processor/LocatorProcessor.java   |  62 +-
 pom.xml                                       |   7 +
 shared/pom.xml                                |  12 -
 .../browserless/BaseBrowserlessTest.java      |  96 ++-
 .../browserless/BrowserlessConfiguration.java |   9 +
 .../BrowserlessTestSetupException.java        |  14 +
 .../browserless/CommercialTesterWrappers.java |   4 +
 .../vaadin/browserless/ComponentQuery.java    |  21 +-
 .../vaadin/browserless/ComponentTester.java   |  27 +-
 .../browserless/ComponentTesterPackages.java  |   4 +-
 .../vaadin/browserless/ElementConditions.java |  39 +-
 .../com/vaadin/browserless/MouseButton.java   |  15 +-
 .../SecuredBrowserlessApplicationContext.java |  96 +++
 .../browserless/SecurityContextHandler.java   |   2 +
 .../browserless/SerializationDebugUtil.java   |   3 +
 .../browserless/TestSignalEnvironment.java    |   3 +
 .../vaadin/browserless/TesterWrappers.java    | 590 ++++++++++++++++-
 .../java/com/vaadin/browserless/Tests.java    |   8 +-
 .../browserless/component/GridUtils.java      | 603 +++++++++++++++---
 .../browserless/internal/BasicUtils.java      |  61 +-
 .../internal/BrowserlessFeatureFlags.java     |   3 +
 .../browserless/internal/ComponentUtils.java  | 194 +++++-
 .../browserless/internal/CountRange.java      |   6 +
 .../internal/DepthFirstTreeIterator.java      |   6 +
 .../browserless/internal/ElementUtils.java    |  54 ++
 .../vaadin/browserless/internal/Locator.java  | 209 ++++++
 .../internal/MockInternalSeverError.java      |   6 +
 .../internal/MockRequestCustomizer.java       |   6 +
 .../internal/MockRouteNotFoundError.java      |  10 +
 .../browserless/internal/MockVaadin.java      | 214 ++++++-
 .../browserless/internal/PrettyPrintTree.java |  27 +-
 .../browserless/internal/Renderers.java       |  43 ++
 .../vaadin/browserless/internal/Routes.java   |  72 +++
 .../browserless/internal/SearchSpec.java      | 167 +++++
 .../browserless/internal/SessionObjects.java  |  58 ++
 .../browserless/internal/Shortcuts.java       |  14 +-
 .../browserless/internal/UIFactory.java       |   5 +
 .../vaadin/browserless/internal/Utils.java    |  61 ++
 .../locator/HasAriaLabelFilter.java           |   8 +
 .../browserless/locator/HasLabelFilter.java   |   8 +
 .../locator/HasPlaceholderFilter.java         |   8 +
 .../browserless/locator/HasTextFilter.java    |  16 +-
 .../browserless/locator/HasThemeFilter.java   |  14 +
 .../browserless/locator/HasValueFilter.java   |   4 +
 .../vaadin/browserless/locator/Locator.java   |  89 ++-
 .../vaadin/browserless/mocks/MockContext.java |  24 +
 .../browserless/mocks/MockHttpSession.java    |  18 +
 .../browserless/mocks/MockInstantiator.java   |   3 +
 .../vaadin/browserless/mocks/MockRequest.java |  15 +
 .../browserless/mocks/MockResponse.java       |   6 +
 .../vaadin/browserless/mocks/MockService.java |   3 +
 .../browserless/mocks/MockVaadinServlet.java  |  39 ++
 .../browserless/mocks/MockVaadinSession.java  |   3 +
 .../vaadin/browserless/mocks/MockedUI.java    |   6 +
 .../mocks/SessionAttributeMap.java            |   6 +
 .../component/accordion/AccordionTester.java  |   4 +
 .../component/avatar/AvatarGroupTester.java   |   8 +-
 .../breadcrumbs/BreadcrumbsTester.java        |   4 +
 .../flow/component/card/CardTester.java       |  15 +-
 .../flow/component/charts/ChartTester.java    |  60 +-
 .../checkbox/CheckboxGroupTester.java         |   2 +
 .../component/combobox/ComboBoxTester.java    |  10 +-
 .../combobox/MultiSelectComboBoxTester.java   |  10 +-
 .../confirmdialog/ConfirmDialogTester.java    |   7 +-
 .../contextmenu/ContextMenuTester.java        |   6 +-
 .../datepicker/DatePickerTester.java          |   6 +-
 .../datetimepicker/DateTimePickerTester.java  |   4 +-
 .../flow/component/dialog/DialogTester.java   |   2 +
 .../BrowserlessGeolocationClientFactory.java  |   6 +
 .../geolocation/GeolocationRequest.java       |  18 +-
 .../geolocation/GeolocationSimulator.java     |   3 +
 .../GeolocationTrackerSession.java            |  18 +-
 .../flow/component/grid/GridTester.java       |  67 +-
 .../flow/component/html/AnchorTester.java     |   6 +-
 .../component/html/DescriptionListTester.java |   2 +
 .../vaadin/flow/component/html/DivTester.java |   2 +
 .../flow/component/html/EmphasisTester.java   |   2 +
 .../vaadin/flow/component/html/H1Tester.java  |   2 +
 .../vaadin/flow/component/html/H2Tester.java  |   2 +
 .../vaadin/flow/component/html/H3Tester.java  |   2 +
 .../vaadin/flow/component/html/H4Tester.java  |   2 +
 .../vaadin/flow/component/html/H5Tester.java  |   2 +
 .../vaadin/flow/component/html/H6Tester.java  |   2 +
 .../vaadin/flow/component/html/HrTester.java  |   2 +
 .../component/html/HtmlClickContainer.java    |   4 +
 .../component/html/HtmlComponentTester.java   |   4 +
 .../component/html/HtmlContainerTester.java   |   4 +
 .../flow/component/html/ImageTester.java      |   2 +
 .../flow/component/html/InputTester.java      |   4 +-
 .../flow/component/html/ListItemTester.java   |   2 +
 .../component/html/NativeButtonTester.java    |   2 +
 .../component/html/NativeDetailsTester.java   |   2 +
 .../component/html/NativeLabelTester.java     |   2 +
 .../component/html/OrderedListTester.java     |   2 +
 .../flow/component/html/ParagraphTester.java  |   2 +
 .../vaadin/flow/component/html/PreTester.java |   2 +
 .../flow/component/html/RangeInputTester.java |   7 +-
 .../flow/component/html/SpanTester.java       |   2 +
 .../component/html/UnorderedListTester.java   |   2 +
 .../flow/component/menubar/MenuBarTester.java |   2 +
 .../component/messages/MessageListTester.java |   9 +-
 .../radiobutton/RadioButtonTester.java        |   6 +
 .../routerlink/RouterLinkTester.java          |   8 +-
 .../flow/component/select/SelectTester.java   |   6 +
 .../flow/component/sidenav/SideNavTester.java |   4 +
 .../flow/component/tabs/TabSheetTester.java   |   5 +
 .../flow/component/tabs/TabsTester.java       |   2 +
 .../textfield/NumberFieldTester.java          |   6 +-
 .../component/textfield/TextAreaTester.java   |   4 +-
 .../component/textfield/TextFieldTester.java  |   4 +-
 .../timepicker/TimePickerTester.java          |   6 +-
 .../component/treegrid/TreeGridTester.java    |  29 +-
 .../flow/component/upload/UploadTester.java   |  18 +-
 .../virtuallist/VirtualListTester.java        |  12 +-
 117 files changed, 3267 insertions(+), 332 deletions(-)

diff --git a/CONVENTIONS.md b/CONVENTIONS.md
index 7295bb35..5460c6a9 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -146,6 +146,11 @@ detail.
 Javadoc describes the code today, not what changed. Change history belongs in
 commit messages.
 
+In a tester, spell cross-package `@link` and `@throws` targets out in full:
+`locator-processor` copies the Javadoc into the generated `*Locator`, which has
+no imports. `shared` builds clean under doclint, so every published member needs
+a description, its `@param`s and its `@return`.
+
 See [`guidelines/documenting.md`](guidelines/documenting.md).
 
 ## Testing
diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index 0b79f80f..4cb5bef3 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -199,13 +199,10 @@ classpath, so downstream consumers pull no Kotlin runtime.
   puts on the classpath at `provided` scope — no new dependency.
 
 **Replacing Dokka turns Javadoc validation on for the first time.** Dokka
-validated nothing, so `maven-javadoc-plugin` immediately fails `shared` on about
-200 doclint issues across 53 files — mostly `self` errors from `<p/>`, missing
-`@param` on type variables, and unresolvable `@link` targets, nearly all in
-testers untouched by the port. `shared` therefore sets `<doclint>none</doclint>`
-so the port does not turn into a module-wide Javadoc cleanup. That cleanup is
-worth doing on its own, tightening the setting back a step at a time; the other
-modules already run with doclint on.
+validated nothing, so `maven-javadoc-plugin` fails `shared` the moment it
+replaces it. `shared` carried `<doclint>none</doclint>` through Phase 5 so the
+port would not turn into a module-wide Javadoc cleanup; see
+[Phase 7](#phase-7--the-doclint-cleanup--done) for that cleanup.
 
 ### Phase 6 — test-side Kotlin — done
 
@@ -246,6 +243,39 @@ block leaves no trace. Every step was checked by comparing the *multiset of
 not the `tests="N"` attribute, which DynaTest under-reports. 1,448 before,
 1,448 after, with all 225 renamed names pairing one-for-one.
 
+### Phase 7 — the doclint cleanup — done
+
+`shared` builds clean under doclint, errors and warnings both, and
+`<doclint>none</doclint>` is gone from its pom.
+
+The "roughly 200 issues" the Phase 5 note quoted was **javadoc's output cap**,
+not the count: the tool stops after 100 errors and 100 warnings. The real
+number was 935. The root pom now passes `-Xmaxerrs`/`-Xmaxwarns` so the next
+person reads a count rather than a ceiling.
+
+- Three groups were genuine defects: unresolvable `@link` and `@throws`
+  targets, `<p/>` and empty `<p>`, `<` and `>` written literally, and a `<pre>`
+  block whose `ContextMenuTester<ContextMenu>` parsed as an HTML tag. 76 of
+  those.
+- 291 were in the *generated* `*Locator` files, so they were fixed in
+  `locator-processor`: the class Javadoc now carries `@param` for the locator's
+  type parameters, both generated constructors carry Javadoc, and a copied
+  `{@link #member}` is rewritten to point back at the tester it came from.
+- A tester's Javadoc is copied verbatim into a generated locator that has no
+  imports, so a cross-package `{@link Span}` resolves in the tester and fails in
+  the copy. The rule — spell such targets out in full — is now in
+  [`guidelines/documenting.md`](guidelines/documenting.md).
+- The rest was the `missing` group: 316 `@param`, 236 undocumented members, 116
+  `@return`. Almost all of it in the files this port rewrote, because KDoc
+  carried none of those tags.
+- The port had also left 65 Javadoc lines in KDoc markup — `[TreeGrid]`,
+  `[_rowSequence]`, `*skip*` — which render as literal brackets and asterisks.
+  Those are now `{@link}`, `{@code}` and `<em>`.
+
+Still open, and untouched here because the ask was `shared`: `junit6`, `spring`
+and `quarkus` report 36 doclint warnings between them. They never failed a
+build, because doclint warnings do not.
+
 ## Breaking changes
 
 Four genuinely breaking changes, all in `com.vaadin.browserless.internal`,
diff --git a/guidelines/documenting.md b/guidelines/documenting.md
index b2b59a37..87a3ad57 100644
--- a/guidelines/documenting.md
+++ b/guidelines/documenting.md
@@ -41,6 +41,15 @@ order:
 - **Mark internal API as internal.** "For internal use only. May be renamed or
   removed in a future release." on classes like `BaseBrowserlessTest` is what
   keeps them changeable.
+- **Spell cross-package `@link` and `@throws` targets out in full** in a
+  tester. `locator-processor` copies a tester method's Javadoc into the
+  generated `*Locator`, which has no imports, so `{@link Span}` resolves in the
+  tester and fails there. Write `{@link com.vaadin.flow.component.html.Span
+  Span}`. Same-package names and `{@link #member}` are fine — the processor
+  rewrites the latter to point back at the tester.
+- **Every published member needs a comment.** `shared` builds clean under
+  doclint, so a missing `@param`, `@return` or description shows up in the
+  `-Djavadocs` build.
 
 ## Documenting the mocks
 
diff --git a/locator-processor/src/main/java/com/vaadin/browserless/locator/processor/LocatorProcessor.java b/locator-processor/src/main/java/com/vaadin/browserless/locator/processor/LocatorProcessor.java
index f86815b1..53748d40 100644
--- a/locator-processor/src/main/java/com/vaadin/browserless/locator/processor/LocatorProcessor.java
+++ b/locator-processor/src/main/java/com/vaadin/browserless/locator/processor/LocatorProcessor.java
@@ -350,22 +350,42 @@ private Entry generateLocatorForTarget(TypeElement tester,
         String ctorAnno = needsRawCast
                 ? "    @SuppressWarnings({\"unchecked\", \"rawtypes\"})\n"
                 : "";
+        String targetLink = "{@link " + target.getQualifiedName() + "}";
         if (freeExtras.isEmpty()) {
-            ctor = ctorAnno + "    public " + locatorSimple + "() {\n"
+            String doc = "    /**\n     * Creates a locator that searches for a "
+                    + targetLink + ".\n     */\n";
+            ctor = doc + ctorAnno + "    public " + locatorSimple + "() {\n"
                     + "        super(" + superArg + ");\n" + "    }\n";
         } else {
             String params = freeExtras.stream()
                     .map(tp -> "java.lang.Class<" + tp.getSimpleName() + "> "
                             + decap(tp.getSimpleName().toString()) + "Type")
                     .collect(Collectors.joining(", "));
-            ctor = ctorAnno + "    public " + locatorSimple + "(" + params
+            StringBuilder doc = new StringBuilder(
+                    "    /**\n     * Creates a locator that searches for a "
+                            + targetLink + ".\n     *\n");
+            for (TypeParameterElement tp : freeExtras) {
+                doc.append("     * @param ")
+                        .append(decap(tp.getSimpleName().toString()))
+                        .append("Type\n");
+                doc.append("     *            class witness pinning the ")
+                        .append(tp.getSimpleName())
+                        .append(" type parameter; the value is unused\n");
+            }
+            doc.append("     */\n");
+            ctor = doc + ctorAnno + "    public " + locatorSimple + "(" + params
                     + ") {\n" + "        super(" + superArg + ");\n"
                     + "    }\n";
         }
         // Seeded-query constructor: takes a direct component reference.
         // Shares the raw-cast workaround with the no-component constructor
         // because the first super-arg is the same Class<C> expression.
-        String useCtor = ctorAnno + "    public " + locatorSimple + "("
+        String useCtor = "    /**\n"
+                + "     * Creates a locator already bound to the given component, so that the\n"
+                + "     * action methods run against it instead of against a lookup.\n"
+                + "     *\n" + "     * @param component\n"
+                + "     *            the component the locator resolves to\n"
+                + "     */\n" + ctorAnno + "    public " + locatorSimple + "("
                 + componentTypeExpr + " component) {\n        super(" + superArg
                 + ", component);\n    }\n";
 
@@ -379,7 +399,7 @@ private Entry generateLocatorForTarget(TypeElement tester,
                         "/* Generated by LocatorProcessor. Do not edit. */");
                 out.println("package " + testerPkg + ";");
                 out.println();
-                out.print(renderClassJavadoc(target, tester));
+                out.print(renderClassJavadoc(target, tester, freeExtras));
                 out.println("@javax.annotation.processing.Generated(\""
                         + LocatorProcessor.class.getName() + "\")");
                 String filterMixinsImpl = renderFilterMixinImplements(target,
@@ -939,7 +959,8 @@ private String renderDelegate(ExecutableElement m, ExecutableType resolved,
         return sb.toString();
     }
 
-    private String renderClassJavadoc(TypeElement target, TypeElement tester) {
+    private String renderClassJavadoc(TypeElement target, TypeElement tester,
+            List<TypeParameterElement> freeExtras) {
         String targetFqn = target.getQualifiedName().toString();
         String testerFqn = tester.getQualifiedName().toString();
         StringBuilder sb = new StringBuilder();
@@ -953,6 +974,16 @@ private String renderClassJavadoc(TypeElement target, TypeElement tester) {
         sb.append(
                 " * around the resolved component, so behavioral changes belong on the\n");
         sb.append(" * tester, not here.\n");
+        if (!freeExtras.isEmpty()) {
+            sb.append(" *\n");
+            for (TypeParameterElement tp : freeExtras) {
+                sb.append(" * @param <").append(tp.getSimpleName())
+                        .append(">\n");
+                sb.append(" *            the ").append(target.getSimpleName())
+                        .append("'s ").append(tp.getSimpleName())
+                        .append(" type parameter\n");
+            }
+        }
         sb.append(" */\n");
         return sb.toString();
     }
@@ -982,7 +1013,7 @@ private String renderJavadoc(ExecutableElement m) {
                 descEnd--;
             }
             for (int i = 0; i < descEnd; i++) {
-                appendDocLine(sb, lines[i]);
+                appendDocLine(sb, qualifySelfRefs(lines[i], declaring));
             }
             if (descEnd > 0) {
                 sb.append("     *\n");
@@ -992,7 +1023,7 @@ private String renderJavadoc(ExecutableElement m) {
             if (firstTag < raw.length) {
                 sb.append("     *\n");
                 for (int i = firstTag; i < raw.length; i++) {
-                    appendDocLine(sb, lines[i]);
+                    appendDocLine(sb, qualifySelfRefs(lines[i], declaring));
                 }
             }
         } else {
@@ -1003,6 +1034,23 @@ private String renderJavadoc(ExecutableElement m) {
         return sb.toString();
     }
 
+    /**
+     * Rewrites {@code {@link #member}} style references so they still resolve
+     * once the Javadoc has been copied into the generated locator, where
+     * {@code #member} would point at the locator instead of at the tester.
+     * <p>
+     * References to types are left alone, which is why a tester's Javadoc has
+     * to spell cross-package {@code @link} and {@code @throws} targets out in
+     * full: the generated file has no imports, so a simple name that resolves
+     * in the tester does not resolve here.
+     */
+    private String qualifySelfRefs(String line, TypeElement tester) {
+        String testerFqn = tester.getQualifiedName().toString();
+        return line.replace("{@link #", "{@link " + testerFqn + "#")
+                .replace("{@linkplain #", "{@linkplain " + testerFqn + "#")
+                .replace("{@value #", "{@value " + testerFqn + "#");
+    }
+
     private void appendDocLine(StringBuilder sb, String line) {
         if (line.isEmpty()) {
             sb.append("     *\n");
diff --git a/pom.xml b/pom.xml
index 3f8d37f5..244db76c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -150,6 +150,13 @@
                          runs in modules that reference this plugin. -->
                     <configuration>
                         <quiet>true</quiet>
+                        <!-- javadoc stops reporting after 100 errors and 100
+                             warnings by default, which makes a large backlog
+                             look far smaller than it is. Report all of it. -->
+                        <additionalOptions>
+                            <additionalOption>-Xmaxerrs 9999</additionalOption>
+                            <additionalOption>-Xmaxwarns 9999</additionalOption>
+                        </additionalOptions>
                     </configuration>
                     <executions>
                         <execution>
diff --git a/shared/pom.xml b/shared/pom.xml
index 600ae1d7..f77ec17a 100644
--- a/shared/pom.xml
+++ b/shared/pom.xml
@@ -35,18 +35,6 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
-                <configuration>
-                    <!-- Dokka generated this module's Javadocs until the Kotlin
-                         sources were ported away, and it validated nothing, so
-                         doclint is seeing these sources for the first time: it
-                         reports roughly 200 issues across 53 files, nearly all
-                         of them in testers untouched by the port. Disabled here
-                         to keep the port from turning into a module-wide
-                         Javadoc cleanup; that cleanup is worth doing on its
-                         own, tightening this back to the default a step at a
-                         time. The other modules run with doclint on. -->
-                    <doclint>none</doclint>
-                </configuration>
             </plugin>
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
diff --git a/shared/src/main/java/com/vaadin/browserless/BaseBrowserlessTest.java b/shared/src/main/java/com/vaadin/browserless/BaseBrowserlessTest.java
index f936c3fb..73f140b5 100644
--- a/shared/src/main/java/com/vaadin/browserless/BaseBrowserlessTest.java
+++ b/shared/src/main/java/com/vaadin/browserless/BaseBrowserlessTest.java
@@ -53,10 +53,21 @@
  */
 public abstract class BaseBrowserlessTest {
 
+    /**
+     * Creates the test base; subclasses are instantiated by the test engine.
+     */
+    protected BaseBrowserlessTest() {
+    }
+
     private TestSignalEnvironment signalsTestEnvironment;
     private BrowserlessConfiguration resolvedConfiguration;
     private boolean classScopedConfiguration;
 
+    /**
+     * Equivalent to {@code discoverRoutes(scanPackages())}.
+     *
+     * @return the routes found in the scanned packages
+     */
     protected synchronized Routes discoverRoutes() {
         return discoverRoutes(scanPackages());
     }
@@ -64,6 +75,8 @@ protected synchronized Routes discoverRoutes() {
     /**
      * Discover and return Routes for mocked Vaadin core system.
      *
+     * @param packageNames
+     *            the packages to scan for routes
      * @see #initVaadinEnvironment()
      * @return Routes
      */
@@ -127,6 +140,10 @@ protected final Set<Class<?>> allLookupServices(
         return services;
     }
 
+    /**
+     * Registers the signals test environment, so that signal-backed components
+     * work inside the mocked environment.
+     */
     protected void initSignalsSupport() {
         signalsTestEnvironment = TestSignalEnvironment.register();
     }
@@ -144,6 +161,12 @@ protected void scanTesters() {
         }
     }
 
+    /**
+     * Collects the packages to scan for routes, from the {@code @ViewPackages}
+     * annotation on the test class.
+     *
+     * @return the packages to scan, empty to scan the whole classpath
+     */
     protected Set<String> scanPackages() {
         Set<String> packagesToScan = new HashSet<>();
 
@@ -282,10 +305,10 @@ void setResolvedConfiguration(BrowserlessConfiguration configuration,
     /**
      * Navigate to the given view class if it is registered.
      *
-     * @param navigationTarget
-     *            view class to navigate to
      * @param <T>
      *            view type
+     * @param navigationTarget
+     *            view class to navigate to
      * @return instantiated view
      */
     public <T extends Component> T navigate(Class<T> navigationTarget) {
@@ -295,14 +318,14 @@ public <T extends Component> T navigate(Class<T> navigationTarget) {
     /**
      * Navigate to view with url parameter.
      *
+     * @param <C>
+     *            parameter type
+     * @param <T>
+     *            view type
      * @param navigationTarget
      *            view class to navigate to
      * @param parameter
      *            parameter to send to view
-     * @param <T>
-     *            view type
-     * @param <C>
-     *            parameter type
      * @return instantiated view
      */
     public <C, T extends Component & HasUrlParameter<C>> T navigate(
@@ -320,13 +343,13 @@ public <C, T extends Component & HasUrlParameter<C>> T navigate(
      * with a query string, write it into the location given to
      * {@link #navigate(String, Class)}.
      *
+     * @param <T>
+     *            view type
      * @param navigationTarget
      *            view class to navigate to
      * @param parameters
      *            route parameters of the target's route template, keyed by
      *            parameter name
-     * @param <T>
-     *            view type
      * @return instantiated view
      */
     public <T extends Component> T navigate(Class<T> navigationTarget,
@@ -344,13 +367,13 @@ public <T extends Component> T navigate(Class<T> navigationTarget,
      * {@code "order/ORD-1?tab=history"}, whose query parameters the view reads
      * from the navigation event.
      *
+     * @param <T>
+     *            view type
      * @param location
      *            location string for navigating, optionally with a query string
      *            and a fragment
      * @param expectedTarget
      *            class that is expected for navigation
-     * @param <T>
-     *            view type
      * @return instantiated view
      */
     public <T extends Component> T navigate(String location,
@@ -377,10 +400,10 @@ public HasElement reload() {
      * Simulates a page reload (see {@link #reload()}) and verifies the
      * resulting view is of the expected type.
      *
-     * @param expectedTarget
-     *            the expected view class after reload
      * @param <T>
      *            the view type
+     * @param expectedTarget
+     *            the expected view class after reload
      * @return the view shown after the reload
      */
     public <T extends Component> T reload(Class<T> expectedTarget) {
@@ -410,11 +433,36 @@ public HasElement getCurrentView() {
     }
 
     // Protected for access by adapter subclass in legacy module
+    /**
+     * Equivalent to {@code TesterRegistry.wrap(component)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param component
+     *            the component to wrap
+     * @return a tester for the given component
+     * @param <Y>
+     *            the component type
+     */
     protected static <T extends ComponentTester<Y>, Y extends Component> T internalWrap(
             Y component) {
         return TesterRegistry.wrap(component);
     }
 
+    /**
+     * Wraps the component in the given tester type, preferring a more specific
+     * tester registered through {@code @Tests} when one exists.
+     *
+     * @param <T>
+     *            the tester type
+     * @param <Y>
+     *            the component type
+     * @param wrap
+     *            the tester type the caller asked for
+     * @param component
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     @SuppressWarnings({ "unchecked", "rawtypes" })
     protected static <T extends ComponentTester<Y>, Y extends Component> T internalWrap(
             Class<T> wrap, Y component) {
@@ -484,10 +532,10 @@ public <T extends ComponentTester<Y>, Y extends Component> T test(
      * context menu, and {@code GridTester.contextMenu(row).open()} for a grid
      * context menu.
      *
-     * @param componentType
-     *            the type of the component(s) to search for
      * @param <T>
      *            the type of the component(s) to search for
+     * @param componentType
+     *            the type of the component(s) to search for
      * @return a query object for finding components
      * @since 1.1
      */
@@ -504,12 +552,12 @@ public <T extends Component> ComponentQuery<T> find(
      * Searches the same server-side component tree as {@link #find(Class)}, see
      * there for what that tree does not contain.
      *
+     * @param <T>
+     *            the type of the component(s) to search for
      * @param componentType
      *            the type of the component(s) to search for
      * @param fromThis
      *            component used as starting element for search.
-     * @param <T>
-     *            the type of the component(s) to search for
      * @return a query object for finding components
      * @since 1.1
      */
@@ -525,10 +573,10 @@ public <T extends Component> ComponentQuery<T> find(Class<T> componentType,
      * Searches the same server-side component tree as {@link #find(Class)}, see
      * there for what that tree does not contain.
      *
-     * @param componentType
-     *            the type of the component(s) to search for
      * @param <T>
      *            the type of the component(s) to search for
+     * @param componentType
+     *            the type of the component(s) to search for
      * @return a query object for finding components
      * @since 1.1
      */
@@ -540,10 +588,10 @@ public <T extends Component> ComponentQuery<T> findInView(
     /**
      * Gets a query object for finding a component inside the UI.
      *
-     * @param componentType
-     *            the type of the component(s) to search for
      * @param <T>
      *            the type of the component(s) to search for
+     * @param componentType
+     *            the type of the component(s) to search for
      * @return a query object for finding components
      * @deprecated since 1.1, for removal in 26.0; use {@link #find(Class)}
      *             instead.
@@ -557,12 +605,12 @@ public <T extends Component> ComponentQuery<T> findInView(
      * Gets a query object for finding a component nested inside the given
      * component.
      *
+     * @param <T>
+     *            the type of the component(s) to search for
      * @param componentType
      *            the type of the component(s) to search for
      * @param fromThis
      *            component used as starting element for search.
-     * @param <T>
-     *            the type of the component(s) to search for
      * @return a query object for finding components
      * @deprecated since 1.1, for removal in 26.0; use
      *             {@link #find(Class, Component)} instead.
@@ -576,10 +624,10 @@ public <T extends Component> ComponentQuery<T> findInView(
     /**
      * Gets a query object for finding a component inside the current view.
      *
-     * @param componentType
-     *            the type of the component(s) to search for
      * @param <T>
      *            the type of the component(s) to search for
+     * @param componentType
+     *            the type of the component(s) to search for
      * @return a query object for finding components
      * @deprecated since 1.1, for removal in 26.0; use
      *             {@link #findInView(Class)} instead.
diff --git a/shared/src/main/java/com/vaadin/browserless/BrowserlessConfiguration.java b/shared/src/main/java/com/vaadin/browserless/BrowserlessConfiguration.java
index 260bd3db..d8d03023 100644
--- a/shared/src/main/java/com/vaadin/browserless/BrowserlessConfiguration.java
+++ b/shared/src/main/java/com/vaadin/browserless/BrowserlessConfiguration.java
@@ -55,8 +55,17 @@ public final class BrowserlessConfiguration implements Serializable {
     private static final BrowserlessConfiguration EMPTY = new BrowserlessConfiguration(
             Map.of(), Map.of(), Set.of());
 
+    /**
+     * The application properties fed to the deployment configuration.
+     */
     private final Map<String, String> applicationProperties;
+    /**
+     * The feature flags to turn on or off, by feature id.
+     */
     private final Map<String, Boolean> featureFlags;
+    /**
+     * The extra service classes handed to the lookup initializer.
+     */
     private final Set<Class<?>> lookupServices;
 
     private BrowserlessConfiguration(Map<String, String> applicationProperties,
diff --git a/shared/src/main/java/com/vaadin/browserless/BrowserlessTestSetupException.java b/shared/src/main/java/com/vaadin/browserless/BrowserlessTestSetupException.java
index 5ce431ec..0304121b 100644
--- a/shared/src/main/java/com/vaadin/browserless/BrowserlessTestSetupException.java
+++ b/shared/src/main/java/com/vaadin/browserless/BrowserlessTestSetupException.java
@@ -22,10 +22,24 @@
  * @since 1.0
  */
 public class BrowserlessTestSetupException extends RuntimeException {
+    /**
+     * Creates an exception with the given message.
+     *
+     * @param message
+     *            what went wrong while setting the test environment up
+     */
     public BrowserlessTestSetupException(String message) {
         super(message);
     }
 
+    /**
+     * Creates an exception with the given message and cause.
+     *
+     * @param message
+     *            what went wrong while setting the test environment up
+     * @param cause
+     *            the failure this one wraps
+     */
     public BrowserlessTestSetupException(String message, Throwable cause) {
         super(message, cause);
     }
diff --git a/shared/src/main/java/com/vaadin/browserless/CommercialTesterWrappers.java b/shared/src/main/java/com/vaadin/browserless/CommercialTesterWrappers.java
index 00841248..f7b356bc 100644
--- a/shared/src/main/java/com/vaadin/browserless/CommercialTesterWrappers.java
+++ b/shared/src/main/java/com/vaadin/browserless/CommercialTesterWrappers.java
@@ -33,6 +33,8 @@ public interface CommercialTesterWrappers {
     /**
      * Create a tester for the given GridPro instance.
      *
+     * @param <V>
+     *            the value type
      * @param grid
      *            the GridPro instance to be tested
      * @return a GridProTester instance wrapping the given GridPro
@@ -44,6 +46,8 @@ default <V> GridProTester<GridPro<V>, V> test(GridPro<V> grid) {
     /**
      * Create a tester for the given GridPro instance.
      *
+     * @param <V>
+     *            the value type
      * @param grid
      *            the GridPro instance to be tested
      * @param itemType
diff --git a/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java b/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java
index df0cb446..fca68c4f 100644
--- a/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java
+++ b/shared/src/main/java/com/vaadin/browserless/ComponentQuery.java
@@ -75,6 +75,8 @@ public ComponentQuery(Class<T> componentType) {
     /**
      * Requires the given property to have expected value.
      *
+     * @param <V>
+     *            the value type
      * @param getter
      *            the function to get the value of the property of the field,
      *            not null
@@ -99,6 +101,8 @@ public <V> ComponentQuery<T> withPropertyValue(Function<T, V> getter,
      * Providing a {@literal null} value as {@code expectedValue} has no effects
      * since the filter will not be applied.
      *
+     * @param <V>
+     *            the value type
      * @param expectedValue
      *            value to be compared with the one obtained by
      *            {@link com.vaadin.flow.component.HasValue#getValue()}
@@ -740,10 +744,10 @@ private boolean isInSlot(Component component, String slot) {
      * Gets a new {@link ComponentQuery} to search for given component type on
      * the context of first matching component for current query.
      *
-     * @param componentType
-     *            the type of the component(s) to search for
      * @param <E>
      *            the type of the component(s) to search for
+     * @param componentType
+     *            the type of the component(s) to search for
      * @return a new query object, to search for nested components.
      * @throws java.util.NoSuchElementException
      *             if first component is found
@@ -761,10 +765,12 @@ public <E extends Component> ComponentQuery<E> thenOnFirst(
      * the actual number of components found results in an
      * {@link IndexOutOfBoundsException}.
      *
-     * @param componentType
-     *            the type of the component(s) to search for
      * @param <E>
      *            the type of the component(s) to search for
+     * @param index
+     *            the 1-based index of the match to pick
+     * @param componentType
+     *            the type of the component(s) to search for
      * @return a new query object, to search for nested components.
      * @see #atIndex(int)
      * @throws IllegalArgumentException
@@ -841,6 +847,8 @@ public T last() {
      * the actual number of components found results in an
      * {@link IndexOutOfBoundsException}.
      *
+     * @param index
+     *            the 1-based index of the match to pick
      * @return the component of the type specified in the constructor.
      * @throws IllegalArgumentException
      *             if index is zero or negative
@@ -942,6 +950,11 @@ public ComponentQuery<T> from(Component context) {
         return this;
     }
 
+    /**
+     * Runs the query and returns the single match.
+     *
+     * @return the only component the query matches
+     */
     protected T find() {
         // Snapshot and restore so resolution's "expect exactly one"
         // constraint doesn't leak into the persistent spec and
diff --git a/shared/src/main/java/com/vaadin/browserless/ComponentTester.java b/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
index 4b451306..ac0d0ebb 100644
--- a/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
+++ b/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
@@ -119,6 +119,8 @@ protected boolean isComponentReadOnly() {
      * {@link #notUsableReasons(Consumer)} to provide additional details to the
      * potential exception thrown by {@link #ensureComponentIsUsable()}.
      *
+     * @param component
+     *            the component to inspect
      * @return {@code true} if component can be interacted with by the user
      * @see #notUsableReasons(Consumer)
      * @see #ensureComponentIsUsable()
@@ -164,10 +166,10 @@ public void setModal(boolean modal) {
      * context menu, and {@code GridTester.contextMenu(row).open()} for a grid
      * context menu.
      *
-     * @param componentType
-     *            type of the component to search.
      * @param <R>
      *            type of the component to search.
+     * @param componentType
+     *            type of the component to search.
      * @return a {@link ComponentQuery} instance, searching for wrapped
      *         component children.
      */
@@ -246,6 +248,8 @@ private static void throwIfNotUsable(Component component,
      * method to provide additional details to the potential exception throw by
      * {@link #ensureComponentIsUsable()}.
      *
+     * @param collector
+     *            receives the components the tester walks over
      * @see #isUsable()
      * @see #ensureComponentIsUsable()
      */
@@ -264,6 +268,10 @@ protected void notUsableReasons(Consumer<String> collector) {
      * method to provide additional details to the potential exception throw by
      * {@link #ensureComponentIsUsable()}.
      *
+     * @param component
+     *            the component to check
+     * @param collector
+     *            receives the components the tester walks over
      * @see #isUsable()
      * @see #ensureComponentIsUsable()
      */
@@ -296,6 +304,9 @@ protected void ensureVisible() {
     /**
      * Check that the given component is visible for the user. Else throw an
      * {@link IllegalStateException}
+     *
+     * @param component
+     *            the component to check
      */
     protected static void ensureVisible(Component component) {
         if (!component.isVisible() || !component.isAttached()) {
@@ -452,12 +463,12 @@ protected void fireDomEvent(DomEvent event) {
      * Usually the {@link ComponentQuery} consumer should only define
      * conditions, not invoke any terminal operator.
      *
+     * @param <R>
+     *            the type of the component to search for
      * @param componentType
      *            the type of the component to search for
      * @param queryBuilder
      *            the function that sets query condition
-     * @param <R>
-     *            the type of the component to search for
      * @return the component found by query execution, wrapped into an
      *         {@link Optional}, or empty if the query does not produce results.
      */
@@ -485,12 +496,12 @@ protected <R extends Component> Optional<R> findByQuery(
      * Usually the {@link ComponentQuery} consumer should only define
      * conditions, not invoke any terminal operator.
      *
+     * @param <R>
+     *            the type of the component to search for
      * @param componentType
      *            the type of the component to search for
      * @param queryBuilder
      *            the function that sets query condition
-     * @param <R>
-     *            the type of the component to search for
      * @return the components found by query execution, or an empty list.
      */
     protected <R extends Component> List<R> findAllByQuery(
@@ -590,6 +601,8 @@ private void setEmptyValueAsUser() {
      * instance of AbstractField. This method is purposed for internal use and
      * when creating custom testers extending ComponentTesters.
      *
+     * @param <V>
+     *            the value type
      * @param value
      *            the new value, may be null.
      */
@@ -609,6 +622,8 @@ protected <V> void setValueAsUser(V value) {
      * extending ComponentTesters, for fields other than the wrapped component,
      * such as an editor field owned by the wrapped component.
      *
+     * @param <V>
+     *            the value type
      * @param field
      *            the field to set the value to, not {@literal null}.
      * @param value
diff --git a/shared/src/main/java/com/vaadin/browserless/ComponentTesterPackages.java b/shared/src/main/java/com/vaadin/browserless/ComponentTesterPackages.java
index bd5599ec..d85dbb50 100644
--- a/shared/src/main/java/com/vaadin/browserless/ComponentTesterPackages.java
+++ b/shared/src/main/java/com/vaadin/browserless/ComponentTesterPackages.java
@@ -24,7 +24,7 @@
 /**
  * Annotation to use to scan given packages for component wrappers outside the
  * default {@code com.vaadin.flow.component}.
- * <p/>
+ * <p>
  * This makes adding custom component wrappers simpler as they can then use
  * package protected fields and methods.
  *
@@ -37,7 +37,7 @@
 
     /**
      * Array of packages to scan for {@link ComponentTester} implementations.
-     * <p/>
+     * <p>
      * Implementation should use the {@link Tests} annotation to be used
      * automatically in the {@code wraps(Component)} method.
      *
diff --git a/shared/src/main/java/com/vaadin/browserless/ElementConditions.java b/shared/src/main/java/com/vaadin/browserless/ElementConditions.java
index f6ad5683..7437f65c 100644
--- a/shared/src/main/java/com/vaadin/browserless/ElementConditions.java
+++ b/shared/src/main/java/com/vaadin/browserless/ElementConditions.java
@@ -58,14 +58,16 @@ private ElementConditions() {
      *
      * For example, given HTML
      *
-     * <pre>
+     * <pre>{@code
      * <p>
      * Hello  <b>there</b> now!
      * </p>
-     * </pre>
+     * }</pre>
      *
      * the text that will be checked will be {@literal  Hello there now!}.
      *
+     * @param <T>
+     *            the item type
      * @param text
      *            the text the component is expected to have as its content. Not
      *            {@literal null}.
@@ -94,14 +96,16 @@ public static <T extends Component> Predicate<T> containsText(String text) {
      *
      * For example, given HTML
      *
-     * <pre>
+     * <pre>{@code
      * <p>
      * Hello  <b>there</b> now!
      * </p>
-     * </pre>
+     * }</pre>
      *
      * the text that will be checked will be {@literal  Hello there now!}.
      *
+     * @param <T>
+     *            the item type
      * @param text
      *            the text the component is expected to have as its content. Not
      *            {@literal null}.
@@ -128,6 +132,8 @@ public static <T extends Component> Predicate<T> containsText(String text,
      * Attribute names are considered case-insensitive and all names will be
      * converted to lower case automatically.
      *
+     * @param <T>
+     *            the item type
      * @param attribute
      *            the name of the attribute, not {@literal null}
      * @return {@literal true} if the attribute has been set, {@literal false}
@@ -145,6 +151,8 @@ public static <T extends Component> Predicate<T> hasAttribute(
      * Attribute names are considered case-insensitive and all names will be
      * converted to lower case automatically.
      *
+     * @param <T>
+     *            the item type
      * @param attribute
      *            the name of the attribute, not {@literal null}
      * @param value
@@ -167,6 +175,8 @@ public static <T extends Component> Predicate<T> hasAttribute(
      * Attribute names are considered case-insensitive and all names will be
      * converted to lower case automatically.
      *
+     * @param <T>
+     *            the item type
      * @param attribute
      *            the name of the attribute, not {@literal null}
      * @return {@literal true} if the attribute has not been set,
@@ -184,6 +194,8 @@ public static <T extends Component> Predicate<T> hasNotAttribute(
      * Attribute names are considered case-insensitive and all names will be
      * converted to lower case automatically.
      *
+     * @param <T>
+     *            the item type
      * @param attribute
      *            the name of the attribute, not {@literal null}
      * @param value
@@ -216,9 +228,13 @@ public static <T extends Component> Predicate<T> hasNotAttribute(
      * {@link com.vaadin.flow.component.html.NativeLabel} (or any
      * {@code <label>} element) targets an input via the {@code for} attribute.
      *
+     * @param <T>
+     *            the item type
      * @param label
      *            the expected label, not {@literal null}
      *
+     * @return {@code true} if the component is labelled by exactly the given
+     *         text
      * @since 1.1
      */
     public static <T extends Component> Predicate<T> hasLabel(String label) {
@@ -234,9 +250,12 @@ public static <T extends Component> Predicate<T> hasLabel(String label) {
      * {@code label} property or a referring {@code <label for="...">} element).
      * Comparison is case-sensitive.
      *
+     * @param <T>
+     *            the item type
      * @param text
      *            substring to find in the label, not {@literal null}
      *
+     * @return {@code true} if the component's label contains the given text
      * @since 1.1
      */
     public static <T extends Component> Predicate<T> labelContains(
@@ -272,8 +291,12 @@ private static boolean matches(String actual, String expected,
      * that don't implement {@code HasPlaceholder} are never matched (they have
      * no placeholder to test against). Comparison is case-sensitive.
      *
+     * @param <T>
+     *            the item type
      * @param text
      *            substring to find in the placeholder, not {@literal null}
+     * @return {@code true} if the component's {@code placeholder} contains the
+     *         given text
      * @since 1.1
      */
     public static <T extends Component> Predicate<T> placeholderContains(
@@ -312,9 +335,13 @@ private static String referringLabelText(Component root, String id) {
      * {@code aria-label} on the client). Otherwise falls back to reading the
      * server-side element's {@code aria-label} attribute.
      *
+     * @param <T>
+     *            the item type
      * @param ariaLabel
      *            the expected aria-label, not {@literal null}
      *
+     * @return {@code true} if the component identifies itself to assistive
+     *         technology via the given {@code aria-label}
      * @since 1.1
      */
     public static <T extends Component> Predicate<T> hasAriaLabel(
@@ -332,9 +359,13 @@ public static <T extends Component> Predicate<T> hasAriaLabel(
      * {@link HasAriaLabel#getAriaLabel()} over the raw element attribute so
      * that field components are matched.
      *
+     * @param <T>
+     *            the item type
      * @param text
      *            substring to find in the aria-label, not {@literal null}
      *
+     * @return {@code true} if the component's aria-label contains the given
+     *         text
      * @since 1.1
      */
     public static <T extends Component> Predicate<T> ariaLabelContains(
diff --git a/shared/src/main/java/com/vaadin/browserless/MouseButton.java b/shared/src/main/java/com/vaadin/browserless/MouseButton.java
index dcd51e45..7eaabe9c 100644
--- a/shared/src/main/java/com/vaadin/browserless/MouseButton.java
+++ b/shared/src/main/java/com/vaadin/browserless/MouseButton.java
@@ -17,7 +17,7 @@
 
 /**
  * Enums for mouse button values in click events.
- * <p/>
+ * <p>
  * Default button values are as follows:
  * <dl>
  * <dt>-1: No button</dt>
@@ -33,7 +33,18 @@
  */
 public enum MouseButton {
 
-    NO_BUTTON(-1), LEFT(0), MIDDLE(1), RIGHT(2), BACK(3), FORWARD(4);
+    /** No button, or a button the browser does not name. */
+    NO_BUTTON(-1),
+    /** The primary button, usually the left one. */
+    LEFT(0),
+    /** The auxiliary button, usually the wheel. */
+    MIDDLE(1),
+    /** The secondary button, usually the right one. */
+    RIGHT(2),
+    /** The first additional button, typically the back button. */
+    BACK(3),
+    /** The second additional button, typically the forward button. */
+    FORWARD(4);
 
     private int button;
 
diff --git a/shared/src/main/java/com/vaadin/browserless/SecuredBrowserlessApplicationContext.java b/shared/src/main/java/com/vaadin/browserless/SecuredBrowserlessApplicationContext.java
index f5e867e6..b9170608 100644
--- a/shared/src/main/java/com/vaadin/browserless/SecuredBrowserlessApplicationContext.java
+++ b/shared/src/main/java/com/vaadin/browserless/SecuredBrowserlessApplicationContext.java
@@ -151,6 +151,12 @@ public <D> Builder<D> withSecurityContextHandler(
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @return this builder, for chaining
+         * @param factory
+         *            creates the servlet the context runs on
          * @see BrowserlessApplicationContext.Builder#withServletFactory
          */
         public Builder<C> withServletFactory(
@@ -160,6 +166,12 @@ public Builder<C> withServletFactory(
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param uiFactory
+         *            creates the UI instance
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withUIFactory
          */
         public Builder<C> withUIFactory(UIFactory uiFactory) {
@@ -168,6 +180,12 @@ public Builder<C> withUIFactory(UIFactory uiFactory) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param services
+         *            the lookup services to register
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withLookupServices
          */
         public Builder<C> withLookupServices(Class<?>... services) {
@@ -176,6 +194,12 @@ public Builder<C> withLookupServices(Class<?>... services) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param packages
+         *            the packages to scan
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withViewPackages(String...)
          */
         public Builder<C> withViewPackages(String... packages) {
@@ -184,6 +208,12 @@ public Builder<C> withViewPackages(String... packages) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param classes
+         *            the classes to register
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withViewPackages(Class[])
          */
         public Builder<C> withViewPackages(Class<?>... classes) {
@@ -192,6 +222,12 @@ public Builder<C> withViewPackages(Class<?>... classes) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param packages
+         *            the packages to scan
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withComponentTesterPackages(String...)
          */
         public Builder<C> withComponentTesterPackages(String... packages) {
@@ -200,6 +236,12 @@ public Builder<C> withComponentTesterPackages(String... packages) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param classes
+         *            the classes to register
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withComponentTesterPackages(Class[])
          */
         public Builder<C> withComponentTesterPackages(Class<?>... classes) {
@@ -208,6 +250,12 @@ public Builder<C> withComponentTesterPackages(Class<?>... classes) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param hook
+         *            the lifecycle hook to install
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withCloseHook
          */
         public Builder<C> withCloseHook(Runnable hook) {
@@ -216,6 +264,14 @@ public Builder<C> withCloseHook(Runnable hook) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param name
+         *            the attribute name
+         * @param value
+         *            the value to set
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withApplicationProperty
          */
         public Builder<C> withApplicationProperty(String name, String value) {
@@ -224,6 +280,12 @@ public Builder<C> withApplicationProperty(String name, String value) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param properties
+         *            the initialization properties
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withApplicationProperties
          */
         public Builder<C> withApplicationProperties(
@@ -233,6 +295,12 @@ public Builder<C> withApplicationProperties(
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param featureIds
+         *            the features to enable
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withFeatureFlags(String...)
          */
         public Builder<C> withFeatureFlags(String... featureIds) {
@@ -241,6 +309,12 @@ public Builder<C> withFeatureFlags(String... featureIds) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param features
+         *            the features to enable
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withFeatureFlags(Feature...)
          */
         public Builder<C> withFeatureFlags(Feature... features) {
@@ -249,6 +323,14 @@ public Builder<C> withFeatureFlags(Feature... features) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param featureId
+         *            the feature to enable
+         * @param enabled
+         *            whether the feature is on
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withFeatureFlag(String,
          *      boolean)
          */
@@ -258,6 +340,14 @@ public Builder<C> withFeatureFlag(String featureId, boolean enabled) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param feature
+         *            the feature to enable
+         * @param enabled
+         *            whether the feature is on
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withFeatureFlag(Feature,
          *      boolean)
          */
@@ -267,6 +357,12 @@ public Builder<C> withFeatureFlag(Feature feature, boolean enabled) {
         }
 
         /**
+         * Forwards to the matching method on the underlying
+         * {@link BrowserlessApplicationContext.Builder}.
+         *
+         * @param configuration
+         *            the deployment configuration to use
+         * @return this builder, for chaining
          * @see BrowserlessApplicationContext.Builder#withConfiguration
          */
         public Builder<C> withConfiguration(
diff --git a/shared/src/main/java/com/vaadin/browserless/SecurityContextHandler.java b/shared/src/main/java/com/vaadin/browserless/SecurityContextHandler.java
index c1cc0835..5b0f6960 100644
--- a/shared/src/main/java/com/vaadin/browserless/SecurityContextHandler.java
+++ b/shared/src/main/java/com/vaadin/browserless/SecurityContextHandler.java
@@ -26,6 +26,8 @@
  * Implementations must be thread-safe with respect to the thread-local security
  * state they manage.
  *
+ * @param <C>
+ *            the credentials type
  * @see BrowserlessApplicationContext.Builder#withSecurityContextHandler(SecurityContextHandler)
  * @since 1.1
  */
diff --git a/shared/src/main/java/com/vaadin/browserless/SerializationDebugUtil.java b/shared/src/main/java/com/vaadin/browserless/SerializationDebugUtil.java
index d4d3cf1d..96594449 100644
--- a/shared/src/main/java/com/vaadin/browserless/SerializationDebugUtil.java
+++ b/shared/src/main/java/com/vaadin/browserless/SerializationDebugUtil.java
@@ -30,6 +30,9 @@
 import java.util.Set;
 
 /**
+ * Dumps the object graph behind a serialization failure, so a test can see
+ * which field made a session unserializable.
+ *
  * @since 1.0
  */
 public final class SerializationDebugUtil {
diff --git a/shared/src/main/java/com/vaadin/browserless/TestSignalEnvironment.java b/shared/src/main/java/com/vaadin/browserless/TestSignalEnvironment.java
index efc411b4..66e5f319 100644
--- a/shared/src/main/java/com/vaadin/browserless/TestSignalEnvironment.java
+++ b/shared/src/main/java/com/vaadin/browserless/TestSignalEnvironment.java
@@ -77,6 +77,9 @@ public class TestSignalEnvironment extends SignalEnvironment {
     private final LinkedBlockingQueue<Runnable> tasks = new LinkedBlockingQueue<>();
     private Runnable cleanup;
 
+    /**
+     * Creates the environment; use {@link #register()} instead.
+     */
     protected TestSignalEnvironment() {
     }
 
diff --git a/shared/src/main/java/com/vaadin/browserless/TesterWrappers.java b/shared/src/main/java/com/vaadin/browserless/TesterWrappers.java
index c3c9cd4d..82ddbbea 100644
--- a/shared/src/main/java/com/vaadin/browserless/TesterWrappers.java
+++ b/shared/src/main/java/com/vaadin/browserless/TesterWrappers.java
@@ -164,11 +164,21 @@
 import com.vaadin.flow.router.RouterLink;
 
 /**
+ * Wrapper methods that hand out a tester for a component instance, mixed into
+ * the test base classes so a test can write {@code test(component)}.
+ *
  * @since 1.0
  */
 @SuppressWarnings("unchecked")
 public interface TesterWrappers {
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param accordion
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default AccordionTester<Accordion> test(Accordion accordion) {
         return BaseBrowserlessTest.internalWrap(AccordionTester.class,
                 accordion);
@@ -186,11 +196,25 @@ default AvatarGroupTester<AvatarGroup> test(AvatarGroup avatarGroup) {
                 avatarGroup);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param breadcrumbs
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default BreadcrumbsTester<Breadcrumbs> test(Breadcrumbs breadcrumbs) {
         return BaseBrowserlessTest.internalWrap(BreadcrumbsTester.class,
                 breadcrumbs);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param button
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default ButtonTester<Button> test(Button button) {
         return BaseBrowserlessTest.internalWrap(ButtonTester.class, button);
     }
@@ -206,80 +230,216 @@ default CardTester<Card> test(Card card) {
         return BaseBrowserlessTest.internalWrap(CardTester.class, card);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param checkbox
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default CheckboxTester<Checkbox> test(Checkbox checkbox) {
         return BaseBrowserlessTest.internalWrap(CheckboxTester.class, checkbox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param checkboxGroup
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> CheckboxGroupTester<CheckboxGroup<V>, V> test(
             CheckboxGroup<V> checkboxGroup) {
         return BaseBrowserlessTest.internalWrap(CheckboxGroupTester.class,
                 checkboxGroup);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param checkboxGroup
+     *            the component to wrap
+     * @param valueType
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> CheckboxGroupTester<CheckboxGroup<V>, V> test(
             CheckboxGroup checkboxGroup, Class<V> valueType) {
         return BaseBrowserlessTest.internalWrap(CheckboxGroupTester.class,
                 checkboxGroup);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param field
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default SwitchTester<Switch> test(Switch field) {
         return BaseBrowserlessTest.internalWrap(SwitchTester.class, field);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param comboBox
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> ComboBoxTester<ComboBox<V>, V> test(ComboBox<V> comboBox) {
         return BaseBrowserlessTest.internalWrap(ComboBoxTester.class, comboBox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param comboBox
+     *            the component to wrap
+     * @param valueType
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> ComboBoxTester<ComboBox<V>, V> test(ComboBox comboBox,
             Class<V> valueType) {
         return BaseBrowserlessTest.internalWrap(ComboBoxTester.class, comboBox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param comboBox
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> MultiSelectComboBoxTester<MultiSelectComboBox<V>, V> test(
             MultiSelectComboBox<V> comboBox) {
         return BaseBrowserlessTest.internalWrap(MultiSelectComboBoxTester.class,
                 comboBox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param comboBox
+     *            the component to wrap
+     * @param valueType
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> MultiSelectComboBoxTester<MultiSelectComboBox<V>, V> test(
             MultiSelectComboBox comboBox, Class<V> valueType) {
         return BaseBrowserlessTest.internalWrap(MultiSelectComboBoxTester.class,
                 comboBox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param confirmDialog
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default ConfirmDialogTester test(ConfirmDialog confirmDialog) {
         return BaseBrowserlessTest.internalWrap(ConfirmDialogTester.class,
                 confirmDialog);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param contextMenu
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default ContextMenuTester<ContextMenu> test(ContextMenu contextMenu) {
         return BaseBrowserlessTest.internalWrap(ContextMenuTester.class,
                 contextMenu);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param datePicker
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default DatePickerTester<DatePicker> test(DatePicker datePicker) {
         return BaseBrowserlessTest.internalWrap(DatePickerTester.class,
                 datePicker);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param dateTimePicker
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default DateTimePickerTester<DateTimePicker> test(
             DateTimePicker dateTimePicker) {
         return BaseBrowserlessTest.internalWrap(DateTimePickerTester.class,
                 dateTimePicker);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param details
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default DetailsTester<Details> test(Details details) {
         return BaseBrowserlessTest.internalWrap(DetailsTester.class, details);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param dialog
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default DialogTester test(Dialog dialog) {
         return BaseBrowserlessTest.internalWrap(DialogTester.class, dialog);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param grid
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> GridTester<Grid<V>, V> test(Grid<V> grid) {
         return BaseBrowserlessTest.internalWrap(GridTester.class, grid);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param grid
+     *            the component to wrap
+     * @param itemType
+     *            the type of the items in the component
+     * @return a tester for the given component
+     */
     default <V> GridTester<Grid<V>, V> test(Grid grid, Class<V> itemType) {
         return BaseBrowserlessTest.internalWrap(GridTester.class, grid);
     }
@@ -300,76 +460,195 @@ default <V> GridContextMenuTester<GridContextMenu<V>, V> test(
                 gridContextMenu);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param listBox
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> ListBoxTester<ListBox<V>, V> test(ListBox<V> listBox) {
         return BaseBrowserlessTest.internalWrap(ListBoxTester.class, listBox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param multiSelectListBox
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> MultiSelectListBoxTester<MultiSelectListBox<V>, V> test(
             MultiSelectListBox<V> multiSelectListBox) {
         return BaseBrowserlessTest.internalWrap(MultiSelectListBoxTester.class,
                 multiSelectListBox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param multiSelectListBox
+     *            the component to wrap
+     * @param valueType
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> MultiSelectListBoxTester<MultiSelectListBox<V>, V> test(
             MultiSelectListBox multiSelectListBox, Class<V> valueType) {
         return BaseBrowserlessTest.internalWrap(MultiSelectListBoxTester.class,
                 multiSelectListBox);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param loginForm
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default LoginFormTester<LoginForm> test(LoginForm loginForm) {
         return BaseBrowserlessTest.internalWrap(LoginFormTester.class,
                 loginForm);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param loginOverlay
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default LoginOverlayTester<LoginOverlay> test(LoginOverlay loginOverlay) {
         return BaseBrowserlessTest.internalWrap(LoginOverlayTester.class,
                 loginOverlay);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param markdown
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default MarkdownTester<Markdown> test(Markdown markdown) {
         return BaseBrowserlessTest.internalWrap(MarkdownTester.class, markdown);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param masterDetailLayout
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default MasterDetailLayoutTester<MasterDetailLayout> test(
             MasterDetailLayout masterDetailLayout) {
         return BaseBrowserlessTest.internalWrap(MasterDetailLayoutTester.class,
                 masterDetailLayout);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param messageInput
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default MessageInputTester<MessageInput> test(MessageInput messageInput) {
         return BaseBrowserlessTest.internalWrap(MessageInputTester.class,
                 messageInput);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param messageList
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default MessageListTester<MessageList> test(MessageList messageList) {
         return BaseBrowserlessTest.internalWrap(MessageListTester.class,
                 messageList);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param popover
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default PopoverTester test(Popover popover) {
         return BaseBrowserlessTest.internalWrap(PopoverTester.class, popover);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param target
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default PopoverTester popoverFor(Component target) {
         return PopoverTester.forTarget(target);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param query
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default PopoverTester popoverFor(
             ComponentQuery<? extends Component> query) {
         return PopoverTester.forTarget(query);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param notification
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default NotificationTester<Notification> test(Notification notification) {
         return BaseBrowserlessTest.internalWrap(NotificationTester.class,
                 notification);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param radioButtonGroup
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> RadioButtonGroupTester<RadioButtonGroup<V>, V> test(
             RadioButtonGroup<V> radioButtonGroup) {
         return BaseBrowserlessTest.internalWrap(RadioButtonGroupTester.class,
                 radioButtonGroup);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param radioButtonGroup
+     *            the component to wrap
+     * @param valueType
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> RadioButtonGroupTester<RadioButtonGroup<V>, V> test(
             RadioButtonGroup radioButtonGroup, Class<V> valueType) {
         return BaseBrowserlessTest.internalWrap(RadioButtonGroupTester.class,
@@ -378,20 +657,54 @@ default <V> RadioButtonGroupTester<RadioButtonGroup<V>, V> test(
 
     // RadioButton is package protected so no autowrap.
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param routerLink
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default RouterLinkTester<RouterLink> test(RouterLink routerLink) {
         return BaseBrowserlessTest.internalWrap(RouterLinkTester.class,
                 routerLink);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param select
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> SelectTester<Select<V>, V> test(Select<V> select) {
         return BaseBrowserlessTest.internalWrap(SelectTester.class, select);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param select
+     *            the component to wrap
+     * @param valueType
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> SelectTester<Select<V>, V> test(Select select,
             Class<V> valueType) {
         return BaseBrowserlessTest.internalWrap(SelectTester.class, select);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param sideNav
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default SideNavTester<SideNav> test(SideNav sideNav) {
         return BaseBrowserlessTest.internalWrap(SideNavTester.class, sideNav);
     }
@@ -463,56 +776,133 @@ default SplitLayoutTester<SplitLayout> test(SplitLayout splitLayout) {
                 splitLayout);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param tabs
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TabsTester<Tabs> test(Tabs tabs) {
         return BaseBrowserlessTest.internalWrap(TabsTester.class, tabs);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param tabSheet
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TabSheetTester<TabSheet> test(TabSheet tabSheet) {
         return BaseBrowserlessTest.internalWrap(TabSheetTester.class, tabSheet);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param text
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TextTester<Text> test(Text text) {
         return BaseBrowserlessTest.internalWrap(TextTester.class, text);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param integerField
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default NumberFieldTester<IntegerField, Integer> test(
             IntegerField integerField) {
         return BaseBrowserlessTest.internalWrap(NumberFieldTester.class,
                 integerField);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param numberField
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default NumberFieldTester<NumberField, Double> test(
             NumberField numberField) {
         return BaseBrowserlessTest.internalWrap(NumberFieldTester.class,
                 numberField);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param textArea
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TextAreaTester<TextArea> test(TextArea textArea) {
         return BaseBrowserlessTest.internalWrap(TextAreaTester.class, textArea);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param textField
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TextFieldTester<TextField, String> test(TextField textField) {
         return BaseBrowserlessTest.internalWrap(TextFieldTester.class,
                 textField);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param passwordField
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TextFieldTester<PasswordField, String> test(
             PasswordField passwordField) {
         return BaseBrowserlessTest.internalWrap(TextFieldTester.class,
                 passwordField);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param emailField
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TextFieldTester<EmailField, String> test(EmailField emailField) {
         return BaseBrowserlessTest.internalWrap(TextFieldTester.class,
                 emailField);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param bigDecimalField
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TextFieldTester<BigDecimalField, BigDecimal> test(
             BigDecimalField bigDecimalField) {
         return BaseBrowserlessTest.internalWrap(TextFieldTester.class,
                 bigDecimalField);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param timePicker
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default TimePickerTester<TimePicker> test(TimePicker timePicker) {
         return BaseBrowserlessTest.internalWrap(TimePickerTester.class,
                 timePicker);
@@ -520,17 +910,17 @@ default TimePickerTester<TimePicker> test(TimePicker timePicker) {
 
     /**
      * Create a tester for the given TreeGrid instance.
-     * <p/>
+     * <p>
      * This overload is more specific than {@link #test(Grid)}, so a
      * {@code TreeGrid} argument now yields a {@link TreeGridTester} rather than
      * a {@link GridTester}. Code that assigned the result to an explicitly
      * typed {@code GridTester<Grid<V>, V>} no longer compiles and has to widen
      * the declaration, use {@code var}, or chain the call directly.
      *
-     * @param treeGrid
-     *            the TreeGrid instance to be tested
      * @param <V>
      *            the type of the items in the TreeGrid
+     * @param treeGrid
+     *            the TreeGrid instance to be tested
      * @return a TreeGridTester instance wrapping the given TreeGrid
      */
     default <V> TreeGridTester<TreeGrid<V>, V> test(TreeGrid<V> treeGrid) {
@@ -539,19 +929,19 @@ default <V> TreeGridTester<TreeGrid<V>, V> test(TreeGrid<V> treeGrid) {
 
     /**
      * Create a tester for the given TreeGrid instance.
-     * <p/>
+     * <p>
      * This overload is more specific than {@link #test(Grid, Class)}, so a
      * {@code TreeGrid} argument now yields a {@link TreeGridTester} rather than
      * a {@link GridTester}. Code that assigned the result to an explicitly
      * typed {@code GridTester<Grid<V>, V>} no longer compiles and has to widen
      * the declaration, use {@code var}, or chain the call directly.
      *
+     * @param <V>
+     *            the type of the items in the TreeGrid
      * @param treeGrid
      *            the TreeGrid instance to be tested
      * @param itemType
      *            the type of the items in the TreeGrid
-     * @param <V>
-     *            the type of the items in the TreeGrid
      * @return a TreeGridTester instance wrapping the given TreeGrid
      */
     default <V> TreeGridTester<TreeGrid<V>, V> test(TreeGrid treeGrid,
@@ -559,16 +949,43 @@ default <V> TreeGridTester<TreeGrid<V>, V> test(TreeGrid treeGrid,
         return BaseBrowserlessTest.internalWrap(TreeGridTester.class, treeGrid);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param upload
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default UploadTester<Upload> test(Upload upload) {
         return BaseBrowserlessTest.internalWrap(UploadTester.class, upload);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param virtualList
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default <V> VirtualListTester<VirtualList<V>, V> test(
             VirtualList<V> virtualList) {
         return BaseBrowserlessTest.internalWrap(VirtualListTester.class,
                 virtualList);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param <V>
+     *            the type of the items in the component
+     * @param virtualList
+     *            the component to wrap
+     * @param itemType
+     *            the type of the items in the component
+     * @return a tester for the given component
+     */
     default <V> VirtualListTester<VirtualList<V>, V> test(
             VirtualList virtualList, Class<V> itemType) {
         return BaseBrowserlessTest.internalWrap(VirtualListTester.class,
@@ -577,99 +994,260 @@ default <V> VirtualListTester<VirtualList<V>, V> test(
 
     /* HTML components */
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param anchor
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default AnchorTester test(Anchor anchor) {
         return BaseBrowserlessTest.internalWrap(AnchorTester.class, anchor);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param descriptionList
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default DescriptionListTester test(DescriptionList descriptionList) {
         return BaseBrowserlessTest.internalWrap(DescriptionListTester.class,
                 descriptionList);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param div
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default DivTester test(Div div) {
         return BaseBrowserlessTest.internalWrap(DivTester.class, div);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param emphasis
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default EmphasisTester test(Emphasis emphasis) {
         return BaseBrowserlessTest.internalWrap(EmphasisTester.class, emphasis);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param h1
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default H1Tester test(H1 h1) {
         return BaseBrowserlessTest.internalWrap(H1Tester.class, h1);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param h2
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default H2Tester test(H2 h2) {
         return BaseBrowserlessTest.internalWrap(H2Tester.class, h2);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param h3
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default H3Tester test(H3 h3) {
         return BaseBrowserlessTest.internalWrap(H3Tester.class, h3);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param h4
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default H4Tester test(H4 h4) {
         return BaseBrowserlessTest.internalWrap(H4Tester.class, h4);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param h5
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default H5Tester test(H5 h5) {
         return BaseBrowserlessTest.internalWrap(H5Tester.class, h5);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param h6
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default H6Tester test(H6 h6) {
         return BaseBrowserlessTest.internalWrap(H6Tester.class, h6);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param hr
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default HrTester test(Hr hr) {
         return BaseBrowserlessTest.internalWrap(HrTester.class, hr);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param image
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default ImageTester test(Image image) {
         return BaseBrowserlessTest.internalWrap(ImageTester.class, image);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param input
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default InputTester test(Input input) {
         return BaseBrowserlessTest.internalWrap(InputTester.class, input);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param input
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default RangeInputTester test(RangeInput input) {
         return BaseBrowserlessTest.internalWrap(RangeInputTester.class, input);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param label
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default NativeLabelTester test(NativeLabel label) {
         return BaseBrowserlessTest.internalWrap(NativeLabelTester.class, label);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param listItem
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default ListItemTester test(ListItem listItem) {
         return BaseBrowserlessTest.internalWrap(ListItemTester.class, listItem);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param nativeButton
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default NativeButtonTester test(NativeButton nativeButton) {
         return BaseBrowserlessTest.internalWrap(NativeButtonTester.class,
                 nativeButton);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param nativeDetails
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default NativeDetailsTester test(NativeDetails nativeDetails) {
         return BaseBrowserlessTest.internalWrap(NativeDetailsTester.class,
                 nativeDetails);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param orderedList
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default OrderedListTester test(OrderedList orderedList) {
         return BaseBrowserlessTest.internalWrap(OrderedListTester.class,
                 orderedList);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param paragraph
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default ParagraphTester test(Paragraph paragraph) {
         return BaseBrowserlessTest.internalWrap(ParagraphTester.class,
                 paragraph);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param pre
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default PreTester test(Pre pre) {
         return BaseBrowserlessTest.internalWrap(PreTester.class, pre);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param span
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default SpanTester test(Span span) {
         return BaseBrowserlessTest.internalWrap(SpanTester.class, span);
     }
 
+    /**
+     * Wraps the given component in a tester.
+     *
+     * @param unorderedList
+     *            the component to wrap
+     * @return a tester for the given component
+     */
     default UnorderedListTester test(UnorderedList unorderedList) {
         return BaseBrowserlessTest.internalWrap(UnorderedListTester.class,
                 unorderedList);
diff --git a/shared/src/main/java/com/vaadin/browserless/Tests.java b/shared/src/main/java/com/vaadin/browserless/Tests.java
index 69fac5fc..4e62738a 100644
--- a/shared/src/main/java/com/vaadin/browserless/Tests.java
+++ b/shared/src/main/java/com/vaadin/browserless/Tests.java
@@ -25,7 +25,7 @@
 /**
  * Wrapper annotation for indicating which components a wrapper implementation
  * supports.
- * <p/>
+ * <p>
  * This is used for automatically selecting a wrapper implementation for a given
  * component.
  *
@@ -43,5 +43,11 @@
      */
     Class<? extends Component>[] value() default {};
 
+    /**
+     * The fully qualified names of the tested component types, for components
+     * that are not on the compile classpath of this module.
+     *
+     * @return the tested component type names
+     */
     String[] fqn() default {};
 }
diff --git a/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java b/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
index 8e0d0604..52fe8cb6 100644
--- a/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
+++ b/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
@@ -171,12 +171,24 @@ private GridUtils() {
 
     /**
      * Returns the item on given row. Fails if the row index is invalid. The
-     * data provider is sorted according to given [sortOrders] (empty by
-     * default) and filtered according to given [filter] (null by default)
+     * data provider is sorted according to given {@code sortOrders} (empty by
+     * default) and filtered according to given {@code filter} (null by default)
      * first.
      *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
      * @param rowIndex
      *            the row, 0..size - 1
+     * @param sortOrders
+     *            the sort orders to pass to the query
+     * @param inMemorySorting
+     *            the comparator applied in memory, or null for none
+     * @param filter
+     *            the filter to pass to the query, or null for none
      * @return the item at given row.
      * @throws AssertionError
      *             if the row index is out of bounds.
@@ -200,15 +212,41 @@ public static <T, F> T _get(DataProvider<T, F> provider, int rowIndex,
         return list.get(0);
     }
 
+    /**
+     * Equivalent to
+     * {@code _get(provider, rowIndex, Collections.emptyList(), null, null)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @param rowIndex
+     *            the row index, 0-based
+     * @return the item at the given row
+     */
     public static <T, F> T _get(DataProvider<T, F> provider, int rowIndex) {
         return _get(provider, rowIndex, Collections.emptyList(), null, null);
     }
 
     /**
      * Returns all items in given data provider, sorted according to given
-     * [sortOrders] (empty by default) and filtered according to given [filter]
-     * (null by default).
+     * {@code sortOrders} (empty by default) and filtered according to given
+     * {@code filter} (null by default).
      *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @param sortOrders
+     *            the sort orders to pass to the query
+     * @param inMemorySorting
+     *            the comparator applied in memory, or null for none
+     * @param filter
+     *            the filter to pass to the query, or null for none
      * @return the list of items.
      */
     public static <T, F> List<T> _findAll(DataProvider<T, F> provider,
@@ -219,6 +257,18 @@ public static <T, F> List<T> _findAll(DataProvider<T, F> provider,
         return fetched.collect(Collectors.toList());
     }
 
+    /**
+     * Equivalent to
+     * {@code _findAll(provider, Collections.emptyList(), null, null)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @return all items the data provider returns
+     */
     public static <T, F> List<T> _findAll(DataProvider<T, F> provider) {
         return _findAll(provider, Collections.emptyList(), null, null);
     }
@@ -227,11 +277,15 @@ public static <T, F> List<T> _findAll(DataProvider<T, F> provider) {
      * Returns the item on given row. Fails if the row index is invalid. Uses
      * current Grid sorting.
      *
-     * For [TreeGrid] this returns the x-th displayed row; skips children of
-     * collapsed nodes. Uses [_rowSequence].
+     * For {@link TreeGrid} this returns the x-th displayed row; skips children
+     * of collapsed nodes. Uses {@code _rowSequence}.
      *
-     * WARNING: Very slow operation for [TreeGrid].
+     * WARNING: Very slow operation for {@link TreeGrid}.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @param rowIndex
      *            the row, 0..size - 1
      * @return the item at given row, not null.
@@ -260,15 +314,19 @@ public static <T> T _get(Grid<T> grid, int rowIndex) {
     }
 
     /**
-     * Returns the item on given row, or null if the [rowIndex] is larger than
-     * the number of items the data provider can provide. Uses current Grid
+     * Returns the item on given row, or null if the {@code rowIndex} is larger
+     * than the number of items the data provider can provide. Uses current Grid
      * sorting.
      *
-     * For [TreeGrid] this returns the x-th displayed row; skips children of
-     * collapsed nodes. Uses [_rowSequence].
+     * For {@link TreeGrid} this returns the x-th displayed row; skips children
+     * of collapsed nodes. Uses {@code _rowSequence}.
      *
-     * WARNING: Very slow operation for [TreeGrid].
+     * WARNING: Very slow operation for {@link TreeGrid}.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @param rowIndex
      *            the row, 0 or larger.
      * @return the item at given row or null if the data provider provides less
@@ -296,8 +354,10 @@ public static <T> T _getOrNull(Grid<T> grid, int rowIndex) {
      * retrieving the number of available rows. See `FetchCallback` for more
      * details.
      *
-     * @return true if the current data provider supports [_size] retrieval,
-     *         false if not. Returns true for Vaadin 14.
+     * @param grid
+     *            the grid to read
+     * @return true if the current data provider supports {@code _size}
+     *         retrieval, false if not. Returns true for Vaadin 14.
      */
     public static boolean _dataProviderSupportsSizeOp(Grid<?> grid) {
         try {
@@ -312,12 +372,22 @@ public static boolean _dataProviderSupportsSizeOp(Grid<?> grid) {
      * Returns items in given range from Grid's data provider. Uses current Grid
      * sorting.
      *
-     * For [TreeGrid] this walks the [_rowSequence].
+     * For {@link TreeGrid} this walks the {@code _rowSequence}.
      *
      * The Grid never sets any filters into the data provider, however any
      * ConfigurableFilterDataProvider will automatically apply its filters.
      *
-     * WARNING: Very slow operation for [TreeGrid].
+     * WARNING: Very slow operation for {@link TreeGrid}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param offset
+     *            the index of the first item to fetch
+     * @param limit
+     *            the maximum number of items to fetch
+     * @return items in given range from Grid's data provider
      */
     public static <T> List<T> _fetch(Grid<T> grid, int offset, int limit) {
         if (grid instanceof TreeGrid) {
@@ -334,7 +404,17 @@ public static <T> List<T> _fetch(Grid<T> grid, int offset, int limit) {
      * Grid sorting. Any ConfigurableFilterDataProvider will automatically apply
      * its filters.
      *
-     * This is an internal stuff, most probably you wish to call [_fetch].
+     * This is an internal stuff, most probably you wish to call {@code _fetch}.
+     *
+     * @param <T>
+     *            the item type
+     * @param dc
+     *            the data communicator to read
+     * @param offset
+     *            the index of the first item to fetch
+     * @param limit
+     *            the maximum number of items to fetch
+     * @return items in given range from this data communicator
      */
     public static <T> List<T> fetch(DataCommunicator<T> dc, int offset,
             int limit) {
@@ -363,7 +443,13 @@ public static <T> List<T> fetch(DataCommunicator<T> dc, int offset,
      * Returns all items from this data communicator. Uses current Grid sorting.
      * Any ConfigurableFilterDataProvider will automatically apply its filters.
      *
-     * This is an internal stuff, most probably you wish to call [_fetch].
+     * This is an internal stuff, most probably you wish to call {@code _fetch}.
+     *
+     * @param <T>
+     *            the item type
+     * @param dc
+     *            the data communicator to read
+     * @return all items from this data communicator
      */
     public static <T> List<T> fetchAll(DataCommunicator<T> dc) {
         return fetch(dc, 0, BasicUtils._saneFetchLimit());
@@ -372,12 +458,16 @@ public static <T> List<T> fetchAll(DataCommunicator<T> dc) {
     /**
      * Returns all items in given data provider. Uses current Grid sorting.
      *
-     * For [TreeGrid] this returns all displayed rows; skips children of
+     * For {@link TreeGrid} this returns all displayed rows; skips children of
      * collapsed nodes.
      *
      * The Grid never sets any filters into the data provider, however any
      * ConfigurableFilterDataProvider will automatically apply its filters.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @return the list of items.
      */
     public static <T> List<T> _findAll(Grid<T> grid) {
@@ -387,8 +477,18 @@ public static <T> List<T> _findAll(Grid<T> grid) {
     /**
      * Returns the number of items in this data provider.
      *
-     * In case of [HierarchicalDataProvider] this returns the number of ALL
-     * items including all leafs.
+     * In case of {@link HierarchicalDataProvider} this returns the number of
+     * ALL items including all leafs.
+     *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @param filter
+     *            the filter to pass to the query, or null for none
+     * @return the number of items in this data provider
      */
     public static <T, F> int _size(DataProvider<T, F> provider, F filter) {
         if (provider instanceof HierarchicalDataProvider) {
@@ -399,6 +499,17 @@ public static <T, F> int _size(DataProvider<T, F> provider, F filter) {
         return provider.size(new Query<>(filter));
     }
 
+    /**
+     * Equivalent to {@code _size(provider, null)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @return the number of items in this data provider
+     */
     public static <T, F> int _size(DataProvider<T, F> provider) {
         return _size(provider, null);
     }
@@ -406,28 +517,61 @@ public static <T, F> int _size(DataProvider<T, F> provider) {
     /**
      * Returns the number of items in this data provider, including child items.
      * The function traverses recursively until all children are found; then a
-     * total size is returned. The function uses [HierarchicalDataProvider.size]
-     * mostly, but also uses [HierarchicalDataProvider.fetchChildren] to
-     * discover children. Only children matching [filter] are considered for
-     * recursive computation of the size.
+     * total size is returned. The function uses
+     * {@link HierarchicalDataProvider#size(com.vaadin.flow.data.provider.Query)}
+     * mostly, but also uses
+     * {@link HierarchicalDataProvider#fetchChildren(HierarchicalQuery)} to
+     * discover children. Only children matching {@code filter} are considered
+     * for recursive computation of the size.
      *
      * Note that this can differ to `Grid._size()` since `Grid._size()` ignores
      * children of collapsed tree nodes.
      *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
      * @param root
      *            start with this item; defaults to null to iterate all items
      * @param filter
-     *            filter to pass to [HierarchicalQuery]
+     *            filter to pass to {@link HierarchicalQuery}
+     * @return the number of items in this data provider, including child items
      */
     public static <T, F> int _size(HierarchicalDataProvider<T, F> provider,
             T root, F filter) {
         return (int) _rowSequence(provider, root, item -> true, filter).count();
     }
 
+    /**
+     * Equivalent to {@code _size(provider, null, null)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @return the number of items in this data provider, including child items
+     */
     public static <T, F> int _size(HierarchicalDataProvider<T, F> provider) {
         return _size(provider, null, null);
     }
 
+    /**
+     * Equivalent to {@code _size(provider, root, null)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @param root
+     *            start with this item; null iterates all items
+     * @return the number of items below the given root, including child items
+     */
     public static <T, F> int _size(HierarchicalDataProvider<T, F> provider,
             T root) {
         return _size(provider, root, null);
@@ -436,14 +580,19 @@ public static <T, F> int _size(HierarchicalDataProvider<T, F> provider,
     /**
      * Returns the number of items in this Grid.
      *
-     * For [TreeGrid] this computes the number of items the [TreeGrid] is
-     * actually showing on-screen, ignoring children of collapsed nodes.
+     * For {@link TreeGrid} this computes the number of items the
+     * {@link TreeGrid} is actually showing on-screen, ignoring children of
+     * collapsed nodes.
      *
-     * A very slow operation for [TreeGrid] since it walks through all items
-     * returned by [_rowSequence].
+     * A very slow operation for {@link TreeGrid} since it walks through all
+     * items returned by {@code _rowSequence}.
      *
-     * If [_dataProviderSupportsSizeOp] is false, this function will fetch all
-     * the data and count the result returned, which is also very slow.
+     * If {@code _dataProviderSupportsSizeOp} is false, this function will fetch
+     * all the data and count the result returned, which is also very slow.
+     *
+     * @param grid
+     *            the grid to read
+     * @return the number of items in this Grid
      */
     public static int _size(Grid<?> grid) {
         if (grid instanceof TreeGrid) {
@@ -461,8 +610,15 @@ public static int _size(Grid<?> grid) {
     }
 
     /**
-     * Gets a [Grid.Column] of this grid by its [columnKey].
+     * Gets a {@link Grid.Column} of this grid by its {@code columnKey}.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param columnKey
+     *            the column key
+     * @return a {@link Grid.Column} of this grid by its {@code columnKey}
      * @throws AssertionError
      *             if no such column exists.
      */
@@ -481,15 +637,22 @@ public static <T> Grid.Column<T> _getColumnByKey(Grid<T> grid,
     }
 
     /**
-     * Retrieves a component produced by [ComponentRenderer] in given [Grid]
-     * cell. Fails if the renderer is not a [ComponentRenderer].
+     * Retrieves a component produced by {@link ComponentRenderer} in given
+     * {@link Grid} cell. Fails if the renderer is not a
+     * {@link ComponentRenderer}.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @param rowIndex
      *            the row index, 0 or higher.
      * @param columnKey
-     *            the column key [Grid.Column.getKey]
+     *            the column key {@link Grid.Column#getKey()}
+     * @return a component produced by {@link ComponentRenderer} in given
+     *         {@link Grid} cell
      * @throws IllegalStateException
-     *             if the renderer is not [ComponentRenderer].
+     *             if the renderer is not {@link ComponentRenderer}.
      */
     public static <T> Component _getCellComponent(Grid<T> grid, int rowIndex,
             String columnKey) {
@@ -514,13 +677,18 @@ public static <T> Component _getCellComponent(Grid<T> grid, int rowIndex,
 
     /**
      * Returns the formatted value of given column as a String. Uses
-     * [getPresentationValue] and converts the result to string (even if the
-     * result is a [Component]).
+     * {@code getPresentationValue} and converts the result to string (even if
+     * the result is a {@link Component}).
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @param rowIndex
      *            the row index, 0 or higher.
      * @param columnKey
      *            the column ID.
+     * @return the formatted value of given column as a String
      */
     public static <T> String _getFormatted(Grid<T> grid, int rowIndex,
             String columnKey) {
@@ -530,11 +698,17 @@ public static <T> String _getFormatted(Grid<T> grid, int rowIndex,
     }
 
     /**
-     * Returns the formatted value as a String. Uses [getPresentationValue] and
-     * converts the result to string (even if the result is a [Component]).
+     * Returns the formatted value as a String. Uses
+     * {@code getPresentationValue} and converts the result to string (even if
+     * the result is a {@link Component}).
      *
+     * @param <T>
+     *            the item type
+     * @param column
+     *            the column to read
      * @param rowObject
      *            the bean
+     * @return the formatted value as a String
      */
     public static <T> String _getFormatted(Grid.Column<T> column, T rowObject) {
         Object value = getPresentationValue(column, rowObject);
@@ -543,10 +717,16 @@ public static <T> String _getFormatted(Grid.Column<T> column, T rowObject) {
 
     /**
      * Returns the formatted row as a list of Strings, one for every visible
-     * column. Uses [_getFormatted].
+     * column. Uses {@code _getFormatted}.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @param rowObject
      *            the bean
+     * @return the formatted row as a list of Strings, one for every visible
+     *         column
      */
     public static <T> List<String> _getFormattedRow(Grid<T> grid, T rowObject) {
         List<String> result = new ArrayList<>();
@@ -560,11 +740,17 @@ public static <T> List<String> _getFormattedRow(Grid<T> grid, T rowObject) {
 
     /**
      * Returns the formatted row as a list of Strings, one for every visible
-     * column. Uses [_getFormatted]. Fails if the [rowIndex] is not within the
-     * limits.
+     * column. Uses {@code _getFormatted}. Fails if the {@code rowIndex} is not
+     * within the limits.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @param rowIndex
      *            the index of the row, 0..size-1.
+     * @return the formatted row as a list of Strings, one for every visible
+     *         column
      */
     public static <T> List<String> _getFormattedRow(Grid<T> grid,
             int rowIndex) {
@@ -574,11 +760,17 @@ public static <T> List<String> _getFormattedRow(Grid<T> grid,
 
     /**
      * Returns the formatted row as a list of Strings, one for every visible
-     * column. Uses [_getFormatted]. Returns null if the [rowIndex] is not
-     * within the limits.
+     * column. Uses {@code _getFormatted}. Returns null if the {@code rowIndex}
+     * is not within the limits.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
      * @param rowIndex
      *            the index of the row, 0-based.
+     * @return the formatted row as a list of Strings, one for every visible
+     *         column
      */
     public static <T> List<String> _getFormattedRowOrNull(Grid<T> grid,
             int rowIndex) {
@@ -590,9 +782,19 @@ public static <T> List<String> _getFormattedRowOrNull(Grid<T> grid,
     }
 
     /**
-     * Returns the output of renderer set for this column for given [rowObject]
-     * formatted as close as possible to the client-side output, using
-     * [Grid.Column.renderer].
+     * Returns the output of renderer set for this column for given
+     * {@code rowObject} formatted as close as possible to the client-side
+     * output, using the column's renderer.
+     *
+     * @param <T>
+     *            the item type
+     * @param column
+     *            the column to read
+     * @param rowObject
+     *            the item the row shows
+     * @return the output of renderer set for this column for given {@code
+     *         rowObject} formatted as close as possible to the client-side
+     *         output, using the column's renderer
      */
     public static <T> Object getPresentationValue(Grid.Column<T> column,
             T rowObject) {
@@ -627,8 +829,8 @@ private static <T> String getSortIndicator(Grid<T> grid,
 
     /**
      * Dumps given range of rows of the Grid, formatting the values using the
-     * [_getFormatted] function. Does not consider header groups. The output
-     * example:
+     * {@code _getFormatted} function. Does not consider header groups. The
+     * output example:
      *
      * <pre>
      * --[Name]--[Age]--[Occupation]--
@@ -636,11 +838,31 @@ private static <T> String getSortIndicator(Grid<T> grid,
      * 1: Fred, 40, Supervisor
      * --and 198 more
      * </pre>
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @return the grid contents, formatted as a table
      */
     public static <T> String _dump(Grid<T> grid) {
         return _dump(grid, 0, 9);
     }
 
+    /**
+     * Dumps the given range of rows of the grid, formatting the values with
+     * {@code _getFormatted}. Does not consider header groups.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to dump
+     * @param from
+     *            the first row to dump, 0-based
+     * @param to
+     *            the row to stop before, exclusive
+     * @return the rows, formatted as a table
+     */
     public static <T> String _dump(Grid<T> grid, int from, int to) {
         StringBuilder sb = new StringBuilder();
         List<Grid.Column<T>> visibleColumns = new ArrayList<>();
@@ -730,8 +952,13 @@ public static <T> String _dump(Grid<T> grid, int from, int to) {
     }
 
     /**
-     * Asserts that this grid's provider returns given [count] of items. If not,
-     * an [AssertionError] is thrown with the Grid [_dump].
+     * Asserts that this grid's provider returns given {@code count} of items.
+     * If not, an {@link AssertionError} is thrown with the Grid {@code _dump}.
+     *
+     * @param grid
+     *            the grid to read
+     * @param count
+     *            the expected number of items
      */
     public static void expectRows(Grid<?> grid, int count) {
         int actual = _size(grid);
@@ -743,8 +970,12 @@ public static void expectRows(Grid<?> grid, int count) {
     }
 
     /**
-     * Asserts that this grid's [rowIndex] row is formatted as expected.
+     * Asserts that this grid's {@code rowIndex} row is formatted as expected.
      *
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
      * @param row
      *            the expected row formatting.
      */
@@ -783,7 +1014,8 @@ static Object column(FooterRow.FooterCell cell) {
     }
 
     /**
-     * Returns the [ValueProvider] backing this [ColumnPathRenderer].
+     * Returns the {@link ValueProvider} backing this
+     * {@link ColumnPathRenderer}.
      */
     @SuppressWarnings("unchecked")
     static <T> ValueProvider<T, ?> providerOf(ColumnPathRenderer<T> renderer) {
@@ -811,8 +1043,12 @@ private static String columnKey(Object abstractColumn) {
     }
 
     /**
-     * Retrieves the cell for given [Grid.Column.getKey].
+     * Retrieves the cell for given {@link Grid.Column#getKey()}.
      *
+     * @param row
+     *            the row index, 0-based
+     * @param key
+     *            the key that was pressed
      * @return the corresponding cell
      * @throws IllegalArgumentException
      *             if no such column exists.
@@ -829,8 +1065,12 @@ public static HeaderRow.HeaderCell getCell(HeaderRow row, String key) {
     }
 
     /**
-     * Retrieves the cell for given [Grid.Column.getKey].
+     * Retrieves the cell for given {@link Grid.Column#getKey()}.
      *
+     * @param row
+     *            the row index, 0-based
+     * @param key
+     *            the key that was pressed
      * @return the corresponding cell
      * @throws IllegalArgumentException
      *             if no such column exists.
@@ -846,8 +1086,15 @@ public static FooterRow.FooterCell getCell(FooterRow row, String key) {
     }
 
     /**
-     * Sorts given grid. Affects [_findAll], [_get] and other data-fetching
-     * functions.
+     * Sorts given grid. Affects {@code _findAll}, {@code _get} and other
+     * data-fetching functions.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param sortOrder
+     *            the sort order to apply
      */
     public static <T> void sort(Grid<T> grid, QuerySortOrder... sortOrder) {
         List<GridSortOrder<T>> orders = new ArrayList<>();
@@ -864,9 +1111,16 @@ public static <T> void sort(Grid<T> grid, QuerySortOrder... sortOrder) {
     // ---------------------------------------------------------------------
 
     /**
-     * Fires the [ItemClickEvent] event for given [rowIndex] which invokes all
-     * item click listeners registered via [Grid.addItemClickListener].
+     * Fires the {@link ItemClickEvent} event for given {@code rowIndex} which
+     * invokes all item click listeners registered via
+     * {@link Grid#addItemClickListener(com.vaadin.flow.component.ComponentEventListener)}.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
      * @param button
      *            the id of the pressed mouse button (0 is the default button,
      *            see ClickEvent.getButton)
@@ -890,19 +1144,36 @@ public static <T> void _clickItem(Grid<T> grid, int rowIndex, int button,
                 shiftKey, altKey, metaKey);
     }
 
+    /**
+     * Equivalent to
+     * {@code _clickItem(grid, rowIndex, 0, false, false, false, false)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
+     */
     public static <T> void _clickItem(Grid<T> grid, int rowIndex) {
         _clickItem(grid, rowIndex, 0, false, false, false, false);
     }
 
     /**
-     * Fires the [ItemClickEvent] event for given [rowIndex] and a [column]
-     * which invokes all item click listeners registered via
-     * [Grid.addItemClickListener].
+     * Fires the {@link ItemClickEvent} event for given {@code rowIndex} and a
+     * {@code column} which invokes all item click listeners registered via
+     * {@link Grid#addItemClickListener(com.vaadin.flow.component.ComponentEventListener)}.
      *
-     * @param button
-     *            the id of the pressed mouse button
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
      * @param column
      *            optional column to be clicked
+     * @param button
+     *            the id of the pressed mouse button
      * @param ctrlKey
      *            `true` if the control key was down when the event was fired,
      *            `false` otherwise
@@ -943,20 +1214,39 @@ public static <T> void _clickItem(Grid<T> grid, int rowIndex,
         BasicUtils._fireEvent(grid, event);
     }
 
+    /**
+     * Equivalent to
+     * {@code _clickItem(grid, rowIndex, column, 1, false, false, false, false)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
+     * @param column
+     *            the column to read
+     */
     public static <T> void _clickItem(Grid<T> grid, int rowIndex,
             Grid.Column<?> column) {
         _clickItem(grid, rowIndex, column, 1, false, false, false, false);
     }
 
     /**
-     * Fires the [ItemClickEvent] event for given [rowIndex] and a [columnKey]
-     * which invokes all item click listeners registered via
-     * [Grid.addItemClickListener].
+     * Fires the {@link ItemClickEvent} event for given {@code rowIndex} and a
+     * {@code columnKey} which invokes all item click listeners registered via
+     * {@link Grid#addItemClickListener(com.vaadin.flow.component.ComponentEventListener)}.
      *
-     * @param button
-     *            the id of the pressed mouse button
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
      * @param columnKey
      *            the key of the column to be clicked
+     * @param button
+     *            the id of the pressed mouse button
      * @param ctrlKey
      *            `true` if the control key was down when the event was fired,
      *            `false` otherwise
@@ -977,16 +1267,35 @@ public static <T> void _clickItem(Grid<T> grid, int rowIndex,
                 ctrlKey, shiftKey, altKey, metaKey);
     }
 
+    /**
+     * Equivalent to
+     * {@code _clickItem(grid, rowIndex, columnKey, 1, false, false, false, false)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
+     * @param columnKey
+     *            the column key
+     */
     public static <T> void _clickItem(Grid<T> grid, int rowIndex,
             String columnKey) {
         _clickItem(grid, rowIndex, columnKey, 1, false, false, false, false);
     }
 
     /**
-     * Fires the [ItemDoubleClickEvent] event for given [rowIndex] which invokes
-     * all item click listeners registered via
-     * [Grid.addItemDoubleClickListener].
+     * Fires the {@link ItemDoubleClickEvent} event for given {@code rowIndex}
+     * which invokes all item click listeners registered via
+     * {@link Grid#addItemDoubleClickListener(com.vaadin.flow.component.ComponentEventListener)}.
      *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
      * @param button
      *            the id of the pressed mouse button
      * @param ctrlKey
@@ -1014,6 +1323,17 @@ public static <T> void _doubleClickItem(Grid<T> grid, int rowIndex,
         BasicUtils._fireEvent(grid, event);
     }
 
+    /**
+     * Equivalent to
+     * {@code _doubleClickItem(grid, rowIndex, 1, false, false, false, false)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param rowIndex
+     *            the row index, 0-based
+     */
     public static <T> void _doubleClickItem(Grid<T> grid, int rowIndex) {
         _doubleClickItem(grid, rowIndex, 1, false, false, false, false);
     }
@@ -1023,13 +1343,23 @@ public static <T> void _doubleClickItem(Grid<T> grid, int rowIndex) {
     // ---------------------------------------------------------------------
 
     /**
-     * Returns a stream which walks over all rows the [TreeGrid] is actually
-     * showing. The stream will *skip* children of collapsed nodes.
+     * Returns a stream which walks over all rows the {@link TreeGrid} is
+     * actually showing. The stream will <em>skip</em> children of collapsed
+     * nodes.
      *
      * Iterating the entire stream is a very slow operation since it will
-     * repeatedly poll [HierarchicalDataProvider] for list of children.
+     * repeatedly poll {@link HierarchicalDataProvider} for list of children.
      *
      * Honors current grid ordering.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param filter
+     *            the filter to pass to the query, or null for none
+     * @return a stream which walks over all rows the {@link TreeGrid} is
+     *         actually showing
      */
     public static <T> Stream<T> _rowSequence(TreeGrid<T> grid,
             SerializablePredicate<T> filter) {
@@ -1037,26 +1367,44 @@ public static <T> Stream<T> _rowSequence(TreeGrid<T> grid,
         return _rowSequence(grid.getDataProvider(), null, isExpanded, filter);
     }
 
+    /**
+     * Equivalent to {@code _rowSequence(grid, null)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @return a stream over the rows the grid is actually showing
+     */
     public static <T> Stream<T> _rowSequence(TreeGrid<T> grid) {
         return _rowSequence(grid, null);
     }
 
     /**
-     * Returns a stream which walks over all rows the [TreeGrid] is actually
-     * showing. The stream will *skip* children of collapsed nodes.
+     * Returns a stream which walks over all rows the {@link TreeGrid} is
+     * actually showing. The stream will <em>skip</em> children of collapsed
+     * nodes.
      *
      * Iterating the entire stream is a very slow operation since it will
-     * repeatedly poll [HierarchicalDataProvider] for list of children.
+     * repeatedly poll {@link HierarchicalDataProvider} for list of children.
      *
      * Honors current grid ordering.
      *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
      * @param root
      *            start with this item; defaults to null to iterate all items
      * @param isExpanded
      *            if returns false for an item, children of that item are
      *            skipped
      * @param filter
-     *            filter to pass to [HierarchicalQuery]
+     *            filter to pass to {@link HierarchicalQuery}
+     * @return a stream which walks over all rows the {@link TreeGrid} is
+     *         actually showing
      */
     public static <T, F> Stream<T> _rowSequence(
             HierarchicalDataProvider<T, F> provider, T root,
@@ -1079,17 +1427,32 @@ public static <T, F> Stream<T> _rowSequence(
         return result;
     }
 
+    /**
+     * Equivalent to {@code _rowSequence(provider, null, item -> true, null)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param <F>
+     *            the filter type
+     * @param provider
+     *            the data provider to read
+     * @return a stream over all items the data provider returns
+     */
     public static <T, F> Stream<T> _rowSequence(
             HierarchicalDataProvider<T, F> provider) {
         return _rowSequence(provider, null, item -> true, null);
     }
 
     /**
-     * Returns the number of items the [TreeGrid] is actually showing. For
+     * Returns the number of items the {@link TreeGrid} is actually showing. For
      * example it doesn't count in children of collapsed nodes.
      *
      * A very slow operation since it walks through all items returned by
-     * [_rowSequence].
+     * {@code _rowSequence}.
+     *
+     * @param grid
+     *            the grid to read
+     * @return the number of items the {@link TreeGrid} is actually showing
      */
     public static int _size(TreeGrid<?> grid) {
         return (int) _rowSequence(grid).count();
@@ -1119,6 +1482,16 @@ private static <T, F> List<T> checkedFetch(
         return provider.fetchChildren(query).collect(Collectors.toList());
     }
 
+    /**
+     * Renders the tree grid's data source as a pretty tree, expanding every
+     * node regardless of what the grid currently shows.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the tree grid to read
+     * @return the data source, as a printable tree
+     */
     public static <T> PrettyPrintTree _dataSourceToPrettyTree(
             TreeGrid<T> grid) {
         Function<T, List<T>> getChildrenOf = item -> {
@@ -1155,6 +1528,16 @@ private static <T> PrettyPrintTree toPrettyTree(TreeGrid<T> grid,
         return new PrettyPrintTree(self.toString(), childTrees);
     }
 
+    /**
+     * Equivalent to
+     * {@code grid.getDataProvider().fetch(new HierarchicalQuery<>(null, null)) .collect(Collectors.toList())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @return the root items of the tree
+     */
     public static <T> List<T> _getRootItems(TreeGrid<T> grid) {
         return grid.getDataProvider().fetch(new HierarchicalQuery<>(null, null))
                 .collect(Collectors.toList());
@@ -1162,11 +1545,26 @@ public static <T> List<T> _getRootItems(TreeGrid<T> grid) {
 
     /**
      * Expands all nodes. May invoke massive data loading.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     * @param depth
+     *            how deep the walk has gone, 0 for the root
      */
     public static <T> void _expandAll(TreeGrid<T> grid, int depth) {
         grid.expandRecursively(_getRootItems(grid), depth);
     }
 
+    /**
+     * Equivalent to {@code _expandAll(grid, 100)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param grid
+     *            the grid to read
+     */
     public static <T> void _expandAll(TreeGrid<T> grid) {
         _expandAll(grid, 100);
     }
@@ -1180,6 +1578,10 @@ public static <T> void _expandAll(TreeGrid<T> grid) {
      *
      * Works both with Vaadin 16 and Vaadin 17: Vaadin 17 components no longer
      * implement HasItems.
+     *
+     * @param c
+     *            the component to inspect
+     * @return the data provider currently set to this Component
      */
     public static DataProvider<?, ?> dataProvider(Component c) {
         try {
@@ -1216,9 +1618,16 @@ public static <T> void _expandAll(TreeGrid<T> grid) {
     // ---------------------------------------------------------------------
 
     /**
-     * Call this instead of [Editor.editItem] - this function makes sure that
-     * the editor opening is mocked properly, calls the editor bindings, and
-     * fires the editor-open-event.
+     * Call this instead of {@link Editor#editItem(Object)} - this function
+     * makes sure that the editor opening is mocked properly, calls the editor
+     * bindings, and fires the editor-open-event.
+     *
+     * @param <T>
+     *            the item type
+     * @param editor
+     *            the editor to act on
+     * @param item
+     *            the item to act on
      */
     public static <T> void _editItem(Editor<T> editor, T item) {
         if (!editor.getGrid().isAttached()) {
@@ -1274,12 +1683,12 @@ private static <T> GridMultiSelectionModel<T> _selectAllCheckboxModel(
      * In single select clears the selection and selects only the given item; in
      * multi-select adds it to the selection.
      *
+     * @param <T>
+     *            the grid item type
      * @param grid
      *            the grid to select in
      * @param item
      *            the item to select
-     * @param <T>
-     *            the grid item type
      */
     public static <T> void _select(Grid<T> grid, T item) {
         BasicUtils.checkEditableByUser(grid);
@@ -1294,10 +1703,10 @@ public static <T> void _select(Grid<T> grid, T item) {
      * Selects all items in the Grid; runs the same code as when the "select
      * all" checkbox is checked.
      *
-     * @param grid
-     *            the grid to select in
      * @param <T>
      *            the grid item type
+     * @param grid
+     *            the grid to select in
      * @throws IllegalStateException
      *             if the grid is not multi-select, or the "select all" checkbox
      *             is hidden
@@ -1323,13 +1732,13 @@ public static <T> void _selectAll(Grid<T> grid) {
      * is single-select with
      * {@link GridSingleSelectionModel#isDeselectAllowed()} set to false.
      *
+     * @param <T>
+     *            the grid item type
      * @param grid
      *            the grid to deselect in
      * @param item
      *            the item to deselect; it must be selected, since deselecting a
      *            row that is not selected is not a gesture the user has
-     * @param <T>
-     *            the grid item type
      * @throws IllegalStateException
      *             if the item is not selected
      */
@@ -1354,10 +1763,10 @@ public static <T> void _deselect(Grid<T> grid, T item) {
      * by unchecking rows one by one. Call {@link #_deselect} per row to model
      * that instead.
      *
-     * @param grid
-     *            the grid to deselect in
      * @param <T>
      *            the grid item type
+     * @param grid
+     *            the grid to deselect in
      * @throws IllegalStateException
      *             if the grid is not multi-select, or the "select all" checkbox
      *             is hidden
@@ -1374,9 +1783,9 @@ public static <T> void _deselectAll(Grid<T> grid) {
     }
 
     /**
-     * Returns the column's Internal ID. Not related to [Grid.Column.getKey] in
-     * any way. Auto-generated by the Grid. Not really useful; mostly used
-     * internally by Vaadin.
+     * Returns the column's Internal ID. Not related to
+     * {@link Grid.Column#getKey()} in any way. Auto-generated by the Grid. Not
+     * really useful; mostly used internally by Vaadin.
      */
     public static String _internalId(Grid.Column<?> column) {
         try {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
index a56dad27..2f336f5f 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
@@ -69,6 +69,8 @@ public static void _fireEvent(Component component,
     /**
      * Fires a DOM event on this component.
      * 
+     * @param component
+     *            the component to fire the event on
      * @param eventType
      *            the event type, e.g. "click"
      */
@@ -79,6 +81,8 @@ public static void _fireDomEvent(Component component, String eventType) {
     /**
      * Fires a DOM event on this component.
      * 
+     * @param component
+     *            the component to fire the event on
      * @param eventType
      *            the event type, e.g. "click"
      * @param eventData
@@ -95,11 +99,23 @@ public static void _fireDomEvent(Component component, String eventType,
      * The same as {@link Component#getId} but without Optional.
      *
      * Workaround for https://github.com/vaadin/flow/issues/664
+     *
+     * @param component
+     *            the component to set the id on
+     * @return the component id, or null if it has none
      */
     public static String id_(Component component) {
         return component.getId().orElse(null);
     }
 
+    /**
+     * Equivalent to {@code component.setId(value)}.
+     *
+     * @param component
+     *            the component to set the id on
+     * @param value
+     *            the value to set
+     */
     public static void id_(Component component, String value) {
         component.setId(value);
     }
@@ -108,6 +124,12 @@ public static void id_(Component component, String value) {
      * Checks whether the component is visible (usually
      * {@link Component#isVisible} but for {@link Text} the text must be
      * non-empty).
+     *
+     * @param component
+     *            the component to inspect
+     * @return {@code true} if the component is visible (usually
+     *         {@link Component#isVisible} but for {@link Text} the text must be
+     *         non-empty)
      */
     public static boolean _isVisible(Component component) {
         if (component instanceof Text) {
@@ -120,6 +142,10 @@ public static boolean _isVisible(Component component) {
 
     /**
      * Returns direct text contents (it doesn't peek into the child elements).
+     *
+     * @param component
+     *            the component to inspect
+     * @return direct text contents (it doesn't peek into the child elements)
      */
     public static String _text(Component component) {
         if (component instanceof HasText) {
@@ -139,6 +165,8 @@ public static String _text(Component component) {
      * enabled. * If the component is {@link HasValue}, it must not be
      * {@link HasValue#isReadOnly}.
      * 
+     * @param component
+     *            the component to check
      * @throws IllegalStateException
      *             if any of the above doesn't hold.
      */
@@ -182,6 +210,8 @@ public static void checkEditableByUser(Component component) {
      * Fails if the component is editable. See {@link #checkEditableByUser} for
      * more details.
      * 
+     * @param component
+     *            the component to check
      * @throws AssertionError
      *             if the component is editable.
      */
@@ -205,12 +235,15 @@ static boolean isEffectivelyVisible(Component component) {
      * Computes whether this component and all of its parents are enabled.
      *
      * Recursively checks that all ancestors are also enabled (the "implicitly
-     * disabled" effect, see {@link HasEnabled#isEnabled} javadoc for more
-     * details).
+     * disabled" effect, see
+     * {@link com.vaadin.flow.component.HasEnabled#isEnabled()
+     * HasEnabled.isEnabled()} javadoc for more details).
      *
      * Also check that the component is not inert due to there being a modal
      * component.
      *
+     * @param component
+     *            the component to inspect
      * @return false if this component or any of its parent is disabled or is
      *         inert.
      */
@@ -222,6 +255,11 @@ public static boolean isEffectivelyEnabled(Component component) {
     /**
      * Fires {@link FocusNotifier.FocusEvent} on the component, but only if it's
      * editable.
+     *
+     * @param <T>
+     *            the item type
+     * @param component
+     *            the component to focus
      */
     public static <T extends Component & Focusable<T>> void _focus(
             T component) {
@@ -233,6 +271,11 @@ public static <T extends Component & Focusable<T>> void _focus(
     /**
      * Fires {@link BlurNotifier.BlurEvent} on the component, but only if it's
      * editable.
+     *
+     * @param <T>
+     *            the item type
+     * @param component
+     *            the component to blur
      */
     public static <T extends Component & Focusable<T>> void _blur(T component) {
         checkEditableByUser(component);
@@ -244,6 +287,9 @@ public static <T extends Component & Focusable<T>> void _blur(T component) {
      * Closes the UI and simulates the end of the request. The {@link UI#close}
      * is called, but also the session is set to null which fires the detach
      * listeners and makes the UI and all of its components detached.
+     *
+     * @param ui
+     *            the UI to act on
      */
     public static void _close(UI ui) {
         ui.close();
@@ -254,6 +300,11 @@ public static void _close(UI ui) {
     /**
      * Returns child components which were added to this component via
      * {@code com.vaadin.flow.dom.Element.appendVirtualChild}.
+     *
+     * @param component
+     *            the component to inspect
+     * @return child components which were added to this component via
+     *         {@code com.vaadin.flow.dom.Element.appendVirtualChild}
      */
     public static List<Component> _getVirtualChildren(Component component) {
         List<Component> result = new ArrayList<>();
@@ -268,6 +319,12 @@ static String errorMessage(InternalServerError error) {
         return error.getElement().getText();
     }
 
+    /**
+     * The number of rows a lookup fetches before it gives up, so that a
+     * misconfigured data provider fails the test instead of hanging it.
+     *
+     * @return the fetch limit
+     */
     public static int _saneFetchLimit() {
         // don't use high value otherwise Vaadin 19+ will calculate negative
         // limit and will pass it to SizeVerifier,
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/BrowserlessFeatureFlags.java b/shared/src/main/java/com/vaadin/browserless/internal/BrowserlessFeatureFlags.java
index 8e2e3c43..6fec671d 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/BrowserlessFeatureFlags.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/BrowserlessFeatureFlags.java
@@ -46,6 +46,9 @@ public class BrowserlessFeatureFlags extends FeatureFlags {
      * NOTE: assigned only after the super constructor completes, so it is null
      * while the super constructor invokes loadProperties().
      */
+    /**
+     * The feature flags the test turned on or off, by feature id.
+     */
     private final Map<String, Boolean> overrides;
 
     private BrowserlessFeatureFlags(Lookup lookup,
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java
index 298a0460..9909ec76 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java
@@ -78,6 +78,11 @@ private ComponentUtils() {
 
     /**
      * Fires given event on the component.
+     *
+     * @param component
+     *            the component to fire the event on
+     * @param event
+     *            the event to fire
      */
     public static void fireEvent(Component component, ComponentEvent<?> event) {
         ComponentUtil.fireEvent(component, event);
@@ -88,11 +93,39 @@ public static void fireEvent(Component component, ComponentEvent<?> event) {
      * to all {@link ClickNotifier}s. This function directly calls all click
      * listeners, thus it avoids the roundtrip to client and back. It even works
      * with browserless testing.
+     *
+     * @param <T>
+     *            the item type
+     * @param notifier
+     *            the component to fire the event on
      */
     public static <T extends ClickNotifier<?>> void serverClick(T notifier) {
         serverClick(notifier, true, 0, 1, false, false, false, false);
     }
 
+    /**
+     * Fires a click event on the component, as the browser would.
+     *
+     * @param <T>
+     *            the component type
+     * @param notifier
+     *            the component to click
+     * @param fromClient
+     *            whether the event is reported as coming from the client
+     * @param button
+     *            the mouse button, as
+     *            {@link com.vaadin.browserless.MouseButton} numbers them
+     * @param clickCount
+     *            how many clicks the event reports
+     * @param shiftKey
+     *            whether Shift was held down
+     * @param ctrlKey
+     *            whether Ctrl was held down
+     * @param altKey
+     *            whether Alt was held down
+     * @param metaKey
+     *            whether Meta was held down
+     */
     public static <T extends ClickNotifier<?>> void serverClick(T notifier,
             boolean fromClient, int button, int clickCount, boolean shiftKey,
             boolean ctrlKey, boolean altKey, boolean metaKey) {
@@ -104,22 +137,48 @@ public static <T extends ClickNotifier<?>> void serverClick(T notifier,
     /**
      * Sets the alignment of the text in the component. One of `center`, `left`,
      * `right`, `justify`.
+     *
+     * @param component
+     *            the component to change
+     * @return the text alignment, or null if none is set
      */
     public static String textAlign(Component component) {
         return component.getElement().getStyle().get("textAlign");
     }
 
+    /**
+     * Equivalent to
+     * {@code component.getElement().getStyle().set("textAlign", value)}.
+     *
+     * @param component
+     *            the component to change
+     * @param value
+     *            the value to set
+     */
     public static void textAlign(Component component, String value) {
         component.getElement().getStyle().set("textAlign", value);
     }
 
     /**
      * Sets or removes the `title` attribute on component's element.
+     *
+     * @param component
+     *            the component to change
+     * @return the tooltip text, or null if the component has none
      */
     public static String tooltip(Component component) {
         return component.getElement().getAttribute("title");
     }
 
+    /**
+     * Equivalent to
+     * {@code ElementUtils.setOrRemoveAttribute(component.getElement(), "title", value)}.
+     *
+     * @param component
+     *            the component to change
+     * @param value
+     *            the value to set
+     */
     public static void tooltip(Component component, String value) {
         ElementUtils.setOrRemoveAttribute(component.getElement(), "title",
                 value);
@@ -129,6 +188,12 @@ public static void tooltip(Component component, String value) {
      * Adds the right-click (context-menu) {@code listener} to the component.
      * Also causes the right-click browser menu not to be shown on this
      * component (see {@link #preventDefault}).
+     *
+     * @param component
+     *            the component to add the listener to
+     * @param listener
+     *            the listener to add
+     * @return the registration, so the listener can be removed again
      */
     public static DomListenerRegistration addContextMenuListener(
             Component component, DomEventListener listener) {
@@ -141,6 +206,8 @@ public static DomListenerRegistration addContextMenuListener(
      * "https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault">Event.preventDefault()</a>
      * on the event.
      *
+     * @param registration
+     *            the registration to remove
      * @return this
      */
     public static DomListenerRegistration preventDefault(
@@ -151,6 +218,9 @@ public static DomListenerRegistration preventDefault(
     /**
      * Removes the component from its parent. Does nothing if the component is
      * not attached to a parent.
+     *
+     * @param component
+     *            the component to detach
      */
     public static void removeFromParent(Component component) {
         Component parent = component.getParent().orElse(null);
@@ -162,6 +232,13 @@ public static void removeFromParent(Component component) {
     /**
      * Finds component's parent, parent's parent (etc) which satisfies given
      * {@code predicate}. Returns null if there is no such parent.
+     *
+     * @param component
+     *            the component to inspect
+     * @param predicate
+     *            the predicate the component must satisfy
+     * @return component's parent, parent's parent (etc) which satisfies given
+     *         {@code predicate}
      */
     public static Component findAncestor(Component component,
             Predicate<Component> predicate) {
@@ -173,6 +250,13 @@ public static Component findAncestor(Component component,
      * Finds component, component's parent, parent's parent (etc) which
      * satisfies given {@code predicate}. Returns null if no component on the
      * ancestor-or-self axis satisfies.
+     *
+     * @param component
+     *            the component to inspect
+     * @param predicate
+     *            the predicate the component must satisfy
+     * @return component, component's parent, parent's parent (etc) which
+     *         satisfies given {@code predicate}
      */
     public static Component findAncestorOrSelf(Component component,
             Predicate<Component> predicate) {
@@ -188,6 +272,13 @@ public static Component findAncestorOrSelf(Component component,
 
     /**
      * Checks if this component is nested in {@code potentialAncestor}.
+     *
+     * @param component
+     *            the component to inspect
+     * @param potentialAncestor
+     *            the component that may be an ancestor
+     * @return {@code true} if this component is nested in {@code
+     *         potentialAncestor}
      */
     public static boolean isNestedIn(Component component,
             Component potentialAncestor) {
@@ -198,6 +289,11 @@ public static boolean isNestedIn(Component component,
      * Checks whether this component is currently attached to a {@link UI}.
      *
      * Returns true for attached components even if the UI itself is closed.
+     *
+     * @param component
+     *            the component to inspect
+     * @return {@code true} if this component is currently attached to a
+     *         {@link UI}
      */
     public static boolean isAttached(Component component) {
         // see https://github.com/vaadin/flow/issues/7911
@@ -209,6 +305,10 @@ public static boolean isAttached(Component component) {
      *
      * Works both with Vaadin 16 and Vaadin 17: Vaadin 17 components no longer
      * implement HasItems.
+     *
+     * @param component
+     *            the component to inspect
+     * @return the data provider currently set to this Component
      */
     public static DataProvider<?, ?> dataProvider(Component component) {
         try {
@@ -245,6 +345,13 @@ public static boolean isAttached(Component component) {
      *
      * In case the specified component has already been added to another parent,
      * it will be removed from there and added to this one.
+     *
+     * @param container
+     *            the component to search, itself included
+     * @param newComponent
+     *            the component to insert
+     * @param existing
+     *            the child to insert ahead of
      */
     public static void insertBefore(HasOrderedComponents container,
             Component newComponent, Component existing) {
@@ -264,6 +371,10 @@ public static void insertBefore(HasOrderedComponents container,
      * Return the location of the currently shown view. The function will report
      * the current (old) view in {@code com.vaadin.flow.router.BeforeLeaveEvent}
      * and {@code com.vaadin.flow.router.BeforeEnterEvent}.
+     *
+     * @param ui
+     *            the UI to act on
+     * @return the location of the view the UI currently shows
      */
     public static Location currentViewLocation(UI ui) {
         return ui.getInternals().getActiveViewLocation();
@@ -271,6 +382,10 @@ public static Location currentViewLocation(UI ui) {
 
     /**
      * True when the component has any children.
+     *
+     * @param container
+     *            the component to search, itself included
+     * @return {@code true} if the container has at least one child
      */
     public static boolean hasChildren(HasComponents container) {
         return ((Component) container).getChildren().findFirst().isPresent();
@@ -280,6 +395,11 @@ public static boolean hasChildren(HasComponents container) {
      * Splits {@code classNames} by whitespaces to obtain individual class
      * names, then calls {@link HasStyle#addClassName} on each class name. Does
      * nothing if the string is blank.
+     *
+     * @param target
+     *            the component to change
+     * @param classNames
+     *            the CSS class names
      */
     public static void addClassNames2(HasStyle target, String classNames) {
         // workaround for https://github.com/vaadin/flow/issues/11709
@@ -292,6 +412,11 @@ public static void addClassNames2(HasStyle target, String classNames) {
      * Splits {@code classNames} by whitespaces to obtain individual class
      * names, then calls {@link #addClassNames2} on each class name. Does
      * nothing if the string is blank.
+     *
+     * @param target
+     *            the component to change
+     * @param classNames
+     *            the CSS class names
      */
     public static void addClassNames2(HasStyle target, String... classNames) {
         // workaround for https://github.com/vaadin/flow/issues/11709
@@ -304,6 +429,11 @@ public static void addClassNames2(HasStyle target, String... classNames) {
      * Splits {@code classNames} by whitespaces to obtain individual class
      * names, then calls {@link HasStyle#removeClassName} on each class name.
      * Does nothing if the string is blank.
+     *
+     * @param target
+     *            the component to change
+     * @param classNames
+     *            the CSS class names
      */
     public static void removeClassNames2(HasStyle target, String classNames) {
         // workaround for https://github.com/vaadin/flow/issues/11709
@@ -316,6 +446,11 @@ public static void removeClassNames2(HasStyle target, String classNames) {
      * Splits {@code classNames} by whitespaces to obtain individual class
      * names, then calls {@link #removeClassNames2} on each class name. Does
      * nothing if the string is blank.
+     *
+     * @param target
+     *            the component to change
+     * @param classNames
+     *            the CSS class names
      */
     public static void removeClassNames2(HasStyle target,
             String... classNames) {
@@ -329,6 +464,11 @@ public static void removeClassNames2(HasStyle target,
      * Splits {@code classNames} by whitespaces to obtain individual class
      * names, then clears the class names and calls {@link #addClassNames2} on
      * each class name. Does nothing if the string is blank.
+     *
+     * @param target
+     *            the component to change
+     * @param classNames
+     *            the CSS class names
      */
     public static void setClassNames2(HasStyle target, String classNames) {
         // workaround for https://github.com/vaadin/flow/issues/11709
@@ -340,6 +480,11 @@ public static void setClassNames2(HasStyle target, String classNames) {
      * Splits {@code classNames} by whitespaces to obtain individual class
      * names, then clears the class names and calls {@link #addClassNames2} on
      * each class name. Does nothing if the string is blank.
+     *
+     * @param target
+     *            the component to change
+     * @param classNames
+     *            the CSS class names
      */
     public static void setClassNames2(HasStyle target, String... classNames) {
         // workaround for https://github.com/vaadin/flow/issues/11709
@@ -351,6 +496,10 @@ public static void setClassNames2(HasStyle target, String... classNames) {
      * A component placeholder, usually shown when there's no value selected.
      * Not all components support a placeholder; those that don't will return
      * null.
+     *
+     * @param component
+     *            the component to inspect
+     * @return the placeholder, or null if the component has none
      */
     public static String placeholder(Component component) {
         // modify when this is fixed: https://github.com/vaadin/flow/issues/4068
@@ -375,6 +524,14 @@ public static String placeholder(Component component) {
         return null;
     }
 
+    /**
+     * Sets the component's placeholder.
+     *
+     * @param component
+     *            the component to change
+     * @param value
+     *            the placeholder to set, null to remove it
+     */
     public static void placeholder(Component component, String value) {
         if (component instanceof TextField) {
             ((TextField) component).setPlaceholder(value);
@@ -398,6 +555,10 @@ public static void placeholder(Component component, String value) {
      * Concatenates texts from all elements placed in the `label` slot. This
      * effectively returns whatever was provided in the String label via
      * {@link FormLayout#addFormItem}.
+     *
+     * @param item
+     *            the item to act on
+     * @return the text of the form item's label slot
      */
     public static String label(FormLayout.FormItem item) {
         List<Component> captions = item.getChildren().filter(
@@ -447,9 +608,9 @@ public static String label(FormLayout.FormItem item) {
      * `label` slot. This effectively returns whatever was provided in the
      * String label via {@link FormLayout#addFormItem}.
      *
-     * {@link Button#caption} is displayed directly on the component while label
-     * is displayed next to the component in a layout (e.g. a {@link TextField}
-     * nested in a form layout).
+     * A {@link Button}'s caption is displayed directly on the component while
+     * label is displayed next to the component in a layout (e.g. a
+     * {@link TextField} nested in a form layout).
      *
      * Vote for <a href="https://github.com/vaadin/flow/issues/3241">issue
      * #3241</a>.
@@ -461,6 +622,10 @@ public static String label(FormLayout.FormItem item) {
      * `VerticalLayout` will show nothing since {@link FormLayout} doesn't
      * display a label itself. See {@code LabelWrapper} for a list of possible
      * solutions.
+     *
+     * @param component
+     *            the component to inspect
+     * @return the component's label, or null if it has none
      */
     public static String label(Component component) {
         try {
@@ -490,6 +655,14 @@ public static String label(Component component) {
         }
     }
 
+    /**
+     * Sets the component's label.
+     *
+     * @param component
+     *            the component to change
+     * @param value
+     *            the label to set, null to remove it
+     */
     public static void label(Component component, String value) {
         try {
             if (_HasLabel != null && _HasLabel.isInstance(component)) {
@@ -524,6 +697,10 @@ public static void label(Component component, String value) {
      * but only managed to create confusion between the two concepts. Also,
      * there's only a {@link Button} which has the notion of a caption. Will be
      * removed with no replacement.
+     *
+     * @param component
+     *            the component to inspect
+     * @return the component's caption, or null if it has none
      */
     @Deprecated
     public static String caption(Component component) {
@@ -533,6 +710,14 @@ public static String caption(Component component) {
         return label(component);
     }
 
+    /**
+     * Sets the component's caption.
+     *
+     * @param component
+     *            the component to change
+     * @param value
+     *            the caption to set, null to remove it
+     */
     @Deprecated
     public static void caption(Component component, String value) {
         if (component instanceof Button) {
@@ -546,6 +731,9 @@ public static void caption(Component component, String value) {
      * Sets up an event listener for overlay components that fires a `closed`
      * DOM event when the component is closed. This simulates the event being
      * fired from the browser after the closing animation has finished.
+     *
+     * @param component
+     *            the component to close
      */
     public static void simulateClosedEvent(Component component) {
         if (ComponentUtil.getData(component,
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java b/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
index f47d92c1..15aa9862 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
@@ -39,8 +39,14 @@ public final class CountRange implements Serializable {
      */
     public static final CountRange ONE = new CountRange(1, 1);
 
+    /**
+     * The smallest accepted count, inclusive.
+     */
     private final int start;
 
+    /**
+     * The largest accepted count, inclusive.
+     */
     private final int endInclusive;
 
     /**
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java b/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java
index 79030a2d..57c76322 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java
@@ -48,6 +48,8 @@ public class DepthFirstTreeIterator<T> implements Iterator<T> {
     private final Function<T, List<T>> children;
 
     /**
+     * Creates an iterator over the tree below the given node.
+     *
      * @param root
      *            start here.
      * @param children
@@ -81,6 +83,10 @@ public T next() {
     /**
      * Walks the component child tree, depth-first: first the component, then
      * its descendants, then its next sibling.
+     *
+     * @param root
+     *            the component to start from
+     * @return the components, in depth-first order
      */
     public static Iterable<Component> walk(Component root) {
         return () -> new DepthFirstTreeIterator<>(root, component -> component
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java
index d2c55775..7018b8a4 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java
@@ -53,8 +53,12 @@ private ElementUtils() {
      * Either calls {@link Element#setAttribute} (if the {@code value} is not
      * null), or {@link Element#removeAttribute} (if the {@code value} is null).
      * 
+     * @param element
+     *            the element to change
      * @param attribute
      *            the name of the attribute.
+     * @param value
+     *            the value to set
      */
     public static void setOrRemoveAttribute(Element element, String attribute,
             String value) {
@@ -69,6 +73,8 @@ public static void setOrRemoveAttribute(Element element, String attribute,
      * Toggles {@code className} - removes it if it was there, or adds it if it
      * wasn't there.
      * 
+     * @param classList
+     *            the element's class list
      * @param className
      *            the class name to toggle, cannot contain spaces.
      */
@@ -83,6 +89,13 @@ public static void toggle(ClassList classList, String className) {
     /**
      * Inserts {@code newNode} as a child, right before an {@code existingNode}.
      * A counterpart for JavaScript DOM `Node.insertBefore()`.
+     *
+     * @param parent
+     *            the element to insert into
+     * @param newNode
+     *            the element to insert
+     * @param existingNode
+     *            the child to insert ahead of
      */
     public static void insertBefore(Element parent, Element newNode,
             Element existingNode) {
@@ -101,6 +114,10 @@ public static void insertBefore(Element parent, Element newNode,
     /**
      * This function actually works, as opposed to
      * {@link Element#getTextRecursively}.
+     *
+     * @param element
+     *            the element to inspect
+     * @return the text of the element and of all of its descendants
      */
     public static String textRecursively2(Element element) {
         // remove when this is fixed: https://github.com/vaadin/flow/issues/3668
@@ -108,6 +125,13 @@ public static String textRecursively2(Element element) {
         return textRecursively(node);
     }
 
+    /**
+     * Returns the text of the node and of all of its descendants.
+     *
+     * @param node
+     *            the node to read
+     * @return the concatenated text
+     */
     public static String textRecursively(Node node) {
         if (node instanceof TextNode) {
             return ((TextNode) node).text();
@@ -122,6 +146,11 @@ public static String textRecursively(Node node) {
     /**
      * Returns all virtual child elements added via
      * {@link Element#appendVirtualChild}.
+     *
+     * @param element
+     *            the element to inspect
+     * @return all virtual child elements added via
+     *         {@link Element#appendVirtualChild}
      */
     public static List<Element> getVirtualChildren(Element element) {
         if (element.getNode().hasFeature(VirtualChildrenList.class)) {
@@ -142,6 +171,10 @@ public static List<Element> getVirtualChildren(Element element) {
 
     /**
      * Gets the element mapped to the given state node.
+     *
+     * @param node
+     *            the node to inspect
+     * @return the element mapped to the given state node
      */
     public static Element element(StateNode node) {
         return Element.get(node);
@@ -150,6 +183,13 @@ public static Element element(StateNode node) {
     /**
      * Returns child elements with the `slot` attribute set to given
      * {@code slotName}.
+     *
+     * @param element
+     *            the element to inspect
+     * @param slotName
+     *            the name of the slot
+     * @return child elements with the `slot` attribute set to given {@code
+     *         slotName}
      */
     public static List<Element> getChildrenInSlot(Element element,
             String slotName) {
@@ -160,6 +200,11 @@ public static List<Element> getChildrenInSlot(Element element,
 
     /**
      * Removes all child elements from given slot, leaving it empty.
+     *
+     * @param element
+     *            the element whose slot is cleared
+     * @param slotName
+     *            the name of the slot
      */
     public static void clearSlot(Element element, String slotName) {
         if (slotName == null || slotName.isBlank()) {
@@ -172,6 +217,10 @@ public static void clearSlot(Element element, String slotName) {
 
     /**
      * Returns all components that are closest to {@code this} element.
+     *
+     * @param element
+     *            the element to inspect
+     * @return all components that are closest to {@code this} element
      */
     public static List<Component> _findComponents(Element element) {
         List<Component> components = new ArrayList<>();
@@ -181,6 +230,11 @@ public static List<Component> _findComponents(Element element) {
 
     /**
      * Fires a DOM {@code event} on this element.
+     *
+     * @param element
+     *            the element to fire the event on
+     * @param event
+     *            the event to fire
      */
     public static void _fireDomEvent(Element element, DomEvent event) {
         element.getNode().getFeature(ElementListenerMap.class).fireEvent(event);
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Locator.java b/shared/src/main/java/com/vaadin/browserless/internal/Locator.java
index fa7afd07..70a884e8 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/Locator.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Locator.java
@@ -52,6 +52,8 @@ private Locator() {
      * Finds a VISIBLE component of given {@code clazz} which matches given
      * {@code block}. This component and all of its descendants are searched.
      *
+     * @param <T>
+     *            the item type
      * @param container
      *            the root component to search under.
      * @param clazz
@@ -85,6 +87,15 @@ public static <T extends Component> T _get(Component container,
     /**
      * Finds a VISIBLE component of given {@code clazz}; see
      * {@link #_get(Component, Class, Consumer)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     * @return a VISIBLE component of given {@code clazz}; see
+     *         {@link #_get(Component, Class, Consumer)}
      */
     public static <T extends Component> T _get(Component container,
             Class<T> clazz) {
@@ -95,6 +106,15 @@ public static <T extends Component> T _get(Component container,
      * Finds a VISIBLE component in the current UI of given {@code clazz} which
      * matches given {@code block}. The current UI and all of its descendants
      * are searched.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @param block
+     *            configures the search spec before the lookup runs
+     * @return a VISIBLE component in the current UI of given {@code clazz}
+     *         which matches given {@code block}
      */
     public static <T extends Component> T _get(Class<T> clazz,
             Consumer<SearchSpec<T>> block) {
@@ -103,6 +123,12 @@ public static <T extends Component> T _get(Class<T> clazz,
 
     /**
      * Finds a VISIBLE component in the current UI of given {@code clazz}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @return a VISIBLE component in the current UI of given {@code clazz}
      */
     public static <T extends Component> T _get(Class<T> clazz) {
         return _get(Utils.currentUI(), clazz, Locator.<T> noop());
@@ -112,6 +138,14 @@ public static <T extends Component> T _get(Class<T> clazz) {
      * Finds a list of VISIBLE components of given {@code clazz} which matches
      * {@code block}. This component and all of its descendants are searched.
      *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     * @param block
+     *            configures the search spec before the lookup runs
      * @return the list of matching components, may be empty.
      */
     public static <T extends Component> List<T> _find(Component container,
@@ -175,6 +209,15 @@ public static <T extends Component> List<T> _find(Component container,
     /**
      * Finds a list of VISIBLE components of given {@code clazz}; see
      * {@link #_find(Component, Class, Consumer)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     * @return a list of VISIBLE components of given {@code clazz}; see
+     *         {@link #_find(Component, Class, Consumer)}
      */
     public static <T extends Component> List<T> _find(Component container,
             Class<T> clazz) {
@@ -184,6 +227,15 @@ public static <T extends Component> List<T> _find(Component container,
     /**
      * Finds a list of VISIBLE components in the current UI of given
      * {@code clazz} which matches {@code block}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @param block
+     *            configures the search spec before the lookup runs
+     * @return a list of VISIBLE components in the current UI of given
+     *         {@code clazz} which matches {@code block}
      */
     public static <T extends Component> List<T> _find(Class<T> clazz,
             Consumer<SearchSpec<T>> block) {
@@ -193,6 +245,13 @@ public static <T extends Component> List<T> _find(Class<T> clazz,
     /**
      * Finds a list of VISIBLE components in the current UI of given
      * {@code clazz}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @return a list of VISIBLE components in the current UI of given
+     *         {@code clazz}
      */
     public static <T extends Component> List<T> _find(Class<T> clazz) {
         return _find(Utils.currentUI(), clazz, Locator.<T> noop());
@@ -244,6 +303,10 @@ private static boolean containsPolymerTemplate(Component root) {
     /**
      * Walks the component child/descendant tree, depth-first: first the
      * component, then its descendants, then its next sibling.
+     *
+     * @param root
+     *            the component to start from
+     * @return the components, in depth-first order
      */
     public static Iterable<Component> _walkAll(final Component root) {
         return new Iterable<Component>() {
@@ -261,6 +324,14 @@ public Iterator<Component> iterator() {
      * matches {@code block}. This component and all of its descendants are
      * searched.
      *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     * @param block
+     *            configures the search spec before the lookup runs
      * @throws AssertionError
      *             if one or more components matched.
      */
@@ -283,6 +354,16 @@ public static <T extends Component> void _expectNone(Component container,
         }
     }
 
+    /**
+     * Equivalent to {@code _expectNone(container, clazz, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     */
     public static <T extends Component> void _expectNone(Component container,
             Class<T> clazz) {
         _expectNone(container, clazz, Locator.<T> noop());
@@ -291,12 +372,28 @@ public static <T extends Component> void _expectNone(Component container,
     /**
      * Expects that there are no VISIBLE components in the current UI of given
      * {@code clazz} which matches {@code block}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @param block
+     *            configures the search spec before the lookup runs
      */
     public static <T extends Component> void _expectNone(Class<T> clazz,
             Consumer<SearchSpec<T>> block) {
         _expectNone(Utils.currentUI(), clazz, block);
     }
 
+    /**
+     * Equivalent to
+     * {@code _expectNone(Utils.currentUI(), clazz, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     */
     public static <T extends Component> void _expectNone(Class<T> clazz) {
         _expectNone(Utils.currentUI(), clazz, Locator.<T> noop());
     }
@@ -311,6 +408,15 @@ public static void _expectNoDialogs() {
     /**
      * Expects that there is exactly one VISIBLE component of given
      * {@code clazz} which matches {@code block}.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     * @param block
+     *            configures the search spec before the lookup runs
      */
     public static <T extends Component> void _expectOne(Component container,
             Class<T> clazz, Consumer<SearchSpec<T>> block) {
@@ -322,16 +428,45 @@ public static <T extends Component> void _expectOne(Component container,
         _get(container, clazz, block);
     }
 
+    /**
+     * Equivalent to {@code _expectOne(container, clazz, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     */
     public static <T extends Component> void _expectOne(Component container,
             Class<T> clazz) {
         _expectOne(container, clazz, Locator.<T> noop());
     }
 
+    /**
+     * Equivalent to {@code _expectOne(Utils.currentUI(), clazz, block)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @param block
+     *            configures the search spec before the lookup runs
+     */
     public static <T extends Component> void _expectOne(Class<T> clazz,
             Consumer<SearchSpec<T>> block) {
         _expectOne(Utils.currentUI(), clazz, block);
     }
 
+    /**
+     * Equivalent to
+     * {@code _expectOne(Utils.currentUI(), clazz, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     */
     public static <T extends Component> void _expectOne(Class<T> clazz) {
         _expectOne(Utils.currentUI(), clazz, Locator.<T> noop());
     }
@@ -340,6 +475,17 @@ public static <T extends Component> void _expectOne(Class<T> clazz) {
      * Expects that there are exactly {@code count} VISIBLE components of given
      * {@code clazz} match {@code block}. This component and all of its
      * descendants are searched.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     * @param count
+     *            the expected number of items
+     * @param block
+     *            configures the search spec before the lookup runs
      */
     public static <T extends Component> void _expect(Component container,
             Class<T> clazz, int count, Consumer<SearchSpec<T>> block) {
@@ -354,26 +500,81 @@ public static <T extends Component> void _expect(Component container,
         });
     }
 
+    /**
+     * Equivalent to
+     * {@code _expect(container, clazz, count, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     * @param count
+     *            the expected number of items
+     */
     public static <T extends Component> void _expect(Component container,
             Class<T> clazz, int count) {
         _expect(container, clazz, count, Locator.<T> noop());
     }
 
+    /**
+     * Equivalent to {@code _expect(container, clazz, 1, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param container
+     *            the component to search, itself included
+     * @param clazz
+     *            the component type to look for
+     */
     public static <T extends Component> void _expect(Component container,
             Class<T> clazz) {
         _expect(container, clazz, 1, Locator.<T> noop());
     }
 
+    /**
+     * Equivalent to {@code _expect(Utils.currentUI(), clazz, count, block)}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @param count
+     *            the expected number of items
+     * @param block
+     *            configures the search spec before the lookup runs
+     */
     public static <T extends Component> void _expect(Class<T> clazz, int count,
             Consumer<SearchSpec<T>> block) {
         _expect(Utils.currentUI(), clazz, count, block);
     }
 
+    /**
+     * Equivalent to
+     * {@code _expect(Utils.currentUI(), clazz, count, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     * @param count
+     *            the expected number of items
+     */
     public static <T extends Component> void _expect(Class<T> clazz,
             int count) {
         _expect(Utils.currentUI(), clazz, count, Locator.<T> noop());
     }
 
+    /**
+     * Equivalent to
+     * {@code _expect(Utils.currentUI(), clazz, 1, Locator.<T> noop())}.
+     *
+     * @param <T>
+     *            the item type
+     * @param clazz
+     *            the component type to look for
+     */
     public static <T extends Component> void _expect(Class<T> clazz) {
         _expect(Utils.currentUI(), clazz, 1, Locator.<T> noop());
     }
@@ -381,6 +582,9 @@ public static <T extends Component> void _expect(Class<T> clazz) {
     /**
      * Asserts that the {@link InternalServerError} page is currently being
      * shown, optionally with given {@code expectedErrorMessage}.
+     *
+     * @param expectedErrorMessage
+     *            the message the error must contain
      */
     public static void _expectInternalServerError(String expectedErrorMessage) {
         TestingLifecycleHooks.getCurrent().awaitBeforeLookup();
@@ -405,6 +609,9 @@ public static void _expectInternalServerError(String expectedErrorMessage) {
         }
     }
 
+    /**
+     * Equivalent to {@code _expectInternalServerError("")}.
+     */
     public static void _expectInternalServerError() {
         _expectInternalServerError("");
     }
@@ -412,6 +619,8 @@ public static void _expectInternalServerError() {
     /**
      * Returns the browser's current path. Returns null if there is no current
      * UI.
+     *
+     * @return the browser's current path
      */
     public static String currentPath() {
         UI ui = UI.getCurrent();
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java b/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java
index 3a449e26..f06c9e94 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java
@@ -40,6 +40,12 @@
 @DefaultErrorHandler
 public class MockInternalSeverError extends InternalServerError {
 
+    /**
+     * Creates the error view.
+     */
+    public MockInternalSeverError() {
+    }
+
     @Override
     public int setErrorParameter(BeforeEnterEvent event,
             ErrorParameter<Exception> parameter) {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java b/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
index 12351a03..7238a667 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
@@ -29,5 +29,11 @@
  */
 @FunctionalInterface
 public interface MockRequestCustomizer {
+    /**
+     * Customizes the request before it is handed to the test.
+     *
+     * @param request
+     *            the request to customize
+     */
     void apply(MockRequest request);
 }
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java b/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java
index 8389e7b8..fed93938 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java
@@ -41,6 +41,16 @@
 @DefaultErrorHandler
 public class MockRouteNotFoundError extends RouteNotFoundError {
 
+    /**
+     * Creates the error view.
+     */
+    public MockRouteNotFoundError() {
+    }
+
+    /**
+     * The exception the navigation failed with, recorded so the test can assert
+     * on it.
+     */
     private NotFoundException cause = null;
 
     /**
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
index 77fe46ce..ac40f9e5 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
@@ -219,10 +219,10 @@ public static UI liveUI(UI ui) {
      * Please do that by extending {@link MockVaadinServlet} and overriding
      * {@link MockVaadinServlet#createServletService}
      * `createServletService(DeploymentConfiguration)`. Please consult
-     * {@link MockService} on what methods you must override in your custom
-     * service. Alternatively, see `MockSpringServlet` (in the
-     * `browserless-test-spring` module) on how to extend your custom servlet
-     * and provide all necessary mocking code.
+     * {@link com.vaadin.browserless.mocks.MockService MockService} on what
+     * methods you must override in your custom service. Alternatively, see
+     * `MockSpringServlet` (in the `browserless-test-spring` module) on how to
+     * extend your custom servlet and provide all necessary mocking code.
      *
      * @param routes
      *            all classes annotated with
@@ -234,6 +234,8 @@ public static UI liveUI(UI ui) {
      *            default simply instantiates {@link MockedUI} class.
      * @param lookupServices
      *            service classes to be provided to the lookup initializer
+     * @param configuration
+     *            the deployment configuration to use
      */
     public static void setup(Routes routes, UIFactory uiFactory,
             Set<Class<?>> lookupServices,
@@ -243,20 +245,50 @@ public static void setup(Routes routes, UIFactory uiFactory,
         setup(uiFactory, servlet, lookupServices, configuration);
     }
 
+    /**
+     * Equivalent to
+     * {@code setup(routes, uiFactory, lookupServices, BrowserlessConfiguration.empty())}.
+     *
+     * @param routes
+     *            the routes to register
+     * @param uiFactory
+     *            creates the UI instance
+     * @param lookupServices
+     *            the lookup services to register
+     */
     public static void setup(Routes routes, UIFactory uiFactory,
             Set<Class<?>> lookupServices) {
         setup(routes, uiFactory, lookupServices,
                 BrowserlessConfiguration.empty());
     }
 
+    /**
+     * Equivalent to {@code setup(routes, uiFactory, Collections.emptySet())}.
+     *
+     * @param routes
+     *            the routes to register
+     * @param uiFactory
+     *            creates the UI instance
+     */
     public static void setup(Routes routes, UIFactory uiFactory) {
         setup(routes, uiFactory, Collections.emptySet());
     }
 
+    /**
+     * Equivalent to
+     * {@code setup(routes, MockedUI::new, Collections.emptySet())}.
+     *
+     * @param routes
+     *            the routes to register
+     */
     public static void setup(Routes routes) {
         setup(routes, MockedUI::new, Collections.emptySet());
     }
 
+    /**
+     * Equivalent to
+     * {@code setup(new Routes(), MockedUI::new, Collections.emptySet())}.
+     */
     public static void setup() {
         setup(new Routes(), MockedUI::new, Collections.emptySet());
     }
@@ -264,6 +296,9 @@ public static void setup() {
     /**
      * Equivalent to
      * {@code setup(new Routes(), uiFactory, Collections.emptySet())}.
+     *
+     * @param uiFactory
+     *            creates the UI instance
      */
     public static void setup(UIFactory uiFactory) {
         setup(new Routes(), uiFactory, Collections.emptySet());
@@ -281,6 +316,8 @@ public static void setup(UIFactory uiFactory) {
      *            {@link VaadinServlet}.
      * @param lookupServices
      *            service classes to be provided to the lookup initializer
+     * @param configuration
+     *            the deployment configuration to use
      */
     public static void setup(UIFactory uiFactory, VaadinServlet servlet,
             Set<Class<?>> lookupServices,
@@ -293,20 +330,55 @@ public static void setup(UIFactory uiFactory, VaadinServlet servlet,
         createSession(servlet.getServletContext(), uiFactory);
     }
 
+    /**
+     * Equivalent to
+     * {@code setup(uiFactory, servlet, lookupServices, BrowserlessConfiguration.empty())}.
+     *
+     * @param uiFactory
+     *            creates the UI instance
+     * @param servlet
+     *            the servlet to act on
+     * @param lookupServices
+     *            the lookup services to register
+     */
     public static void setup(UIFactory uiFactory, VaadinServlet servlet,
             Set<Class<?>> lookupServices) {
         setup(uiFactory, servlet, lookupServices,
                 BrowserlessConfiguration.empty());
     }
 
+    /**
+     * Equivalent to {@code setup(uiFactory, servlet, Collections.emptySet())}.
+     *
+     * @param uiFactory
+     *            creates the UI instance
+     * @param servlet
+     *            the servlet to act on
+     */
     public static void setup(UIFactory uiFactory, VaadinServlet servlet) {
         setup(uiFactory, servlet, Collections.emptySet());
     }
 
+    /**
+     * Equivalent to
+     * {@code setup((UIFactory) MockedUI::new, servlet, Collections.emptySet())}.
+     *
+     * @param servlet
+     *            the servlet to act on
+     */
     public static void setup(VaadinServlet servlet) {
         setup((UIFactory) MockedUI::new, servlet, Collections.emptySet());
     }
 
+    /**
+     * Equivalent to
+     * {@code setup((UIFactory) MockedUI::new, servlet, lookupServices)}.
+     *
+     * @param servlet
+     *            the servlet to act on
+     * @param lookupServices
+     *            the lookup services to register
+     */
     public static void setup(VaadinServlet servlet,
             Set<Class<?>> lookupServices) {
         setup((UIFactory) MockedUI::new, servlet, lookupServices);
@@ -318,6 +390,12 @@ public static void setup(VaadinServlet servlet,
      * to share a single service across multiple independent sessions
      * (multi-user testing).
      *
+     * @param servlet
+     *            the servlet to act on
+     * @param lookupServices
+     *            the lookup services to register
+     * @param configuration
+     *            the deployment configuration to use
      * @return the initialized {@link VaadinServletService}
      */
     public static VaadinServletService setupServlet(VaadinServlet servlet,
@@ -383,12 +461,30 @@ public static VaadinServletService setupServlet(VaadinServlet servlet,
         return service;
     }
 
+    /**
+     * Equivalent to
+     * {@code setupServlet(servlet, lookupServices, BrowserlessConfiguration.empty())}.
+     *
+     * @param servlet
+     *            the servlet to act on
+     * @param lookupServices
+     *            the lookup services to register
+     * @return the service the servlet was initialized with
+     */
     public static VaadinServletService setupServlet(VaadinServlet servlet,
             Set<Class<?>> lookupServices) {
         return setupServlet(servlet, lookupServices,
                 BrowserlessConfiguration.empty());
     }
 
+    /**
+     * Equivalent to
+     * {@code setupServlet(servlet, Collections.emptySet(), BrowserlessConfiguration.empty())}.
+     *
+     * @param servlet
+     *            the servlet to act on
+     * @return the service the servlet was initialized with
+     */
     public static VaadinServletService setupServlet(VaadinServlet servlet) {
         return setupServlet(servlet, Collections.emptySet(),
                 BrowserlessConfiguration.empty());
@@ -397,6 +493,9 @@ public static VaadinServletService setupServlet(VaadinServlet servlet) {
     /**
      * Properly closes the current UI and fire the detach event on it. Does
      * nothing if there is no current UI.
+     *
+     * @param fireUIDetach
+     *            whether the UI detach listeners are fired
      */
     public static void closeCurrentUI(boolean fireUIDetach) {
         UI ui = UI.getCurrent();
@@ -462,6 +561,9 @@ private static void closeCurrentSession() {
      * `currentlyClosingSession` flag is set for the duration so the
      * `afterSessionClose` recreation hook (used by single-user `setup`) is
      * suppressed — multi-user callers manage their own session lifecycle.
+     *
+     * @param session
+     *            the session to act on
      */
     public static void fireSessionDestroyAndDrain(VaadinSession session) {
         VaadinService service = session.getService();
@@ -480,6 +582,11 @@ public static void fireSessionDestroyAndDrain(VaadinSession session) {
     /**
      * Creates a new session, request and response for the given
      * {@code service}, but does NOT set any thread-locals or create a UI.
+     *
+     * @param service
+     *            the service to act on
+     * @return a new session, request and response for the given {@code
+     *         service}, but does NOT set any thread-locals or create a UI
      */
     public static SessionObjects createSessionObjects(
             VaadinServletService service) {
@@ -555,6 +662,15 @@ private static void createSession(ServletContext ctx, UIFactory uiFactory) {
         createUI(uiFactory, objs.session);
     }
 
+    /**
+     * Creates a new UI in the given session and navigates it to the current
+     * location, as a browser would on a fresh page load.
+     *
+     * @param uiFactory
+     *            produces the UI instance
+     * @param session
+     *            the session the UI belongs to
+     */
     public static void createUI(UIFactory uiFactory, VaadinSession session) {
         VaadinRequest request = VaadinRequest.getCurrent();
         if (request == null) {
@@ -634,9 +750,10 @@ public static void createUI(UIFactory uiFactory, VaadinSession session) {
      * Calls the following:
      * <ul>
      * <li>{@code runUIQueue}
-     * <li>{@link StateTree#runExecutionsBeforeClientResponse} which runs all
-     * blocks scheduled via {@link UI#beforeClientResponse}
-     * <li>{@link #cleanupDialogs}
+     * <li>{@link com.vaadin.flow.internal.StateTree#runExecutionsBeforeClientResponse()
+     * StateTree.runExecutionsBeforeClientResponse} which runs all blocks
+     * scheduled via {@link UI#beforeClientResponse}
+     * <li>{@link TestingLifecycleHooks#cleanupDialogs}
      * </ul>
      *
      * If you'd like to test your {@link ErrorHandler} then take a look at
@@ -660,17 +777,19 @@ public static void clientRoundtrip() {
      *
      * If {@link VaadinSession#errorHandler} is not set or
      * {@code propagateExceptionToHandler} is false, any exceptions thrown from
-     * {@link Command}s scheduled via the {@link UI#access} will make this
-     * function fail. The exceptions will be wrapped in
-     * {@link ExecutionException}.
+     * {@link com.vaadin.flow.server.Command Command}s scheduled via the
+     * {@link UI#access} will make this function fail. The exceptions will be
+     * wrapped in {@link ExecutionException}.
      *
      * @param propagateExceptionToHandler
      *            defaults to false. If true and
      *            {@link VaadinSession#errorHandler} is set, any exceptions
-     *            thrown from {@link Command}s scheduled via the
-     *            {@link UI#access} will be redirected to
+     *            thrown from {@link com.vaadin.flow.server.Command Command}s
+     *            scheduled via the {@link UI#access} will be redirected to
      *            {@link VaadinSession#errorHandler} and will not be re-thrown
      *            from this method.
+     * @param session
+     *            the session to act on
      * @throws IllegalStateException
      *             if the environment is not mocked
      */
@@ -734,10 +853,21 @@ private static <T extends Throwable> void sneakyThrow(Throwable t)
         throw (T) t;
     }
 
+    /**
+     * Equivalent to
+     * {@code runUIQueue(propagateExceptionToHandler, VaadinSession.getCurrent())}.
+     *
+     * @param propagateExceptionToHandler
+     *            whether a failing command is handed to the session's error
+     *            handler instead of being rethrown
+     */
     public static void runUIQueue(boolean propagateExceptionToHandler) {
         runUIQueue(propagateExceptionToHandler, VaadinSession.getCurrent());
     }
 
+    /**
+     * Equivalent to {@code runUIQueue(false, VaadinSession.getCurrent())}.
+     */
     public static void runUIQueue() {
         runUIQueue(false, VaadinSession.getCurrent());
     }
@@ -746,8 +876,14 @@ public static void runUIQueue() {
      * Internal function, do not call directly.
      *
      * Only usable when you are providing your own implementation of
-     * {@link VaadinSession}. See {@link MockVaadinSession} on how to call this
-     * properly.
+     * {@link VaadinSession}. See
+     * {@link com.vaadin.browserless.mocks.MockVaadinSession MockVaadinSession}
+     * on how to call this properly.
+     *
+     * @param session
+     *            the session to act on
+     * @param uiFactory
+     *            creates the UI instance
      */
     public static void afterSessionClose(VaadinSession session,
             UIFactory uiFactory) {
@@ -792,6 +928,13 @@ public static void afterSessionClose(VaadinSession session,
     /**
      * Fires session init listeners on the given service. Java-friendly static
      * wrapper for the internal extension function.
+     *
+     * @param service
+     *            the service to act on
+     * @param session
+     *            the session to act on
+     * @param request
+     *            the request to act on
      */
     public static void fireSessionInit(VaadinService service,
             VaadinSession session, VaadinRequest request) {
@@ -802,6 +945,9 @@ public static void fireSessionInit(VaadinService service,
     /**
      * Fires service destroy listeners on the given service. Java-friendly
      * static wrapper for the internal extension function.
+     *
+     * @param service
+     *            the service to act on
      */
     public static void fireServiceDestroy(VaadinService service) {
         fireServiceDestroyListeners(service, new ServiceDestroyEvent(service));
@@ -864,11 +1010,33 @@ public static class MockPage extends Page {
         private static final Set<String> SELF_NAMES = new HashSet<>(
                 Arrays.asList("_self", "_parent", "_top", ""));
 
+        /**
+         * The UI this page belongs to.
+         */
         private final UI ui;
+        /**
+         * Produces the UI instance a reload puts in place of the old one.
+         */
         private final UIFactory uiFactory;
+        /**
+         * The session the UI belongs to.
+         */
         private final VaadinSession session;
+        /**
+         * The recorded outbound navigations, by window name.
+         */
         private final Map<String, List<String>> navigations = new LinkedHashMap<>();
 
+        /**
+         * Creates the page of the given UI.
+         *
+         * @param ui
+         *            the UI this page belongs to
+         * @param uiFactory
+         *            produces the UI a reload puts in place of the old one
+         * @param session
+         *            the session the UI belongs to
+         */
         public MockPage(UI ui, UIFactory uiFactory, VaadinSession session) {
             super(ui);
             this.ui = ui;
@@ -876,6 +1044,12 @@ public MockPage(UI ui, UIFactory uiFactory, VaadinSession session) {
             this.session = session;
         }
 
+        /**
+         * Returns the URL of the last navigation that replaced the current
+         * page.
+         *
+         * @return the URL, or null if nothing navigated away
+         */
         public String getLastExternalNavigationURL() {
             List<String> list = navigations.get("_self");
             if (list == null || list.isEmpty()) {
@@ -884,6 +1058,13 @@ public String getLastExternalNavigationURL() {
             return list.get(list.size() - 1);
         }
 
+        /**
+         * Returns the URL of the last navigation into the given window.
+         *
+         * @param windowName
+         *            the target window name, as passed to {@code open()}
+         * @return the URL, or null if nothing opened that window
+         */
         public String getExternalNavigationURL(String windowName) {
             List<String> list = navigations
                     .get(normalizeWindowName(windowName));
@@ -893,6 +1074,11 @@ public String getExternalNavigationURL(String windowName) {
             return list.get(list.size() - 1);
         }
 
+        /**
+         * Returns the URLs opened in each window other than the current one.
+         *
+         * @return the opened URLs, by window name
+         */
         public Map<String, List<String>> getOpenedWindows() {
             Map<String, List<String>> result = new LinkedHashMap<>();
             for (Map.Entry<String, List<String>> e : navigations.entrySet()) {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java b/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
index 7f54541e..6ec14c23 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
@@ -189,6 +189,13 @@ private void print(StringBuilder sb, String prefix, boolean isTail) {
         }
     }
 
+    /**
+     * Builds a printable tree out of the component and its descendants.
+     *
+     * @param root
+     *            the component to start from
+     * @return the tree, ready to be printed
+     */
     public static PrettyPrintTree ofVaadin(Component root) {
         PrettyPrintTree result = new PrettyPrintTree(toPrettyString(root),
                 new ArrayList<>());
@@ -199,6 +206,13 @@ public static PrettyPrintTree ofVaadin(Component root) {
         return result;
     }
 
+    /**
+     * Equivalent to {@code PrettyPrintTree.ofVaadin(c).print()}.
+     *
+     * @param c
+     *            the component to inspect
+     * @return the component tree rendered as text
+     */
     public static String toPrettyTree(Component c) {
         return PrettyPrintTree.ofVaadin(c).print();
     }
@@ -213,8 +227,17 @@ public static String toPrettyTree(Component c) {
      * Returns the most basic properties of the component, formatted as a
      * concise string: * The component class * The {@link Component#getId} *
      * Whether the component is {@link Component#isVisible} * Whether it is a
-     * {@link HasValue} that is read-only * the styles * The
-     * {@link Component#label} and text * The {@link HasValue#getValue}
+     * {@link HasValue} that is read-only * the styles * The label and text *
+     * The {@link HasValue#getValue}
+     *
+     * @param c
+     *            the component to inspect
+     * @return the most basic properties of the component, formatted as a
+     *         concise string: * The component class * The
+     *         {@link Component#getId} * Whether the component is
+     *         {@link Component#isVisible} * Whether it is a {@link HasValue}
+     *         that is read-only * the styles * The label and text * The
+     *         {@link HasValue#getValue}
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static String toPrettyString(Component c) {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java b/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
index 6946395a..c90a77d4 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
@@ -79,6 +79,15 @@ private Renderers() {
     /**
      * Returns the output of this renderer for given {@code rowObject} formatted
      * as close as possible to the client-side output.
+     *
+     * @param <T>
+     *            the item type
+     * @param renderer
+     *            the renderer to read the value from
+     * @param rowObject
+     *            the item the row shows
+     * @return the output of this renderer for given {@code rowObject} formatted
+     *         as close as possible to the client-side output
      */
     @SuppressWarnings("unchecked")
     public static <T> String _getPresentationValue(Renderer<T> renderer,
@@ -124,6 +133,20 @@ public static <T> String _getPresentationValue(Renderer<T> renderer,
         }
     }
 
+    /**
+     * Renders a Lit template the way the client would, substituting every
+     * {@code ${item.x}} expression with the matching value provider's output.
+     *
+     * @param <T>
+     *            the item type
+     * @param template
+     *            the Lit template source
+     * @param valueProviders
+     *            the value providers, by the name used in the template
+     * @param item
+     *            the item the row shows
+     * @return the template with every expression substituted
+     */
     public static <T> String renderLitTemplate(String template,
             Map<String, ValueProvider<T, ?>> valueProviders, T item) {
         String renderedTemplate = template;
@@ -140,6 +163,14 @@ public static <T> String renderLitTemplate(String template,
 
     /**
      * Returns the text rendered for given {@code item}.
+     *
+     * @param <T>
+     *            the item type
+     * @param renderer
+     *            the renderer to read the value from
+     * @param item
+     *            the item to act on
+     * @return the text rendered for given {@code item}
      */
     public static <T> String renderText(TextRenderer<T> renderer, T item) {
         return renderer.createComponent(item).getElement().getText();
@@ -147,6 +178,14 @@ public static <T> String renderText(TextRenderer<T> renderer, T item) {
 
     /**
      * Returns the {@link ValueProvider} set to {@link BasicRenderer}.
+     *
+     * @param <T>
+     *            the item type
+     * @param <V>
+     *            the value type
+     * @param renderer
+     *            the renderer to read the value from
+     * @return the {@link ValueProvider} set to {@link BasicRenderer}
      */
     @SuppressWarnings("unchecked")
     public static <T, V> ValueProvider<T, V> valueProvider(
@@ -161,6 +200,10 @@ public static <T, V> ValueProvider<T, V> valueProvider(
 
     /**
      * Returns the Polymer Template set to the {@link Renderer}.
+     *
+     * @param renderer
+     *            the renderer to read the value from
+     * @return the Polymer Template set to the {@link Renderer}
      */
     public static String template(Renderer<?> renderer) {
         try {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Routes.java b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
index 3ba256fd..57071946 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
@@ -58,30 +58,78 @@ public class Routes implements Serializable {
 
     private static final Logger LOG = LoggerFactory.getLogger(Routes.class);
 
+    /**
+     * The classes annotated with {@code @Route}.
+     */
     private final Set<Class<? extends Component>> routes;
 
+    /**
+     * The classes implementing {@code HasErrorParameter}.
+     */
     private final Set<Class<? extends HasErrorParameter<?>>> errorRoutes;
 
+    /**
+     * The classes implementing {@code RouterLayout}.
+     */
     private final Set<Class<? extends RouterLayout>> layouts;
 
+    /**
+     * Whether {@link #register} skips looking for a {@code @PWA} class.
+     */
     private boolean skipPwaInit;
 
+    /**
+     * Equivalent to
+     * {@code this(new LinkedHashSet<>(), defaultErrorRoutes(), new LinkedHashSet<>(), true)}.
+     */
     public Routes() {
         this(new LinkedHashSet<>(), defaultErrorRoutes(), new LinkedHashSet<>(),
                 true);
     }
 
+    /**
+     * Equivalent to
+     * {@code this(routes, errorRoutes, new LinkedHashSet<>(), true)}.
+     *
+     * @param routes
+     *            the routes to register
+     * @param errorRoutes
+     *            the error routes to register
+     */
     public Routes(Set<Class<? extends Component>> routes,
             Set<Class<? extends HasErrorParameter<?>>> errorRoutes) {
         this(routes, errorRoutes, new LinkedHashSet<>(), true);
     }
 
+    /**
+     * Equivalent to {@code this(routes, errorRoutes, layouts, true)}.
+     *
+     * @param routes
+     *            the routes to register
+     * @param errorRoutes
+     *            the error routes to register
+     * @param layouts
+     *            the layouts to register
+     */
     public Routes(Set<Class<? extends Component>> routes,
             Set<Class<? extends HasErrorParameter<?>>> errorRoutes,
             Set<Class<? extends RouterLayout>> layouts) {
         this(routes, errorRoutes, layouts, true);
     }
 
+    /**
+     * Creates a route set with the given contents.
+     *
+     * @param routes
+     *            the classes annotated with {@code @Route}
+     * @param errorRoutes
+     *            the classes implementing {@code HasErrorParameter}
+     * @param layouts
+     *            the classes implementing {@code RouterLayout}
+     * @param skipPwaInit
+     *            whether {@link #register} skips looking for a {@code @PWA}
+     *            class
+     */
     public Routes(Set<Class<? extends Component>> routes,
             Set<Class<? extends HasErrorParameter<?>>> errorRoutes,
             Set<Class<? extends RouterLayout>> layouts, boolean skipPwaInit) {
@@ -151,6 +199,9 @@ private static Set<Class<? extends HasErrorParameter<?>>> defaultErrorRoutes() {
     /**
      * Registers all routes to Vaadin 15 registry. Automatically called from
      * {@link MockVaadin#setup}.
+     *
+     * @param sc
+     *            the servlet context to register the routes in
      */
     @SuppressWarnings("unchecked")
     public void register(VaadinContext sc) {
@@ -231,6 +282,14 @@ public Routes autoDiscoverViews(String... packageNames) {
         return this;
     }
 
+    /**
+     * Returns a new route set holding the routes of both this set and the given
+     * one.
+     *
+     * @param other
+     *            the routes to merge in
+     * @return the union of the two route sets
+     */
     public Routes merge(Routes other) {
         Routes result = new Routes(new LinkedHashSet<>(this.routes),
                 new LinkedHashSet<>(this.errorRoutes),
@@ -266,6 +325,16 @@ private void cleanupErrorRoutes() {
     /**
      * Creates a copy of this Routes with optional field overrides. Mirrors the
      * Kotlin data-class `copy(...)` method.
+     *
+     * @param routes
+     *            the routes to register
+     * @param errorRoutes
+     *            the error routes to register
+     * @param layouts
+     *            the layouts to register
+     * @param skipPwaInit
+     *            whether PWA initialization is skipped
+     * @return a copy of this Routes with optional field overrides
      */
     public Routes copy(Set<Class<? extends Component>> routes,
             Set<Class<? extends HasErrorParameter<?>>> errorRoutes,
@@ -314,6 +383,9 @@ public int hashCode() {
 
     /**
      * Clears the PWA class config from this registry.
+     *
+     * @param registry
+     *            the route registry to register into
      */
     @SuppressWarnings("unchecked")
     public static void clearPwaClass(ApplicationRouteRegistry registry) {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java b/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
index da01be33..ac3bec08 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
@@ -34,6 +34,9 @@
  * support for custom search criteria</a> for more details.
  * <p>
  * For internal use only. May be renamed or removed in a future release.
+ *
+ * @param <T>
+ *            the component type
  */
 public class SearchSpec<T extends Component> {
 
@@ -112,6 +115,12 @@ public class SearchSpec<T extends Component> {
      */
     private String withoutThemes;
 
+    /**
+     * Creates a spec matching components of the given type.
+     *
+     * @param clazz
+     *            the component type to look for
+     */
     public SearchSpec(Class<T> clazz) {
         this.clazz = clazz;
     }
@@ -119,108 +128,264 @@ public SearchSpec(Class<T> clazz) {
     // Accessor methods, kept for Java-style usage and to preserve the Kotlin
     // `is`/getter/setter shape that other code relied on.
 
+    /**
+     * The class of the component we are searching for.
+     *
+     * @return the current value
+     */
     public Class<T> getClazz() {
         return clazz;
     }
 
+    /**
+     * The required {@link Component#getId()}; if null, no particular id is
+     * matched.
+     *
+     * @return the current value
+     */
     public String getId() {
         return id;
     }
 
+    /**
+     * The required {@link Component#getId()}; if null, no particular id is
+     * matched.
+     *
+     * @param id
+     *            the new value
+     */
     public void setId(String id) {
         this.id = id;
     }
 
+    /**
+     * The required test id, i.e. the {@code data-testid} attribute; if null, no
+     * particular test id is matched.
+     *
+     * @return the current value
+     */
     public String getTestId() {
         return testId;
     }
 
+    /**
+     * The required test id, i.e. the {@code data-testid} attribute; if null, no
+     * particular test id is matched.
+     *
+     * @param testId
+     *            the new value
+     */
     public void setTestId(String testId) {
         this.testId = testId;
     }
 
+    /**
+     * The required {@code caption}; if null, no particular caption is matched.
+     *
+     * @return the current value
+     */
     public String getCaption() {
         return caption;
     }
 
+    /**
+     * The required {@code caption}; if null, no particular caption is matched.
+     *
+     * @param caption
+     *            the new value
+     */
     public void setCaption(String caption) {
         this.caption = caption;
     }
 
+    /**
+     * The required {@code placeholder}; if null, no particular placeholder is
+     * matched.
+     *
+     * @return the current value
+     */
     public String getPlaceholder() {
         return placeholder;
     }
 
+    /**
+     * The required {@code placeholder}; if null, no particular placeholder is
+     * matched.
+     *
+     * @param placeholder
+     *            the new value
+     */
     public void setPlaceholder(String placeholder) {
         this.placeholder = placeholder;
     }
 
+    /**
+     * The {@code com.vaadin.flow.dom.Element.getText}
+     *
+     * @return the current value
+     */
     public String getText() {
         return text;
     }
 
+    /**
+     * The {@code com.vaadin.flow.dom.Element.getText}
+     *
+     * @param text
+     *            the new value
+     */
     public void setText(String text) {
         this.text = text;
     }
 
+    /**
+     * The number of components the lookup accepts.
+     *
+     * @return the current value
+     */
     public CountRange getCount() {
         return count;
     }
 
+    /**
+     * The number of components the lookup accepts.
+     *
+     * @param count
+     *            the new value
+     */
     public void setCount(CountRange count) {
         this.count = count;
     }
 
+    /**
+     * Expected {@code com.vaadin.flow.component.HasValue.getValue}; if
+     * {@code null}, no particular value is matched.
+     *
+     * @return the current value
+     */
     public Object getValue() {
         return value;
     }
 
+    /**
+     * Expected {@code com.vaadin.flow.component.HasValue.getValue}; if
+     * {@code null}, no particular value is matched.
+     *
+     * @param value
+     *            the new value
+     */
     public void setValue(Object value) {
         this.value = value;
     }
 
+    /**
+     * If not null, the component must match all of these class names.
+     * Space-separated.
+     *
+     * @return the current value
+     */
     public String getClasses() {
         return classes;
     }
 
+    /**
+     * If not null, the component must match all of these class names.
+     * Space-separated.
+     *
+     * @param classes
+     *            the new value
+     */
     public void setClasses(String classes) {
         this.classes = classes;
     }
 
+    /**
+     * If not null, the component must NOT match any of these class names.
+     * Space-separated.
+     *
+     * @return the current value
+     */
     public String getWithoutClasses() {
         return withoutClasses;
     }
 
+    /**
+     * If not null, the component must NOT match any of these class names.
+     * Space-separated.
+     *
+     * @param withoutClasses
+     *            the new value
+     */
     public void setWithoutClasses(String withoutClasses) {
         this.withoutClasses = withoutClasses;
     }
 
+    /**
+     * Extra predicates the component must satisfy, on top of the other rules.
+     *
+     * @return the current value
+     */
     public List<Predicate<T>> getPredicates() {
         return predicates;
     }
 
+    /**
+     * Extra predicates the component must satisfy, on top of the other rules.
+     *
+     * @param predicates
+     *            the new value
+     */
     public void setPredicates(List<Predicate<T>> predicates) {
         this.predicates = predicates;
     }
 
+    /**
+     * If not null, the component must have all theme names defined.
+     * Space-separated.
+     *
+     * @return the current value
+     */
     public String getThemes() {
         return themes;
     }
 
+    /**
+     * If not null, the component must have all theme names defined.
+     * Space-separated.
+     *
+     * @param themes
+     *            the new value
+     */
     public void setThemes(String themes) {
         this.themes = themes;
     }
 
+    /**
+     * If not null, the component must NOT have any of the theme names defined.
+     * Space-separated.
+     *
+     * @return the current value
+     */
     public String getWithoutThemes() {
         return withoutThemes;
     }
 
+    /**
+     * If not null, the component must NOT have any of the theme names defined.
+     * Space-separated.
+     *
+     * @param withoutThemes
+     *            the new value
+     */
     public void setWithoutThemes(String withoutThemes) {
         this.withoutThemes = withoutThemes;
     }
 
     /**
      * Makes sure that the component's caption contains given {@code substring}.
+     *
+     * @param substring
+     *            the substring the caption must contain
      */
     public void captionContains(String substring) {
         predicates.add(new CaptionContainsPredicate<>(substring));
@@ -276,6 +441,8 @@ public String toString() {
      * Returns a predicate which matches components based on this spec. All
      * rules are matched except the count rule. The rules are matched against
      * given component only (not against its children).
+     *
+     * @return a predicate which matches components based on this spec
      */
     @SuppressWarnings("unchecked")
     public Predicate<Component> toPredicate() {
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java b/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
index 7c83926e..c22617e6 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
@@ -32,11 +32,35 @@
  */
 public final class SessionObjects {
 
+    /**
+     * The session.
+     */
     public final VaadinSession session;
+    /**
+     * The request bound to the session.
+     */
     public final VaadinRequest request;
+    /**
+     * The response bound to the session.
+     */
     public final VaadinResponse response;
+    /**
+     * The HTTP session the Vaadin session is stored in.
+     */
     public final MockHttpSession httpSession;
 
+    /**
+     * Groups the four objects that make up one mocked user's session.
+     *
+     * @param session
+     *            the session
+     * @param request
+     *            the request bound to the session
+     * @param response
+     *            the response bound to the session
+     * @param httpSession
+     *            the HTTP session the Vaadin session is stored in
+     */
     public SessionObjects(VaadinSession session, VaadinRequest request,
             VaadinResponse response, MockHttpSession httpSession) {
         this.session = session;
@@ -45,22 +69,56 @@ public SessionObjects(VaadinSession session, VaadinRequest request,
         this.httpSession = httpSession;
     }
 
+    /**
+     * Returns the session.
+     *
+     * @return the session
+     */
     public VaadinSession getSession() {
         return session;
     }
 
+    /**
+     * Returns the request bound to the session.
+     *
+     * @return the request
+     */
     public VaadinRequest getRequest() {
         return request;
     }
 
+    /**
+     * Returns the response bound to the session.
+     *
+     * @return the response
+     */
     public VaadinResponse getResponse() {
         return response;
     }
 
+    /**
+     * Returns the HTTP session the Vaadin session is stored in.
+     *
+     * @return the HTTP session
+     */
     public MockHttpSession getHttpSession() {
         return httpSession;
     }
 
+    /**
+     * Returns a copy of this group with the given objects in place of the
+     * current ones.
+     *
+     * @param session
+     *            the session
+     * @param request
+     *            the request bound to the session
+     * @param response
+     *            the response bound to the session
+     * @param httpSession
+     *            the HTTP session the Vaadin session is stored in
+     * @return the new group
+     */
     public SessionObjects copy(VaadinSession session, VaadinRequest request,
             VaadinResponse response, MockHttpSession httpSession) {
         return new SessionObjects(session, request, response, httpSession);
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java b/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
index e92738fc..2b31f6f5 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
@@ -150,6 +150,11 @@ public boolean booleanValue() {
      * the current UI. This will in turn notify all components currently
      * attached to the current UI which subscribed for this exact key
      * combination.
+     *
+     * @param key
+     *            the key that was pressed
+     * @param modifiers
+     *            the key modifiers held down
      */
     public static void fireShortcut(Key key, Key... modifiers) {
         // keep the modifiers of type Key[] instead of KeyModifier[], otherwise
@@ -162,6 +167,13 @@ public static void fireShortcut(Key key, Key... modifiers) {
     /**
      * Use the global `fireShortcut()` function unless you know what you're
      * doing!
+     *
+     * @param component
+     *            the component the shortcut is fired on
+     * @param key
+     *            the key that was pressed
+     * @param modifiers
+     *            the key modifiers held down
      */
     public static void _fireShortcut(Component component, Key key,
             Key... modifiers) {
@@ -185,7 +197,7 @@ public static void _fireShortcut(Component component, Key key,
         MockFilterJsonObject data = new MockFilterJsonObject(key, modifierSet);
 
         // the shortcut registration is only updated in
-        // [UI.beforeClientResponse]; run the registration code now.
+        // UI.beforeClientResponse(); run the registration code now.
         MockVaadin.clientRoundtrip();
 
         // this will fire the "keydown" DOM event, which in turn fires
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java b/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
index d1e4d827..7a18c525 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
@@ -37,5 +37,10 @@
  */
 @FunctionalInterface
 public interface UIFactory extends Serializable {
+    /**
+     * Creates a new UI instance.
+     *
+     * @return the new UI; must be a fresh instance every time
+     */
     UI invoke();
 }
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/Utils.java b/shared/src/main/java/com/vaadin/browserless/internal/Utils.java
index 3c77514e..0fce6bda 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/Utils.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Utils.java
@@ -58,6 +58,8 @@ private Utils() {
     /**
      * Returns the major JVM version, e.g. 6 for Java 1.6, 8 for Java 8, 11 for
      * Java 11 etc.
+     *
+     * @return the major JVM version, e.g
      */
     public static int jvmVersion() {
         return parseJvmVersion(System.getProperty("java.version"));
@@ -133,6 +135,13 @@ static boolean isRouteNotFound(Class<?> clazz) {
         return getErrorParameterType(clazz) == NotFoundException.class;
     }
 
+    /**
+     * Returns the current request.
+     *
+     * @return the current request, never null
+     * @throws IllegalStateException
+     *             if no request is bound to the current thread
+     */
     public static VaadinRequest currentRequest() {
         VaadinRequest req = VaadinService.getCurrentRequest();
         if (req == null) {
@@ -142,6 +151,13 @@ public static VaadinRequest currentRequest() {
         return req;
     }
 
+    /**
+     * Returns the current response.
+     *
+     * @return the current response, never null
+     * @throws IllegalStateException
+     *             if no response is bound to the current thread
+     */
     public static VaadinResponse currentResponse() {
         VaadinResponse resp = VaadinService.getCurrentResponse();
         if (resp == null) {
@@ -154,6 +170,9 @@ public static VaadinResponse currentResponse() {
     /**
      * Returns the {@link UI#getCurrent}; fails with informative error message
      * if the UI.getCurrent() is null.
+     *
+     * @return the {@link UI#getCurrent}; fails with informative error message
+     *         if the UI.getCurrent() is null
      */
     public static UI currentUI() {
         UI ui = UI.getCurrent();
@@ -167,6 +186,10 @@ public static UI currentUI() {
     /**
      * Retrieves the mock request which backs up {@link VaadinRequest}. ```
      * currentRequest.mock.addCookie(Cookie("foo", "bar")) ```
+     *
+     * @param request
+     *            the request to act on
+     * @return the mock request which backs up {@link VaadinRequest}
      */
     public static MockRequest mock(VaadinRequest request) {
         return (MockRequest) ((VaadinServletRequest) request).getRequest();
@@ -175,6 +198,10 @@ public static MockRequest mock(VaadinRequest request) {
     /**
      * Retrieves the mock response which backs up {@link VaadinResponse}. ```
      * currentResponse.mock.getCookie("foo").value ```
+     *
+     * @param response
+     *            the response to act on
+     * @return the mock response which backs up {@link VaadinResponse}
      */
     public static MockResponse mock(VaadinResponse response) {
         return (MockResponse) ((VaadinServletResponse) response).getResponse();
@@ -183,16 +210,34 @@ public static MockResponse mock(VaadinResponse response) {
     /**
      * Retrieves the mock session which backs up {@link VaadinSession}. ```
      * VaadinSession.getCurrent().mock ```
+     *
+     * @param session
+     *            the session to act on
+     * @return the mock session which backs up {@link VaadinSession}
      */
     public static MockHttpSession mock(VaadinSession session) {
         return (MockHttpSession) ((WrappedHttpSession) session.getSession())
                 .getHttpSession();
     }
 
+    /**
+     * Returns the servlet context behind a Vaadin context.
+     *
+     * @param context
+     *            the Vaadin context
+     * @return the servlet context
+     */
     public static ServletContext getContext(VaadinContext context) {
         return ((VaadinServletContext) context).getContext();
     }
 
+    /**
+     * Returns whether the servlet has been initialized.
+     *
+     * @param servlet
+     *            the servlet to check
+     * @return {@code true} if the servlet has a servlet config
+     */
     public static boolean isInitialized(Servlet servlet) {
         return servlet.getServletConfig() != null;
     }
@@ -213,6 +258,13 @@ static boolean hasPolymerTemplates() {
         return polymerTemplateClass != null;
     }
 
+    /**
+     * Loads a class by name.
+     *
+     * @param className
+     *            the fully qualified class name
+     * @return the class, or null if it is not on the classpath
+     */
     public static Class<?> findClass(String className) {
         try {
             return Class.forName(className);
@@ -226,6 +278,15 @@ public static Class<?> findClass(String className) {
         }
     }
 
+    /**
+     * Loads a class by name.
+     *
+     * @param className
+     *            the fully qualified class name
+     * @return the class, never null
+     * @throws ClassNotFoundException
+     *             if the class is not on the classpath
+     */
     public static Class<?> findClassOrThrow(String className)
             throws ClassNotFoundException {
         Class<?> clazz = findClass(className);
diff --git a/shared/src/main/java/com/vaadin/browserless/locator/HasAriaLabelFilter.java b/shared/src/main/java/com/vaadin/browserless/locator/HasAriaLabelFilter.java
index 90a7bb6f..96b0e87e 100644
--- a/shared/src/main/java/com/vaadin/browserless/locator/HasAriaLabelFilter.java
+++ b/shared/src/main/java/com/vaadin/browserless/locator/HasAriaLabelFilter.java
@@ -36,6 +36,10 @@ public interface HasAriaLabelFilter<C extends Component & HasAriaLabel, SELF ext
     /**
      * Requires the matched component's {@code aria-label} attribute to be
      * exactly the given value.
+     *
+     * @param ariaLabel
+     *            the expected ARIA label
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withAriaLabel(String ariaLabel) {
@@ -46,6 +50,10 @@ default SELF withAriaLabel(String ariaLabel) {
     /**
      * Requires the matched component's {@code aria-label} attribute to contain
      * the given text.
+     *
+     * @param text
+     *            the expected text
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withAriaLabelContaining(String text) {
diff --git a/shared/src/main/java/com/vaadin/browserless/locator/HasLabelFilter.java b/shared/src/main/java/com/vaadin/browserless/locator/HasLabelFilter.java
index 6640abc6..1243061a 100644
--- a/shared/src/main/java/com/vaadin/browserless/locator/HasLabelFilter.java
+++ b/shared/src/main/java/com/vaadin/browserless/locator/HasLabelFilter.java
@@ -39,6 +39,10 @@ public interface HasLabelFilter<C extends Component & HasLabel, SELF extends Loc
      * Requires the matched component's {@code label} property to be exactly the
      * given value. Use this for form fields where the end user identifies a
      * field by its label.
+     *
+     * @param label
+     *            the expected label
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withLabel(String label) {
@@ -48,6 +52,10 @@ default SELF withLabel(String label) {
     /**
      * Requires the matched component's {@code label} property to contain the
      * given text.
+     *
+     * @param text
+     *            the expected text
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withLabelContaining(String text) {
diff --git a/shared/src/main/java/com/vaadin/browserless/locator/HasPlaceholderFilter.java b/shared/src/main/java/com/vaadin/browserless/locator/HasPlaceholderFilter.java
index 249022ed..cf0dbaaf 100644
--- a/shared/src/main/java/com/vaadin/browserless/locator/HasPlaceholderFilter.java
+++ b/shared/src/main/java/com/vaadin/browserless/locator/HasPlaceholderFilter.java
@@ -38,6 +38,10 @@ public interface HasPlaceholderFilter<C extends Component & HasPlaceholder, SELF
      * given value. Useful for toolbar / search fields that intentionally omit a
      * stacked label and identify themselves to the user via placeholder text
      * instead.
+     *
+     * @param placeholder
+     *            the expected placeholder
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withPlaceholder(String placeholder) {
@@ -48,6 +52,10 @@ default SELF withPlaceholder(String placeholder) {
     /**
      * Requires the matched component's {@code placeholder} to contain the given
      * text.
+     *
+     * @param text
+     *            the expected text
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withPlaceholderContaining(String text) {
diff --git a/shared/src/main/java/com/vaadin/browserless/locator/HasTextFilter.java b/shared/src/main/java/com/vaadin/browserless/locator/HasTextFilter.java
index dccf5ef2..223e1617 100644
--- a/shared/src/main/java/com/vaadin/browserless/locator/HasTextFilter.java
+++ b/shared/src/main/java/com/vaadin/browserless/locator/HasTextFilter.java
@@ -35,13 +35,25 @@
  */
 public interface HasTextFilter<C extends Component & HasText, SELF extends Locator<C, SELF>> {
 
-    /** Requires the text content of the component to equal the given text. */
+    /**
+     * Requires the text content of the component to equal the given text.
+     *
+     * @param text
+     *            the text the component must have
+     * @return this locator, for chaining
+     */
     @SuppressWarnings("unchecked")
     default SELF withText(String text) {
         return ((Locator<C, SELF>) this).applyFilter(q -> q.withText(text));
     }
 
-    /** Requires the text content of the component to contain the given text. */
+    /**
+     * Requires the text content of the component to contain the given text.
+     *
+     * @param text
+     *            the text the component's text must contain
+     * @return this locator, for chaining
+     */
     @SuppressWarnings("unchecked")
     default SELF withTextContaining(String text) {
         return ((Locator<C, SELF>) this)
diff --git a/shared/src/main/java/com/vaadin/browserless/locator/HasThemeFilter.java b/shared/src/main/java/com/vaadin/browserless/locator/HasThemeFilter.java
index fd22c54f..bce35b94 100644
--- a/shared/src/main/java/com/vaadin/browserless/locator/HasThemeFilter.java
+++ b/shared/src/main/java/com/vaadin/browserless/locator/HasThemeFilter.java
@@ -42,6 +42,10 @@ public interface HasThemeFilter<C extends Component & HasTheme, SELF extends Loc
      * <pre>{@code
      * ui.findButton().withTheme(ButtonVariant.LUMO_PRIMARY).click();
      * }</pre>
+     *
+     * @param variant
+     *            the theme variant
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withTheme(ThemeVariant variant) {
@@ -51,6 +55,9 @@ default SELF withTheme(ThemeVariant variant) {
     /**
      * Requires the matched component to have the given theme set.
      *
+     * @param theme
+     *            the theme name
+     * @return this locator, for chaining
      * @deprecated use {@link #withTheme(ThemeVariant)} with the component's
      *             typed variant enum where possible. This raw-string overload
      *             remains for themes not surfaced through a {@code
@@ -66,6 +73,10 @@ default SELF withTheme(String theme) {
      * Requires the matched component to not have the given theme variant set.
      * Prefer this over the raw-string {@link #withoutTheme(String)} for the
      * same reasons as {@link #withTheme(ThemeVariant)}.
+     *
+     * @param variant
+     *            the theme variant
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withoutTheme(ThemeVariant variant) {
@@ -76,6 +87,9 @@ default SELF withoutTheme(ThemeVariant variant) {
     /**
      * Requires the matched component to not have the given theme set.
      *
+     * @param theme
+     *            the theme name
+     * @return this locator, for chaining
      * @deprecated use {@link #withoutTheme(ThemeVariant)} with the component's
      *             typed variant enum where possible.
      */
diff --git a/shared/src/main/java/com/vaadin/browserless/locator/HasValueFilter.java b/shared/src/main/java/com/vaadin/browserless/locator/HasValueFilter.java
index 0527e40b..bb9be3c9 100644
--- a/shared/src/main/java/com/vaadin/browserless/locator/HasValueFilter.java
+++ b/shared/src/main/java/com/vaadin/browserless/locator/HasValueFilter.java
@@ -47,6 +47,10 @@ public interface HasValueFilter<C extends Component & HasValue<?, V>, V, SELF ex
      * Requires the matched component to implement {@code HasValue} and to have
      * the given value. Has no effect when {@code expectedValue} is
      * {@code null}.
+     *
+     * @param expectedValue
+     *            the value the component must have
+     * @return this locator, for chaining
      */
     @SuppressWarnings("unchecked")
     default SELF withValue(V expectedValue) {
diff --git a/shared/src/main/java/com/vaadin/browserless/locator/Locator.java b/shared/src/main/java/com/vaadin/browserless/locator/Locator.java
index 00c839c6..1492a3e9 100644
--- a/shared/src/main/java/com/vaadin/browserless/locator/Locator.java
+++ b/shared/src/main/java/com/vaadin/browserless/locator/Locator.java
@@ -101,7 +101,13 @@ protected Locator(Class<C> componentType, C component) {
                 .withCondition(c -> c == component);
     }
 
-    /** Requires the matched component to have the given id. */
+    /**
+     * Requires the matched component to have the given id.
+     *
+     * @param id
+     *            the expected component id
+     * @return this locator, for chaining
+     */
     public SELF withId(String id) {
         resetCache();
         query.withId(id);
@@ -112,6 +118,10 @@ public SELF withId(String id) {
      * Requires the matched component to have the given {@code data-testid}
      * attribute, as set by
      * {@link com.vaadin.flow.component.Component#setTestId(String)}.
+     *
+     * @param testId
+     *            the expected {@code data-testid} value
+     * @return this locator, for chaining
      */
     public SELF withTestId(String testId) {
         resetCache();
@@ -119,7 +129,13 @@ public SELF withTestId(String testId) {
         return self();
     }
 
-    /** Requires the matched component to have all the given CSS class names. */
+    /**
+     * Requires the matched component to have all the given CSS class names.
+     *
+     * @param className
+     *            the CSS class names the component must have
+     * @return this locator, for chaining
+     */
     public SELF withClassName(String... className) {
         resetCache();
         query.withClassName(className);
@@ -128,6 +144,10 @@ public SELF withClassName(String... className) {
 
     /**
      * Requires the matched component to have none of the given CSS class names.
+     *
+     * @param className
+     *            the CSS class names the component must not have
+     * @return this locator, for chaining
      */
     public SELF withoutClassName(String... className) {
         resetCache();
@@ -135,7 +155,13 @@ public SELF withoutClassName(String... className) {
         return self();
     }
 
-    /** Requires the matched component to have the given attribute set. */
+    /**
+     * Requires the matched component to have the given attribute set.
+     *
+     * @param attribute
+     *            the attribute that must be present
+     * @return this locator, for chaining
+     */
     public SELF withAttribute(String attribute) {
         resetCache();
         query.withAttribute(attribute);
@@ -145,6 +171,12 @@ public SELF withAttribute(String attribute) {
     /**
      * Requires the matched component to have the given attribute with the
      * expected value.
+     *
+     * @param attribute
+     *            the attribute that must be present
+     * @param value
+     *            the value the attribute must have
+     * @return this locator, for chaining
      */
     public SELF withAttribute(String attribute, String value) {
         resetCache();
@@ -152,7 +184,13 @@ public SELF withAttribute(String attribute, String value) {
         return self();
     }
 
-    /** Requires the matched component not to have the given attribute. */
+    /**
+     * Requires the matched component not to have the given attribute.
+     *
+     * @param attribute
+     *            the attribute that must be absent
+     * @return this locator, for chaining
+     */
     public SELF withoutAttribute(String attribute) {
         resetCache();
         query.withoutAttribute(attribute);
@@ -162,6 +200,12 @@ public SELF withoutAttribute(String attribute) {
     /**
      * Requires the matched component not to have the given attribute value (or
      * not to have the attribute at all).
+     *
+     * @param attribute
+     *            the attribute to check
+     * @param value
+     *            the value the attribute must not have
+     * @return this locator, for chaining
      */
     public SELF withoutAttribute(String attribute, String value) {
         resetCache();
@@ -180,6 +224,9 @@ public SELF withoutAttribute(String attribute, String value) {
      * names are component specific — see
      * {@link ComponentQuery#withinSlot(String)} for annotated component trees.
      *
+     * @param slot
+     *            the name of the slot the component must sit in
+     * @return this locator, for chaining
      * @see ComponentQuery#withinSlot(String)
      */
     public SELF withinSlot(String slot) {
@@ -188,7 +235,13 @@ public SELF withinSlot(String slot) {
         return self();
     }
 
-    /** Requires the matched component to satisfy the given predicate. */
+    /**
+     * Requires the matched component to satisfy the given predicate.
+     *
+     * @param condition
+     *            the predicate the component must satisfy
+     * @return this locator, for chaining
+     */
     public SELF withCondition(Predicate<C> condition) {
         resetCache();
         query.withCondition(condition);
@@ -211,6 +264,9 @@ public SELF withCondition(Predicate<C> condition) {
      * fluent chain just re-installs the same instance; an operator that builds
      * and returns a fresh query replaces the prior one wholesale.
      *
+     * @param op
+     *            the operator applied to the underlying query
+     * @return this locator, for chaining
      * @throws IllegalStateException
      *             if the operator returns {@code null} instead of a
      *             {@code ComponentQuery} — the operator is expected either to
@@ -235,6 +291,10 @@ public SELF with(UnaryOperator<ComponentQuery<C>> op) {
      * Scopes the search to descendants of the given component. Replaces any
      * lazy parent previously installed by {@link #inside(Locator)} with a fixed
      * reference.
+     *
+     * @param parent
+     *            the component whose descendants are searched
+     * @return this locator, for chaining
      */
     public SELF inside(Component parent) {
         resetCache();
@@ -256,6 +316,10 @@ public SELF inside(Component parent) {
      * fixed reference; calling {@code inside(Locator)} again replaces the lazy
      * parent.
      *
+     * @param parent
+     *            the locator matching the component whose descendants are
+     *            searched
+     * @return this locator, for chaining
      * @throws NullPointerException
      *             if {@code parent} is {@code null}
      * @throws IllegalArgumentException
@@ -277,6 +341,9 @@ public SELF inside(Locator<?, ?> parent) {
      * Picks the n-th match (1-based) when the filter chain yields multiple
      * matches. Without this, the default expectation is exactly one match.
      *
+     * @param index
+     *            the 1-based index of the match to pick
+     * @return this locator, for chaining
      * @throws IllegalArgumentException
      *             if {@code index} is zero or negative — mirrors
      *             {@link ComponentQuery#atIndex(int)}'s own contract, so the
@@ -314,6 +381,8 @@ public C component() {
     /**
      * Returns all matching components, bypassing the cache. Useful for
      * assertions on counts without committing to a single match.
+     *
+     * @return every component the filter chain matches
      */
     public List<C> components() {
         prepareQueryContext();
@@ -322,6 +391,8 @@ public List<C> components() {
 
     /**
      * Returns {@code true} if the filter chain matches at least one component.
+     *
+     * @return {@code true} if at least one component matches
      */
     public boolean exists() {
         prepareQueryContext();
@@ -338,6 +409,8 @@ public boolean exists() {
      * action to re-resolve, and also drops the pick so the next resolution
      * defaults back to "single match expected" until the caller re-applies
      * {@link #atIndex(int)}.
+     *
+     * @return this locator, for chaining
      */
     public SELF invalidate() {
         resetCache();
@@ -371,6 +444,12 @@ private void prepareQueryContext() {
         }
     }
 
+    /**
+     * Returns this locator, typed as the concrete subtype, so the filter steps
+     * can chain fluently.
+     *
+     * @return this locator
+     */
     @SuppressWarnings("unchecked")
     protected SELF self() {
         return (SELF) this;
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java
index 076b4801..84c21eaf 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java
@@ -76,6 +76,12 @@
  */
 public class MockContext implements ServletContext, Serializable {
 
+    /**
+     * Creates an empty context.
+     */
+    public MockContext() {
+    }
+
     private static final Logger LOG = LoggerFactory
             .getLogger(MockContext.class);
 
@@ -245,6 +251,9 @@ public <T extends Filter> T createFilter(Class<T> clazz) {
         throw new UnsupportedOperationException("not implemented");
     }
 
+    /**
+     * The directories {@link #getRealPath} resolves paths against.
+     */
     private List<String> realPathRoots = Arrays
             .asList("src/main/webapp/frontend", "src/main/webapp");
 
@@ -291,6 +300,9 @@ public String getRealPath(String path) {
         return null;
     }
 
+    /**
+     * The context init parameters.
+     */
     private final Map<String, String> initParameters = new HashMap<>();
 
     /**
@@ -367,6 +379,9 @@ public String getVirtualServerName() {
         return "mock/localhost"; // Tomcat returns "Catalina/localhost"
     }
 
+    /**
+     * The session timeout, in minutes.
+     */
     private int sessionTimeout = 30;
 
     @Override
@@ -379,6 +394,9 @@ public void setSessionTimeout(int sessionTimeout) {
         this.sessionTimeout = sessionTimeout;
     }
 
+    /**
+     * The character encoding requests default to.
+     */
     private String requestCharacterEncoding = null;
 
     @Override
@@ -391,6 +409,9 @@ public void setRequestCharacterEncoding(String encoding) {
         this.requestCharacterEncoding = encoding;
     }
 
+    /**
+     * The character encoding responses default to.
+     */
     private String responseCharacterEncoding = null;
 
     @Override
@@ -413,6 +434,9 @@ public RequestDispatcher getRequestDispatcher(String path) {
         throw new UnsupportedOperationException("not implemented");
     }
 
+    /**
+     * The context attributes.
+     */
     private final ConcurrentHashMap<String, Object> attributes = new ConcurrentHashMap<>();
 
     @Override
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java
index 2d7dcfe0..9df84dac 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java
@@ -46,12 +46,30 @@
  */
 public class MockHttpSession implements HttpSession, Serializable {
 
+    /**
+     * The session id, which {@link #changeSessionId} rotates.
+     */
     private volatile String sessionId;
+    /**
+     * The context the session belongs to.
+     */
     private final ServletContext servletContext;
+    /**
+     * When the session was created.
+     */
     private final long creationTime;
+    /**
+     * The inactivity timeout, in seconds.
+     */
     private int maxInactiveInterval;
 
+    /**
+     * The session attributes.
+     */
     private final ConcurrentHashMap<String, Object> attributes = new ConcurrentHashMap<>();
+    /**
+     * Whether the session is still valid; {@link #invalidate} clears it.
+     */
     private final AtomicBoolean valid = new AtomicBoolean(true);
 
     /**
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java
index cd645fae..d4b9741d 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java
@@ -58,6 +58,9 @@
 @Deprecated(forRemoval = true)
 public class MockInstantiator implements Instantiator {
 
+    /**
+     * The instantiator the calls are forwarded to.
+     */
     private final Instantiator delegate;
 
     /**
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java
index 2b9220f9..17cb46b6 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java
@@ -490,6 +490,12 @@ public void setCookiesInt(Cookie[] cookiesInt) {
         this.cookiesInt = cookiesInt;
     }
 
+    /**
+     * Adds a cookie to the request, as the browser would send it.
+     *
+     * @param cookie
+     *            the cookie to add
+     */
     public void addCookie(Cookie cookie) {
         if (cookiesInt == null) {
             cookiesInt = new Cookie[] { cookie };
@@ -738,6 +744,15 @@ public boolean isSecure() {
         return MockHttpEnvironment.isSecure();
     }
 
+    /**
+     * Equivalent to
+     * {@code parameters.put(name, Arrays.copyOf(values, values.length))}.
+     *
+     * @param name
+     *            the attribute name
+     * @param values
+     *            the values of the parameter
+     */
     public void setParameter(String name, String... values) {
         parameters.put(name, Arrays.copyOf(values, values.length));
     }
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java
index 3c828587..77d3588f 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java
@@ -49,6 +49,12 @@
  */
 public class MockResponse implements HttpServletResponse {
 
+    /**
+     * Creates an empty response.
+     */
+    public MockResponse() {
+    }
+
     @Override
     public String encodeURL(String url) {
         return url;
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java
index 4c641ef8..7cb96e1b 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java
@@ -51,6 +51,9 @@
  */
 public class MockService extends VaadinServletService {
 
+    /**
+     * Produces the UI instances the sessions of this service hand out.
+     */
     private final UIFactory uiFactory;
 
     /**
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java
index c4434b3a..ebd2511a 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java
@@ -56,8 +56,14 @@
  */
 public class MockVaadinServlet extends VaadinServlet {
 
+    /**
+     * The routes registered when the service is created.
+     */
     private final Routes routes;
 
+    /**
+     * Produces the UI instances the sessions of this servlet hand out.
+     */
     private final UIFactory uiFactory;
 
     /**
@@ -174,6 +180,10 @@ private static Constructor<?> findTwoArgConstructor(Class<?> cls) {
 
     /**
      * Workaround for https://github.com/mvysny/karibu-testing/issues/66
+     *
+     * @param servlet
+     *            the servlet to act on
+     * @return the servlet's service, initializing the servlet first if needed
      */
     public static VaadinServletService serviceSafe(VaadinServlet servlet) {
         // we need to use the reflection. The problem is that the signature
@@ -194,6 +204,12 @@ public static VaadinServletService serviceSafe(VaadinServlet servlet) {
 
     /**
      * Workaround for https://github.com/mvysny/karibu-testing/issues/66
+     *
+     * @param request
+     *            the request to act on
+     * @param service
+     *            the service to act on
+     * @return a request bound to the given servlet's service
      */
     public static VaadinServletRequest createVaadinServletRequest(
             HttpServletRequest request, VaadinService service) {
@@ -215,6 +231,12 @@ public static VaadinServletRequest createVaadinServletRequest(
 
     /**
      * Workaround for https://github.com/mvysny/karibu-testing/issues/66
+     *
+     * @param response
+     *            the response to act on
+     * @param service
+     *            the service to act on
+     * @return a response bound to the given servlet's service
      */
     public static VaadinServletResponse createVaadinServletResponse(
             HttpServletResponse response, VaadinService service) {
@@ -234,6 +256,14 @@ public static VaadinServletResponse createVaadinServletResponse(
         }
     }
 
+    /**
+     * Creates the browser details the session reports, describing a desktop
+     * Firefox.
+     *
+     * @param request
+     *            the request the browser details are taken from
+     * @return the browser details
+     */
     public static WebBrowser createWebBrowser(VaadinRequest request) {
         try {
             return _WebBrowser_constructor.newInstance(request);
@@ -242,6 +272,15 @@ public static WebBrowser createWebBrowser(VaadinRequest request) {
         }
     }
 
+    /**
+     * Creates a session, locks it and binds it to the request.
+     *
+     * @param service
+     *            the service the session belongs to
+     * @param request
+     *            the request the session is bound to
+     * @return the new session, already locked
+     */
     public static VaadinSession createVaadinSession(VaadinService service,
             VaadinRequest request) {
         try {
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java
index a1b238f1..4bdee8b1 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java
@@ -36,6 +36,9 @@
  */
 public class MockVaadinSession extends VaadinSession {
 
+    /**
+     * Produces the UI instances this session hands out.
+     */
     private final UIFactory uiFactory;
 
     /**
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java b/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
index 61dfe2e5..d0685c0b 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
@@ -44,6 +44,12 @@
  */
 public class MockedUI extends UI {
 
+    /**
+     * Creates the UI.
+     */
+    public MockedUI() {
+    }
+
     /** {@link Location} keeps its own copies of these package private. */
     private static final String QUERY_SEPARATOR = "?";
 
diff --git a/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java b/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java
index 9b5c7f34..a827a706 100644
--- a/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java
@@ -38,6 +38,12 @@ public class SessionAttributeMap extends AbstractMap<String, Object> {
     private final HttpSession session;
     private final Set<Entry<String, Object>> entries;
 
+    /**
+     * Exposes the given session's attributes as a map.
+     *
+     * @param session
+     *            the session to wrap
+     */
     public SessionAttributeMap(HttpSession session) {
         this.session = session;
         this.entries = new SessionAttributeEntrySet(session);
diff --git a/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java b/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java
index 2a234093..a48cf4c8 100644
--- a/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java
@@ -21,6 +21,10 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Accordion components.
+ *
+ * @param <T>
+ *            component type
  * @since 1.0
  */
 @Tests(Accordion.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java b/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java
index 38e6d721..41d5dbe7 100644
--- a/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/avatar/AvatarGroupTester.java
@@ -119,9 +119,11 @@ public String getOverflowAbbreviation() {
 
     /**
      * Gets the accessible label of the group, that is, the
-     * {@link AvatarGroupI18n#setOneActiveUser(String) one} or
-     * {@link AvatarGroupI18n#setManyActiveUsers(String) many} active users
-     * phrase with {@code {count}} replaced by the total number of items.
+     * {@link com.vaadin.flow.component.avatar.AvatarGroup.AvatarGroupI18n#setOneActiveUser(String)
+     * one} or
+     * {@link com.vaadin.flow.component.avatar.AvatarGroup.AvatarGroupI18n#setManyActiveUsers(String)
+     * many} active users phrase with {@code {count}} replaced by the total
+     * number of items.
      *
      * @return the accessible label, or {@code null} if no matching translation
      *         has been set on the component
diff --git a/shared/src/main/java/com/vaadin/flow/component/breadcrumbs/BreadcrumbsTester.java b/shared/src/main/java/com/vaadin/flow/component/breadcrumbs/BreadcrumbsTester.java
index a42daf31..9bab1782 100644
--- a/shared/src/main/java/com/vaadin/flow/component/breadcrumbs/BreadcrumbsTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/breadcrumbs/BreadcrumbsTester.java
@@ -24,6 +24,10 @@
 import com.vaadin.flow.component.UI;
 
 /**
+ * Tester for Breadcrumbs components.
+ *
+ * @param <T>
+ *            component type
  * @since 1.1
  */
 @Tests(Breadcrumbs.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java b/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java
index ed611ca2..0192b788 100644
--- a/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/card/CardTester.java
@@ -113,12 +113,15 @@ public Component getSubtitle() {
     /**
      * Gets the subtitle text shown on the card.
      * <p>
-     * {@link Card#setSubtitle(String)} wraps the text in a {@link Span}, so a
-     * subtitle set as text is reported here, and so is the text of a
-     * {@link Span} set with {@link Card#setSubtitle(Component)} — the card
-     * stores the two the same way and cannot tell them apart. A subtitle set as
-     * any other component is not text and reports {@code null}; use
-     * {@link #getSubtitle()} to get the component itself.
+     * {@link Card#setSubtitle(String)} wraps the text in a
+     * {@link com.vaadin.flow.component.html.Span Span}, so a subtitle set as
+     * text is reported here, and so is the text of a
+     * {@link com.vaadin.flow.component.html.Span Span} set with
+     * {@link Card#setSubtitle(com.vaadin.flow.component.Component)
+     * Card.setSubtitle(Component)} — the card stores the two the same way and
+     * cannot tell them apart. A subtitle set as any other component is not text
+     * and reports {@code null}; use {@link #getSubtitle()} to get the component
+     * itself.
      * <p>
      * Note that this differs from {@link #getTitleAsText()}, which reports an
      * empty string rather than {@code null} when the card shows no textual
diff --git a/shared/src/main/java/com/vaadin/flow/component/charts/ChartTester.java b/shared/src/main/java/com/vaadin/flow/component/charts/ChartTester.java
index 1381c7eb..62f632db 100644
--- a/shared/src/main/java/com/vaadin/flow/component/charts/ChartTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/charts/ChartTester.java
@@ -58,12 +58,15 @@ public ChartTester(T component) {
     /**
      * Gets the values for the series at given index.
      *
-     * At the moment only {@link ListSeries}, {@link DataSeries} and
-     * {@link DataProviderSeries} are supported. For all other series types an
+     * At the moment only
+     * {@link com.vaadin.flow.component.charts.model.ListSeries ListSeries},
+     * {@link com.vaadin.flow.component.charts.model.DataSeries DataSeries} and
+     * {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} are supported. For all other series types an
      * exception will be thrown.
      *
-     * For {@link DataProviderSeries} Y value is expected to be a {@link Number}
-     * subtype.
+     * For {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} Y value is expected to be a {@link Number} subtype.
      *
      * @param seriesIndex
      *            zero-based index of the series
@@ -83,12 +86,15 @@ public List<Number> getSeriesValues(int seriesIndex) {
     /**
      * Gets the values for the series with the given name.
      *
-     * At the moment only {@link ListSeries}, {@link DataSeries} and
-     * {@link DataProviderSeries} are supported. For all other series types an
+     * At the moment only
+     * {@link com.vaadin.flow.component.charts.model.ListSeries ListSeries},
+     * {@link com.vaadin.flow.component.charts.model.DataSeries DataSeries} and
+     * {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} are supported. For all other series types an
      * exception will be thrown.
      *
-     * For {@link DataProviderSeries} Y value is expected to be a {@link Number}
-     * subtype.
+     * For {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} Y value is expected to be a {@link Number} subtype.
      *
      * @param seriesName
      *            name of the series
@@ -107,13 +113,20 @@ public List<Number> getSeriesValues(String seriesName) {
      * Gets the value of the point with given name from the series at given
      * index.
      *
-     * The {@code name} depends on the series type. For {@link ListSeries} it is
-     * expected to refer to an X-Axis category, for {@link DataSeries} it refers
-     * to the item name, for {@link DataProviderSeries} it is matched against
-     * the value of the configured {@literal x attribute}.
+     * The {@code name} depends on the series type. For
+     * {@link com.vaadin.flow.component.charts.model.ListSeries ListSeries} it
+     * is expected to refer to an X-Axis category, for
+     * {@link com.vaadin.flow.component.charts.model.DataSeries DataSeries} it
+     * refers to the item name, for
+     * {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} it is matched against the value of the configured
+     * {@literal x attribute}.
      *
-     * At the moment only {@link ListSeries}, {@link DataSeries} and
-     * {@link DataProviderSeries} are supported. For all other series types an
+     * At the moment only
+     * {@link com.vaadin.flow.component.charts.model.ListSeries ListSeries},
+     * {@link com.vaadin.flow.component.charts.model.DataSeries DataSeries} and
+     * {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} are supported. For all other series types an
      * exception will be thrown.
      *
      * @param seriesIndex
@@ -133,13 +146,20 @@ public Number getPointValue(int seriesIndex, String name) {
      * Gets the value of the point with given name from the series at given
      * index.
      *
-     * The {@code name} depends on the series type. For {@link ListSeries} it is
-     * expected to refer to an X-Axis category, for {@link DataSeries} it refers
-     * to the item name, for {@link DataProviderSeries} it is matched against
-     * the value of the configured {@literal x attribute}.
+     * The {@code name} depends on the series type. For
+     * {@link com.vaadin.flow.component.charts.model.ListSeries ListSeries} it
+     * is expected to refer to an X-Axis category, for
+     * {@link com.vaadin.flow.component.charts.model.DataSeries DataSeries} it
+     * refers to the item name, for
+     * {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} it is matched against the value of the configured
+     * {@literal x attribute}.
      *
-     * At the moment only {@link ListSeries}, {@link DataSeries} and
-     * {@link DataProviderSeries} are supported. For all other series types an
+     * At the moment only
+     * {@link com.vaadin.flow.component.charts.model.ListSeries ListSeries},
+     * {@link com.vaadin.flow.component.charts.model.DataSeries DataSeries} and
+     * {@link com.vaadin.flow.component.charts.model.DataProviderSeries
+     * DataProviderSeries} are supported. For all other series types an
      * exception will be thrown.
      *
      * @param seriesName
diff --git a/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java b/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java
index 47fc18a2..d0af3e6f 100644
--- a/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/checkbox/CheckboxGroupTester.java
@@ -37,6 +37,8 @@
  *
  * @param <T>
  *            component type
+ * @param <V>
+ *            the item type
  * @since 1.0
  */
 @Tests(fqn = "com.vaadin.flow.component.checkbox.CheckboxGroup")
diff --git a/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java b/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java
index 26db9be0..d535ab8f 100644
--- a/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java
@@ -30,6 +30,12 @@
 import com.vaadin.flow.function.SerializableConsumer;
 
 /**
+ * Tester for ComboBox components.
+ *
+ * @param <T>
+ *            component type
+ * @param <Y>
+ *            item type
  * @since 1.0
  */
 @Tests(fqn = "com.vaadin.flow.component.combobox.ComboBox")
@@ -47,7 +53,7 @@ public ComboBoxTester(T component) {
 
     /**
      * Simulate writing a filter to the combobox.
-     * <p/>
+     * <p>
      * Use {@link #getSuggestions()} to get the string values show in the
      * dropdown or {@link #getSuggestionItems()} to get the actual items in the
      * suggestion.
@@ -127,7 +133,7 @@ public void selectItem(String selection) {
 
     /**
      * Clears the selection by clicking the clear button, as the user would.
-     * <p/>
+     * <p>
      * Requires the clear button to be visible — a hidden clear button is not
      * something the user can click. {@link #selectItem(String)} with
      * {@code null} clears the selection without that requirement.
diff --git a/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java b/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java
index 2bf7fd00..b060f273 100644
--- a/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/combobox/MultiSelectComboBoxTester.java
@@ -33,6 +33,12 @@
 import com.vaadin.flow.function.SerializableConsumer;
 
 /**
+ * Tester for MultiSelectComboBox components.
+ *
+ * @param <T>
+ *            component type
+ * @param <Y>
+ *            item type
  * @since 1.0
  */
 @Tests(fqn = "com.vaadin.flow.component.combobox.MultiSelectComboBox")
@@ -50,7 +56,7 @@ public MultiSelectComboBoxTester(T component) {
 
     /**
      * Simulate writing a filter to the combobox.
-     * <p/>
+     * <p>
      * Use {@link #getSuggestions()} to get the string values show in the
      * dropdown or {@link #getSuggestionItems()} to get the actual items in the
      * suggestion.
@@ -105,7 +111,7 @@ public void selectItem(String... selection) {
 
     /**
      * Clears the selection by clicking the clear button, as the user would.
-     * <p/>
+     * <p>
      * Requires the clear button to be visible — a hidden clear button is not
      * something the user can click. {@link #selectItem(String...)} with
      * {@code null} clears the selection without that requirement.
diff --git a/shared/src/main/java/com/vaadin/flow/component/confirmdialog/ConfirmDialogTester.java b/shared/src/main/java/com/vaadin/flow/component/confirmdialog/ConfirmDialogTester.java
index 33adaebe..2b9af169 100644
--- a/shared/src/main/java/com/vaadin/flow/component/confirmdialog/ConfirmDialogTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/confirmdialog/ConfirmDialogTester.java
@@ -15,8 +15,6 @@
  */
 package com.vaadin.flow.component.confirmdialog;
 
-import java.util.NoSuchElementException;
-
 import com.vaadin.browserless.ComponentTester;
 import com.vaadin.browserless.Tests;
 import com.vaadin.flow.component.ComponentUtil;
@@ -39,6 +37,9 @@ public ConfirmDialogTester(ConfirmDialog component) {
         super(component);
     }
 
+    /**
+     * Opens the dialog, as clicking the component that owns it would.
+     */
     public void open() {
         getComponent().open();
         roundTrip();
@@ -111,7 +112,7 @@ public String getHeader() {
      * Get the header element set to the confirm dialog.
      *
      * @return header element
-     * @throws NoSuchElementException
+     * @throws java.util.NoSuchElementException
      *             if no header element found
      */
     public Element getHeaderElement() {
diff --git a/shared/src/main/java/com/vaadin/flow/component/contextmenu/ContextMenuTester.java b/shared/src/main/java/com/vaadin/flow/component/contextmenu/ContextMenuTester.java
index a047c07e..4d7112f8 100644
--- a/shared/src/main/java/com/vaadin/flow/component/contextmenu/ContextMenuTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/contextmenu/ContextMenuTester.java
@@ -283,6 +283,8 @@ public boolean isItemChecked(String topLevelText,
      * @param nestedItemsPositions
      *            the zero-based position of the nested items, relative to the
      *            parent menu
+     * @return {@code true} if the checkable menu item at given position is
+     *         checked
      * @throws IllegalArgumentException
      *             if the provided position does not identify a menu item or if
      *             the menu item is not checkable.
@@ -490,7 +492,7 @@ public List<String> getItemTexts(String topLevelText,
      * are in a detached state unless {@link #open()} has been called
      * previously. Example usage:
      *
-     * <pre>
+     * <pre>{@code
      * // view:
      * ContextMenu menu = new ContextMenu();
      * menu.addItem(new VerticalLayout(new Div("Component Item")),
@@ -505,7 +507,7 @@ public List<String> getItemTexts(String topLevelText,
      * menuTester.close();
      * div = menuTester.find(Div.class).withText("Component Item").single();
      * Assertions.assertFalse(div.isAttached());
-     * </pre>
+     * }</pre>
      */
     @Override
     public <R extends Component> ComponentQuery<R> find(
diff --git a/shared/src/main/java/com/vaadin/flow/component/datepicker/DatePickerTester.java b/shared/src/main/java/com/vaadin/flow/component/datepicker/DatePickerTester.java
index 5dbd6502..144d092f 100644
--- a/shared/src/main/java/com/vaadin/flow/component/datepicker/DatePickerTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/datepicker/DatePickerTester.java
@@ -42,7 +42,7 @@ public DatePickerTester(T component) {
 
     /**
      * Set the given date as value to the component, as the user would enter it.
-     * <p/>
+     * <p>
      * A date that violates the component's constraints — outside
      * {@literal min - max}, or the empty value on a required field — is
      * committed all the same, because the browser commits it too and simply
@@ -84,7 +84,7 @@ public boolean isValid() {
     /**
      * Empties the field, as when the user deletes its contents (or clicks the
      * clear button, where one is shown).
-     * <p/>
+     * <p>
      * Emptying is something the user can always do, so it needs no clear
      * button: a field may legitimately end up invalid — a required field, for
      * instance — once emptied.
@@ -98,7 +98,7 @@ public void clear() {
 
     /**
      * Empties the field by clicking its clear button, as the user would.
-     * <p/>
+     * <p>
      * Unlike {@link #clear()}, which models selecting the contents and deleting
      * them and is therefore always available, this requires the clear button to
      * be visible — a hidden clear button is not something the user can click.
diff --git a/shared/src/main/java/com/vaadin/flow/component/datetimepicker/DateTimePickerTester.java b/shared/src/main/java/com/vaadin/flow/component/datetimepicker/DateTimePickerTester.java
index 40d84c22..f8afec28 100644
--- a/shared/src/main/java/com/vaadin/flow/component/datetimepicker/DateTimePickerTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/datetimepicker/DateTimePickerTester.java
@@ -42,7 +42,7 @@ public DateTimePickerTester(T component) {
 
     /**
      * Set the date to the component, as the user would enter it.
-     * <p/>
+     * <p>
      * A value that violates the component's constraints — outside
      * {@literal min - max}, or the empty value on a required field — is
      * committed all the same, because the browser commits it too and simply
@@ -84,7 +84,7 @@ public boolean isValid() {
     /**
      * Empties the field, as when the user deletes its contents (or clicks the
      * clear button, where one is shown).
-     * <p/>
+     * <p>
      * Emptying is something the user can always do, so it needs no clear
      * button: a field may legitimately end up invalid — a required field, for
      * instance — once emptied.
diff --git a/shared/src/main/java/com/vaadin/flow/component/dialog/DialogTester.java b/shared/src/main/java/com/vaadin/flow/component/dialog/DialogTester.java
index f5faf512..75a533a1 100644
--- a/shared/src/main/java/com/vaadin/flow/component/dialog/DialogTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/dialog/DialogTester.java
@@ -23,6 +23,8 @@
 import com.vaadin.flow.component.Component;
 
 /**
+ * Tester for Dialog components.
+ *
  * @since 1.0
  */
 @Tests(Dialog.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/geolocation/BrowserlessGeolocationClientFactory.java b/shared/src/main/java/com/vaadin/flow/component/geolocation/BrowserlessGeolocationClientFactory.java
index 8f2f2684..f83e8f20 100644
--- a/shared/src/main/java/com/vaadin/flow/component/geolocation/BrowserlessGeolocationClientFactory.java
+++ b/shared/src/main/java/com/vaadin/flow/component/geolocation/BrowserlessGeolocationClientFactory.java
@@ -30,6 +30,12 @@
 public final class BrowserlessGeolocationClientFactory
         implements GeolocationClientFactory {
 
+    /**
+     * Creates the factory; Flow looks it up through the service loader.
+     */
+    public BrowserlessGeolocationClientFactory() {
+    }
+
     @Override
     public GeolocationClient create(UI ui) {
         BrowserlessGeolocationClient client = new BrowserlessGeolocationClient();
diff --git a/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationRequest.java b/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationRequest.java
index 21c5e389..000e20e8 100644
--- a/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationRequest.java
+++ b/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationRequest.java
@@ -28,22 +28,36 @@
  */
 public interface GeolocationRequest {
 
-    /** The options the application passed to get(...), or {@code null}. */
+    /**
+     * The options the application passed to get(...), or {@code null}.
+     *
+     * @return the options the request was made with
+     */
     @Nullable
     GeolocationOptions options();
 
-    /** Whether this request still awaits a response. */
+    /**
+     * Whether this request still awaits a response.
+     *
+     * @return {@code true} while the request is still waiting for a position
+     */
     boolean isPending();
 
     /**
      * Resolves the request with the given position. Throws
      * {@link IllegalStateException} if the request was already resolved.
+     *
+     * @param position
+     *            the caret position
      */
     void respondWith(GeolocationPosition position);
 
     /**
      * Resolves the request with the given error. Throws
      * {@link IllegalStateException} if the request was already resolved.
+     *
+     * @param error
+     *            the error view to register
      */
     void respondWith(GeolocationError error);
 }
diff --git a/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationSimulator.java b/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationSimulator.java
index e9859ae1..803d28f6 100644
--- a/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationSimulator.java
+++ b/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationSimulator.java
@@ -72,6 +72,9 @@
  */
 public final class GeolocationSimulator implements Serializable {
 
+    /**
+     * The client the simulated positions are pushed into.
+     */
     private final BrowserlessGeolocationClient client;
 
     GeolocationSimulator(BrowserlessGeolocationClient client) {
diff --git a/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationTrackerSession.java b/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationTrackerSession.java
index 50b76a48..4ecdf3c1 100644
--- a/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationTrackerSession.java
+++ b/shared/src/main/java/com/vaadin/flow/component/geolocation/GeolocationTrackerSession.java
@@ -27,13 +27,25 @@
  */
 public interface GeolocationTrackerSession {
 
-    /** The component that owns this tracker session. */
+    /**
+     * The component that owns this tracker session.
+     *
+     * @return the component that started tracking
+     */
     Component owner();
 
-    /** Options the tracker was started with, or {@code null}. */
+    /**
+     * Options the tracker was started with, or {@code null}.
+     *
+     * @return the options tracking was started with
+     */
     @Nullable
     GeolocationOptions options();
 
-    /** Whether the tracker is currently receiving updates. */
+    /**
+     * Whether the tracker is currently receiving updates.
+     *
+     * @return {@code true} while the session is still tracking
+     */
     boolean isActive();
 }
diff --git a/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java b/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
index 10739612..1f6f6eb3 100644
--- a/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
@@ -72,7 +72,7 @@ public int size() {
 
     /**
      * Get the item at the given row index.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -85,7 +85,7 @@ public Y getRow(int row) {
 
     /**
      * Click on grid row.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -97,7 +97,7 @@ public void clickRow(int row) {
 
     /**
      * Click on grid row with given button.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -112,7 +112,7 @@ public void clickRow(int row, MouseButton button) {
 
     /**
      * Click on grid row with given meta keys pressed.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -126,7 +126,7 @@ public void clickRow(int row, MetaKeys metaKeys) {
 
     /**
      * Click on grid row with given button and meta keys pressed.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -146,7 +146,7 @@ public void clickRow(int row, MouseButton button, MetaKeys metaKeys) {
 
     /**
      * Double-click on grid row.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -158,7 +158,7 @@ public void doubleClickRow(int row) {
 
     /**
      * Double-click on grid row with given button.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -173,7 +173,7 @@ public void doubleClickRow(int row, MouseButton button) {
 
     /**
      * Double-click on grid row with given meta keys pressed.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -187,7 +187,7 @@ public void doubleClickRow(int row, MetaKeys metaKeys) {
 
     /**
      * Double-click on grid row with given button and meta keys pressed.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -207,9 +207,9 @@ public void doubleClickRow(int row, MouseButton button, MetaKeys metaKeys) {
 
     /**
      * Select the item on given row.
-     * <p/>
+     * <p>
      * The index is 0 based.
-     * <p/>
+     * <p>
      * Single select will clear any old selections. Multi select will add to
      * selection.
      *
@@ -227,7 +227,7 @@ public void select(int row) {
     /**
      * Select all items in grid, running the same code as when the select all
      * checkbox is checked.
-     * <p/>
+     * <p>
      * Only works for multi select, and only when the select all checkbox is
      * actually shown - if it isn't, the user has no way to trigger this.
      *
@@ -242,16 +242,16 @@ public void selectAll() {
 
     /**
      * Deselect the item on given row.
-     * <p/>
+     * <p>
      * The index is 0 based.
-     * <p/>
+     * <p>
      * Simulates the user deselecting a row: ctrl-clicking a selected row or
      * unchecking the row's selection checkbox in multi select, clicking the
      * selected row in single select.
-     * <p/>
+     * <p>
      * The row has to be selected. Deselecting a row that isn't selected is not
      * a gesture the user has, so it fails instead of doing nothing.
-     * <p/>
+     * <p>
      * The call is ignored, exactly as the user's click would be, when the item
      * is not selectable or when the grid is single select and deselecting is
      * not allowed.
@@ -271,10 +271,10 @@ public void deselect(int row) {
     /**
      * Deselect all items in grid, running the same code as when the select all
      * checkbox is unchecked.
-     * <p/>
+     * <p>
      * Only works for multi select, and only when the select all checkbox is
      * actually shown - if it isn't, the user has no way to trigger this.
-     * <p/>
+     * <p>
      * This is the counterpart of {@link #selectAll()} and behaves like the
      * checkbox does: the selection is dropped in one selection event, without
      * the per row toggle events the user would cause by unchecking rows one by
@@ -292,15 +292,15 @@ public void deselectAll() {
     /**
      * Get the text that is shown on the client for the cell in the given
      * position.
-     * <p/>
+     * <p>
      * The indexes for row and column are 0 based.
-     * <p/>
+     * <p>
      * For the default renderer ColumnPathRenderer the result is the sent text
      * for defined object path.
-     * <p/>
+     * <p>
      * For a ComponentRenderer the result is the rendered component as
      * prettyString.
-     * <p/>
+     * <p>
      * More to be added as we find other renderers that need handling.
      *
      * @param row
@@ -418,6 +418,8 @@ private <V> V getLitRendererPropertyValue(int row, Grid.Column<Y> column,
     /**
      * Get property value for item's LitRenderer in column.
      *
+     * @param <V>
+     *            the type of the LitRenderer property
      * @param row
      *            item row
      * @param columnName
@@ -426,8 +428,6 @@ private <V> V getLitRendererPropertyValue(int row, Grid.Column<Y> column,
      *            the name of the LitRenderer property
      * @param propertyClass
      *            the class of the value of the LitRenderer property
-     * @param <V>
-     *            the type of the LitRenderer property
      * @return value of renderer's property for the target cell
      * @throws IllegalArgumentException
      *             when column for property doesn't exist or the target column
@@ -443,6 +443,8 @@ public <V> V getLitRendererPropertyValue(int row, String columnName,
     /**
      * Get property value for item's LitRenderer in column.
      *
+     * @param <V>
+     *            the type of the LitRenderer property
      * @param row
      *            item row
      * @param column
@@ -451,8 +453,6 @@ public <V> V getLitRendererPropertyValue(int row, String columnName,
      *            the name of the LitRenderer property
      * @param propertyClass
      *            the class of the value of the LitRenderer property
-     * @param <V>
-     *            the type of the LitRenderer property
      * @return value of renderer's property for the target cell
      * @throws IllegalArgumentException
      *             when column for property doesn't exist or the target column
@@ -557,8 +557,10 @@ public void invokeLitRendererFunction(int row, int column,
      * @throws IllegalStateException
      *             if component is not visible
      *
-     * @deprecated Use {@link Grid.Column#getHeaderText()} or
-     *             {@link Grid.Column#getHeaderComponent()}
+     * @deprecated Use
+     *             {@link com.vaadin.flow.component.grid.Grid.Column#getHeaderText()}
+     *             or
+     *             {@link com.vaadin.flow.component.grid.Grid.Column#getHeaderComponent()}
      */
     @Deprecated
     public String getHeaderCell(int column) {
@@ -609,8 +611,11 @@ public Grid.Column<Y> getColumn(String property) {
      * @return footer contents
      * @throws IllegalStateException
      *             if component is not visible
-     * @deprecated Use {@link Grid.Column#getFooterText()} or
-     *             {@link Grid.Column#getFooterComponent()} directly
+     * @deprecated Use
+     *             {@link com.vaadin.flow.component.grid.Grid.Column#getFooterText()}
+     *             or
+     *             {@link com.vaadin.flow.component.grid.Grid.Column#getFooterComponent()}
+     *             directly
      */
     @Deprecated(forRemoval = true)
     public String getFooterCell(int column) {
@@ -630,7 +635,7 @@ public Collection<Y> getSelected() {
 
     /**
      * Checks if the column at the given index is sortable.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param column
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/AnchorTester.java b/shared/src/main/java/com/vaadin/flow/component/html/AnchorTester.java
index 8bf8f9f2..9a7eb03c 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/AnchorTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/AnchorTester.java
@@ -38,6 +38,8 @@
 import com.vaadin.flow.server.streams.DownloadHandler;
 
 /**
+ * Tester for Anchor components.
+ *
  * @since 1.0
  */
 @Tests(Anchor.class)
@@ -76,8 +78,8 @@ public String getPath() {
     /**
      * Gets the query parameters for the router-link.
      *
-     * @return a {@link QueryParameters} containing the navigation target's
-     *         query parameters
+     * @return a {@link com.vaadin.flow.router.QueryParameters QueryParameters}
+     *         containing the navigation target's query parameters
      */
     public QueryParameters getQueryParameters() {
         return QueryParameters.fromString(URI.create(getHref()).getQuery());
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/DescriptionListTester.java b/shared/src/main/java/com/vaadin/flow/component/html/DescriptionListTester.java
index b29177c4..da6f469d 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/DescriptionListTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/DescriptionListTester.java
@@ -21,6 +21,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for DescriptionList components.
+ *
  * @since 1.0
  */
 @Tests(DescriptionList.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/DivTester.java b/shared/src/main/java/com/vaadin/flow/component/html/DivTester.java
index c6ed1705..4110005b 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/DivTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/DivTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Div components.
+ *
  * @since 1.0
  */
 @Tests(Div.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/EmphasisTester.java b/shared/src/main/java/com/vaadin/flow/component/html/EmphasisTester.java
index 0ec9eb0b..a634b3e9 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/EmphasisTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/EmphasisTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Emphasis components.
+ *
  * @since 1.0
  */
 @Tests(Emphasis.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/H1Tester.java b/shared/src/main/java/com/vaadin/flow/component/html/H1Tester.java
index 8fa6d09d..084e9116 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/H1Tester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/H1Tester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for H1 components.
+ *
  * @since 1.0
  */
 @Tests(H1.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/H2Tester.java b/shared/src/main/java/com/vaadin/flow/component/html/H2Tester.java
index b9e51732..92271dff 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/H2Tester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/H2Tester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for H2 components.
+ *
  * @since 1.0
  */
 @Tests(H2.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/H3Tester.java b/shared/src/main/java/com/vaadin/flow/component/html/H3Tester.java
index e44c9719..c4308af9 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/H3Tester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/H3Tester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for H3 components.
+ *
  * @since 1.0
  */
 @Tests(H3.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/H4Tester.java b/shared/src/main/java/com/vaadin/flow/component/html/H4Tester.java
index 779aedf8..8d876f1e 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/H4Tester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/H4Tester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for H4 components.
+ *
  * @since 1.0
  */
 @Tests(H4.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/H5Tester.java b/shared/src/main/java/com/vaadin/flow/component/html/H5Tester.java
index 1e122113..9bad2fa9 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/H5Tester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/H5Tester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for H5 components.
+ *
  * @since 1.0
  */
 @Tests(H5.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/H6Tester.java b/shared/src/main/java/com/vaadin/flow/component/html/H6Tester.java
index bcdb32fd..6622f476 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/H6Tester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/H6Tester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for H6 components.
+ *
  * @since 1.0
  */
 @Tests(H6.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/HrTester.java b/shared/src/main/java/com/vaadin/flow/component/html/HrTester.java
index f34a46b7..4aa7fc20 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/HrTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/HrTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Hr components.
+ *
  * @since 1.0
  */
 @Tests(Hr.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/HtmlClickContainer.java b/shared/src/main/java/com/vaadin/flow/component/html/HtmlClickContainer.java
index 9326582d..4082db00 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/HtmlClickContainer.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/HtmlClickContainer.java
@@ -18,6 +18,10 @@
 import com.vaadin.flow.component.HtmlContainer;
 
 /**
+ * Tester for HtmlContainer components that are also clickable.
+ *
+ * @param <T>
+ *            component type
  * @since 1.0
  */
 public abstract class HtmlClickContainer<T extends HtmlContainer>
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/HtmlComponentTester.java b/shared/src/main/java/com/vaadin/flow/component/html/HtmlComponentTester.java
index 9dc86ce2..5a15af0b 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/HtmlComponentTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/HtmlComponentTester.java
@@ -19,6 +19,10 @@
 import com.vaadin.flow.component.HtmlComponent;
 
 /**
+ * Tester for HtmlComponent components.
+ *
+ * @param <T>
+ *            component type
  * @since 1.0
  */
 public class HtmlComponentTester<T extends HtmlComponent>
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/HtmlContainerTester.java b/shared/src/main/java/com/vaadin/flow/component/html/HtmlContainerTester.java
index 0a66b3be..818edfca 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/HtmlContainerTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/HtmlContainerTester.java
@@ -18,6 +18,10 @@
 import com.vaadin.flow.component.HtmlContainer;
 
 /**
+ * Tester for HtmlContainer components.
+ *
+ * @param <T>
+ *            component type
  * @since 1.0
  */
 public class HtmlContainerTester<T extends HtmlContainer>
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/ImageTester.java b/shared/src/main/java/com/vaadin/flow/component/html/ImageTester.java
index e2223caa..07cb7689 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/ImageTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/ImageTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Image components.
+ *
  * @since 1.0
  */
 @Tests(Image.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/InputTester.java b/shared/src/main/java/com/vaadin/flow/component/html/InputTester.java
index 87464daf..39ae3589 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/InputTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/InputTester.java
@@ -19,6 +19,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Input components.
+ *
  * @since 1.0
  */
 @Tests(Input.class)
@@ -68,7 +70,7 @@ public String getValue() {
     /**
      * Empties the field, as when the user deletes its contents (or clicks the
      * clear button, where one is shown).
-     * <p/>
+     * <p>
      * Emptying is something the user can always do, so it needs no clear
      * button: a field may legitimately end up invalid — a required field, for
      * instance — once emptied.
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/ListItemTester.java b/shared/src/main/java/com/vaadin/flow/component/html/ListItemTester.java
index 106a40f2..6de91c2c 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/ListItemTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/ListItemTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for ListItem components.
+ *
  * @since 1.0
  */
 @Tests(ListItem.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/NativeButtonTester.java b/shared/src/main/java/com/vaadin/flow/component/html/NativeButtonTester.java
index b922dd2c..a1a93320 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/NativeButtonTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/NativeButtonTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for NativeButton components.
+ *
  * @since 1.0
  */
 @Tests(NativeButton.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/NativeDetailsTester.java b/shared/src/main/java/com/vaadin/flow/component/html/NativeDetailsTester.java
index 988d5417..5d642e95 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/NativeDetailsTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/NativeDetailsTester.java
@@ -20,6 +20,8 @@
 import com.vaadin.flow.component.ComponentUtil;
 
 /**
+ * Tester for NativeDetails components.
+ *
  * @since 1.0
  */
 @Tests(NativeDetails.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/NativeLabelTester.java b/shared/src/main/java/com/vaadin/flow/component/html/NativeLabelTester.java
index ef77e082..1a1804cd 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/NativeLabelTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/NativeLabelTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for NativeLabel components.
+ *
  * @since 1.0
  */
 @Tests(NativeLabel.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/OrderedListTester.java b/shared/src/main/java/com/vaadin/flow/component/html/OrderedListTester.java
index e1163076..da99737a 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/OrderedListTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/OrderedListTester.java
@@ -21,6 +21,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for OrderedList components.
+ *
  * @since 1.0
  */
 @Tests(OrderedList.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/ParagraphTester.java b/shared/src/main/java/com/vaadin/flow/component/html/ParagraphTester.java
index 9c3b10b6..3c3b1130 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/ParagraphTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/ParagraphTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Paragraph components.
+ *
  * @since 1.0
  */
 @Tests(Paragraph.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/PreTester.java b/shared/src/main/java/com/vaadin/flow/component/html/PreTester.java
index 9e09a6af..16665940 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/PreTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/PreTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Pre components.
+ *
  * @since 1.0
  */
 @Tests(Pre.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/RangeInputTester.java b/shared/src/main/java/com/vaadin/flow/component/html/RangeInputTester.java
index 9105a8c5..a89aacbc 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/RangeInputTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/RangeInputTester.java
@@ -21,6 +21,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for RangeInput components.
+ *
  * @since 1.0
  */
 @Tests(RangeInput.class)
@@ -54,7 +56,6 @@ public Double getValue() {
      * For a non interactable component an IllegalStateException will be thrown
      * as the end user would not be able to set a value.
      * <p>
-     * </p>
      * The value must be in the component {@literal min - max} range, and should
      * be valid according to the {@literal step} scale factor, otherwise an
      * {@link IllegalArgumentException} is thrown.
@@ -100,7 +101,6 @@ public void setValue(Double value) {
     /**
      * Increase the value by the amount defined by component {@literal step}.
      * <p>
-     * </p>
      * If the {@literal step} is not defined, an {@link IllegalStateException}
      * is thrown. An {@link IllegalArgumentException} is thrown if increase
      * operation exceeds the {@literal max} boundaries.
@@ -116,7 +116,6 @@ public void increase() {
      * Increases the value by a specified multiple of the component step
      * setting.
      * <p>
-     * </p>
      * If the {@literal step} is not defined, an {@link IllegalStateException}
      * is thrown. An {@link IllegalArgumentException} is thrown if increase
      * operation exceeds the {@literal max} boundaries.
@@ -147,7 +146,6 @@ public void increase(int times) {
     /**
      * Decreases the value by the amount defined by component {@literal step}.
      * <p>
-     * </p>
      * If the {@literal step} is not defined, an {@link IllegalStateException}
      * is thrown. An {@link IllegalArgumentException} is thrown if increase
      * operation exceeds the {@literal min} boundaries.
@@ -163,7 +161,6 @@ public void decrease() {
      * Decreases the value by a specified multiple of the component step
      * setting.
      * <p>
-     * </p>
      * If the {@literal step} is not defined, an {@link IllegalStateException}
      * is thrown. An {@link IllegalArgumentException} is thrown if increase
      * operation exceeds the {@literal min} boundaries.
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/SpanTester.java b/shared/src/main/java/com/vaadin/flow/component/html/SpanTester.java
index f69f9d30..56a3fb15 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/SpanTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/SpanTester.java
@@ -18,6 +18,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for Span components.
+ *
  * @since 1.0
  */
 @Tests(Span.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/html/UnorderedListTester.java b/shared/src/main/java/com/vaadin/flow/component/html/UnorderedListTester.java
index 4b4df999..94b5a990 100644
--- a/shared/src/main/java/com/vaadin/flow/component/html/UnorderedListTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/html/UnorderedListTester.java
@@ -21,6 +21,8 @@
 import com.vaadin.browserless.Tests;
 
 /**
+ * Tester for UnorderedList components.
+ *
  * @since 1.0
  */
 @Tests(UnorderedList.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/menubar/MenuBarTester.java b/shared/src/main/java/com/vaadin/flow/component/menubar/MenuBarTester.java
index 1cba462e..38d04849 100644
--- a/shared/src/main/java/com/vaadin/flow/component/menubar/MenuBarTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/menubar/MenuBarTester.java
@@ -215,6 +215,8 @@ public boolean isItemChecked(String topLevelText,
      * @param nestedItemsPositions
      *            the zero-based position of the nested items, relative to the
      *            parent menu
+     * @return {@code true} if the checkable menu item at given position is
+     *         checked
      * @throws IllegalArgumentException
      *             if the provided position does not identify a menu item or if
      *             the menu item is not checkable.
diff --git a/shared/src/main/java/com/vaadin/flow/component/messages/MessageListTester.java b/shared/src/main/java/com/vaadin/flow/component/messages/MessageListTester.java
index 8ebe58ab..970f07f2 100644
--- a/shared/src/main/java/com/vaadin/flow/component/messages/MessageListTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/messages/MessageListTester.java
@@ -59,7 +59,8 @@ public int size() {
      *            item index
      * @return message in index
      * @throws IndexOutOfBoundsException
-     *             – if the index is out of range (index < 0 || index >= size())
+     *             – if the index is out of range
+     *             ({@code index < 0 || index >= size()})
      */
     public MessageListItem getMessage(int index) {
         ensureComponentIsUsable();
@@ -132,7 +133,8 @@ public List<MessageListItem> getMessagesBefore(Instant end) {
      * @return attachments of the message in index, empty list if the message
      *         has no attachments
      * @throws IndexOutOfBoundsException
-     *             – if the index is out of range (index < 0 || index >= size())
+     *             – if the index is out of range
+     *             ({@code index < 0 || index >= size()})
      * @since 1.1
      */
     public List<MessageListItem.Attachment> getAttachments(int index) {
@@ -151,7 +153,8 @@ public List<MessageListItem.Attachment> getAttachments(int index) {
      * @return attachment with the given name, or {@code null} if the message
      *         has no attachment with the given name
      * @throws IndexOutOfBoundsException
-     *             – if the index is out of range (index < 0 || index >= size())
+     *             – if the index is out of range
+     *             ({@code index < 0 || index >= size()})
      * @since 1.1
      */
     public MessageListItem.Attachment getAttachmentByName(int index,
diff --git a/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonTester.java b/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonTester.java
index 3a0f32ec..f621e111 100644
--- a/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/radiobutton/RadioButtonTester.java
@@ -71,6 +71,12 @@ public void click() {
         radioButton.setChecked(true);
     }
 
+    /**
+     * Equivalent to
+     * {@code getComponent().getElement().getProperty("disabled", false)}.
+     *
+     * @return whether the radio button is disabled
+     */
     protected boolean isDisabled() {
         return getComponent().getElement().getProperty("disabled", false);
     }
diff --git a/shared/src/main/java/com/vaadin/flow/component/routerlink/RouterLinkTester.java b/shared/src/main/java/com/vaadin/flow/component/routerlink/RouterLinkTester.java
index 4e5237cd..2e691ad2 100644
--- a/shared/src/main/java/com/vaadin/flow/component/routerlink/RouterLinkTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/routerlink/RouterLinkTester.java
@@ -73,8 +73,8 @@ public String getPath() {
     /**
      * Gets the query parameters for the router-link.
      *
-     * @return a {@link QueryParameters} containing the navigation target's
-     *         query parameters
+     * @return a {@link com.vaadin.flow.router.QueryParameters QueryParameters}
+     *         containing the navigation target's query parameters
      */
     public QueryParameters getQueryParameters() {
         return QueryParameters.fromString(URI.create(getHref()).getQuery());
@@ -84,8 +84,8 @@ public QueryParameters getQueryParameters() {
      * Gets the registered route class for the router-link. Returns an empty
      * optional if there is no corresponding navigation target.
      *
-     * @return an {@link Optional} containing the navigation target class or
-     *         empty if not found
+     * @return an {@link java.util.Optional Optional} containing the navigation
+     *         target class or empty if not found
      */
     public Optional<Class<? extends Component>> getRoute() {
         return RouteConfiguration.forSessionScope().getRoute(getPath());
diff --git a/shared/src/main/java/com/vaadin/flow/component/select/SelectTester.java b/shared/src/main/java/com/vaadin/flow/component/select/SelectTester.java
index 6f3580ab..16d01eaf 100644
--- a/shared/src/main/java/com/vaadin/flow/component/select/SelectTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/select/SelectTester.java
@@ -24,6 +24,12 @@
 import com.vaadin.flow.data.provider.DataViewUtils;
 
 /**
+ * Tester for Select components.
+ *
+ * @param <T>
+ *            component type
+ * @param <Y>
+ *            item type
  * @since 1.0
  */
 @Tests(fqn = { "com.vaadin.flow.component.select.Select" })
diff --git a/shared/src/main/java/com/vaadin/flow/component/sidenav/SideNavTester.java b/shared/src/main/java/com/vaadin/flow/component/sidenav/SideNavTester.java
index 1fef7487..e69633f2 100644
--- a/shared/src/main/java/com/vaadin/flow/component/sidenav/SideNavTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/sidenav/SideNavTester.java
@@ -22,6 +22,10 @@
 import com.vaadin.flow.component.UI;
 
 /**
+ * Tester for SideNav components.
+ *
+ * @param <T>
+ *            component type
  * @since 1.0
  */
 @Tests(SideNav.class)
diff --git a/shared/src/main/java/com/vaadin/flow/component/tabs/TabSheetTester.java b/shared/src/main/java/com/vaadin/flow/component/tabs/TabSheetTester.java
index 836e5253..1708a84f 100644
--- a/shared/src/main/java/com/vaadin/flow/component/tabs/TabSheetTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/tabs/TabSheetTester.java
@@ -125,6 +125,7 @@ public boolean isSelected(int index) {
      *
      * @param label
      *            the tab label
+     * @return the visible tab with the given label
      * @throws IllegalStateException
      *             if tab is not visible
      */
@@ -171,6 +172,8 @@ public Tab getTab(int index) {
     /**
      * Gets the content of the visible tab with the given label.
      *
+     * @param <E>
+     *            the event type
      * @param label
      *            the tab label
      * @return the content of the tab with the given label
@@ -198,6 +201,8 @@ public <E extends Component> E getTabContent(String label) {
      * is hidden, then to get the content of tab 'C', the call must be
      * {@code getTabContent(1)} and not {@code getTabContent(2)}.
      *
+     * @param <E>
+     *            the event type
      * @param index
      *            the zero-based index of the selected tab, negative value to
      *            unselect
diff --git a/shared/src/main/java/com/vaadin/flow/component/tabs/TabsTester.java b/shared/src/main/java/com/vaadin/flow/component/tabs/TabsTester.java
index b2cfd873..12aaf532 100644
--- a/shared/src/main/java/com/vaadin/flow/component/tabs/TabsTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/tabs/TabsTester.java
@@ -124,6 +124,7 @@ public boolean isSelected(int index) {
      *
      * @param label
      *            the tab label
+     * @return the visible tab with the given label
      * @throws IllegalStateException
      *             if tab is not visible
      */
@@ -150,6 +151,7 @@ public Tab getTab(String label) {
      * @param index
      *            the zero-based index of the selected tab, negative value to
      *            unselect
+     * @return the visible tab at given index
      * @throws IllegalStateException
      *             if tab at given index is not visible in the browser
      * @throws IllegalArgumentException
diff --git a/shared/src/main/java/com/vaadin/flow/component/textfield/NumberFieldTester.java b/shared/src/main/java/com/vaadin/flow/component/textfield/NumberFieldTester.java
index 88310610..87e01713 100644
--- a/shared/src/main/java/com/vaadin/flow/component/textfield/NumberFieldTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/textfield/NumberFieldTester.java
@@ -45,7 +45,7 @@ public NumberFieldTester(T component) {
 
     /**
      * Set the given value for the component, as the user would type it.
-     * <p/>
+     * <p>
      * A value that violates the component's constraints — outside
      * {@literal min - max}, off the {@literal step} scale, or the empty value
      * on a required field — is committed all the same, because the browser
@@ -66,7 +66,7 @@ public void setValue(V value) {
     /**
      * Empties the field, as when the user deletes its contents (or clicks the
      * clear button, where one is shown).
-     * <p/>
+     * <p>
      * Emptying is something the user can always do, so it needs no clear
      * button: a field may legitimately end up invalid — a required field, for
      * instance — once emptied.
@@ -80,7 +80,7 @@ public void clear() {
 
     /**
      * Empties the field by clicking its clear button, as the user would.
-     * <p/>
+     * <p>
      * Unlike {@link #clear()}, which models selecting the contents and deleting
      * them and is therefore always available, this requires the clear button to
      * be visible — a hidden clear button is not something the user can click.
diff --git a/shared/src/main/java/com/vaadin/flow/component/textfield/TextAreaTester.java b/shared/src/main/java/com/vaadin/flow/component/textfield/TextAreaTester.java
index 8063425c..d73b6554 100644
--- a/shared/src/main/java/com/vaadin/flow/component/textfield/TextAreaTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/textfield/TextAreaTester.java
@@ -54,7 +54,7 @@ public void setValue(String value) {
     /**
      * Empties the field, as when the user deletes its contents (or clicks the
      * clear button, where one is shown).
-     * <p/>
+     * <p>
      * Emptying is something the user can always do, so it needs no clear
      * button: a field may legitimately end up invalid — a required field, for
      * instance — once emptied.
@@ -68,7 +68,7 @@ public void clear() {
 
     /**
      * Empties the field by clicking its clear button, as the user would.
-     * <p/>
+     * <p>
      * Unlike {@link #clear()}, which models selecting the contents and deleting
      * them and is therefore always available, this requires the clear button to
      * be visible — a hidden clear button is not something the user can click.
diff --git a/shared/src/main/java/com/vaadin/flow/component/textfield/TextFieldTester.java b/shared/src/main/java/com/vaadin/flow/component/textfield/TextFieldTester.java
index 329e578b..e8d5571c 100644
--- a/shared/src/main/java/com/vaadin/flow/component/textfield/TextFieldTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/textfield/TextFieldTester.java
@@ -65,7 +65,7 @@ public void setValue(V value) {
     /**
      * Empties the field, as when the user deletes its contents (or clicks the
      * clear button, where one is shown).
-     * <p/>
+     * <p>
      * Emptying is something the user can always do, so it needs no clear
      * button: a field may legitimately end up invalid — a required field, for
      * instance — once emptied.
@@ -79,7 +79,7 @@ public void clear() {
 
     /**
      * Empties the field by clicking its clear button, as the user would.
-     * <p/>
+     * <p>
      * Unlike {@link #clear()}, which models selecting the contents and deleting
      * them and is therefore always available, this requires the clear button to
      * be visible — a hidden clear button is not something the user can click.
diff --git a/shared/src/main/java/com/vaadin/flow/component/timepicker/TimePickerTester.java b/shared/src/main/java/com/vaadin/flow/component/timepicker/TimePickerTester.java
index 881f56b2..b114b0f1 100644
--- a/shared/src/main/java/com/vaadin/flow/component/timepicker/TimePickerTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/timepicker/TimePickerTester.java
@@ -41,7 +41,7 @@ public TimePickerTester(T component) {
 
     /**
      * Set the time to the component, as the user would enter it.
-     * <p/>
+     * <p>
      * A time that violates the component's constraints — outside
      * {@literal min - max}, or the empty value on a required field — is
      * committed all the same, because the browser commits it too and simply
@@ -83,7 +83,7 @@ public boolean isValid() {
     /**
      * Empties the field, as when the user deletes its contents (or clicks the
      * clear button, where one is shown).
-     * <p/>
+     * <p>
      * Emptying is something the user can always do, so it needs no clear
      * button: a field may legitimately end up invalid — a required field, for
      * instance — once emptied.
@@ -97,7 +97,7 @@ public void clear() {
 
     /**
      * Empties the field by clicking its clear button, as the user would.
-     * <p/>
+     * <p>
      * Unlike {@link #clear()}, which models selecting the contents and deleting
      * them and is therefore always available, this requires the clear button to
      * be visible — a hidden clear button is not something the user can click.
diff --git a/shared/src/main/java/com/vaadin/flow/component/treegrid/TreeGridTester.java b/shared/src/main/java/com/vaadin/flow/component/treegrid/TreeGridTester.java
index a52f0763..a9913e90 100644
--- a/shared/src/main/java/com/vaadin/flow/component/treegrid/TreeGridTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/treegrid/TreeGridTester.java
@@ -26,11 +26,12 @@
 
 /**
  * Tester for TreeGrid components.
- * <p/>
+ * <p>
  * Adds the hierarchy interactions a user can perform on top of everything
- * {@link GridTester} offers. Row indexes address the rows the user actually
- * sees, so children of collapsed nodes are not counted.
- * <p/>
+ * {@link com.vaadin.flow.component.grid.GridTester GridTester} offers. Row
+ * indexes address the rows the user actually sees, so children of collapsed
+ * nodes are not counted.
+ * <p>
  * The expand toggle lives in the hierarchy column, and a {@code TreeGrid} can
  * be configured with none, one, or several of them. {@link #expand(int)} and
  * {@link #collapse(int)} require at least one visible hierarchy column, since
@@ -65,10 +66,10 @@ public TreeGridTester(T component) {
     /**
      * Expands the node on the given row, as if the user clicked its expand
      * toggle in the browser.
-     * <p/>
+     * <p>
      * The index is 0 based and counts only rows that are currently displayed,
      * so children of collapsed nodes are skipped.
-     * <p/>
+     * <p>
      * The resulting {@link ExpandEvent} reports
      * {@link ExpandEvent#isFromClient()} as {@literal true}.
      *
@@ -95,10 +96,10 @@ public void expand(int row) {
     /**
      * Collapses the node on the given row, as if the user clicked its collapse
      * toggle in the browser.
-     * <p/>
+     * <p>
      * The index is 0 based and counts only rows that are currently displayed,
      * so children of collapsed nodes are skipped.
-     * <p/>
+     * <p>
      * The resulting {@link CollapseEvent} reports
      * {@link CollapseEvent#isFromClient()} as {@literal true}.
      *
@@ -124,7 +125,7 @@ public void collapse(int row) {
 
     /**
      * Checks whether the node on the given row is expanded.
-     * <p/>
+     * <p>
      * The index is 0 based and counts only rows that are currently displayed,
      * so children of collapsed nodes are skipped.
      *
@@ -143,7 +144,7 @@ public boolean isExpanded(int row) {
     /**
      * Checks whether the node on the given row has children, meaning the user
      * is shown an expand toggle for it.
-     * <p/>
+     * <p>
      * The index is 0 based and counts only rows that are currently displayed,
      * so children of collapsed nodes are skipped.
      *
@@ -162,12 +163,13 @@ public boolean hasChildren(int row) {
     /**
      * Get the text that is shown on the client for the cell in the given
      * position.
-     * <p/>
+     * <p>
      * A hierarchy column added with
      * {@link TreeGrid#addHierarchyColumn(com.vaadin.flow.function.ValueProvider)}
      * renders the item through a {@code vaadin-grid-tree-toggle}, so its text
      * is read from the toggle's own value provider rather than from a column
-     * path. Every other column is read exactly as {@link GridTester} does.
+     * path. Every other column is read exactly as
+     * {@link com.vaadin.flow.component.grid.GridTester GridTester} does.
      *
      * @param row
      *            row of cell
@@ -219,7 +221,8 @@ private boolean isHierarchyColumn(Grid.Column<Y> column) {
      * provider, or {@literal null} when the column is not one. Such a column
      * renders a {@code vaadin-grid-tree-toggle} straight from a
      * {@link LitRenderer}; the component variant is a {@link ComponentRenderer}
-     * instead and is handled by {@link GridTester}.
+     * instead and is handled by
+     * {@link com.vaadin.flow.component.grid.GridTester GridTester}.
      */
     private LitRenderer<Y> getTreeToggleRenderer(Grid.Column<Y> column) {
         final Renderer<Y> renderer = column.getRenderer();
diff --git a/shared/src/main/java/com/vaadin/flow/component/upload/UploadTester.java b/shared/src/main/java/com/vaadin/flow/component/upload/UploadTester.java
index 9bb1a775..c97ec2de 100644
--- a/shared/src/main/java/com/vaadin/flow/component/upload/UploadTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/upload/UploadTester.java
@@ -141,7 +141,7 @@ public UploadTester(T component) {
      *            content type of the file to upload
      * @param contents
      *            file contents as an array of bytes
-     * @throws UncheckedIOException
+     * @throws java.io.UncheckedIOException
      *             if the upload component fails to handle file contents
      * @throws IllegalStateException
      *             if the component is not usable
@@ -166,7 +166,7 @@ public void upload(String fileName, String contentType,
      *            content type of the file to upload
      * @param contents
      *            file contents as an array of bytes
-     * @throws UncheckedIOException
+     * @throws java.io.UncheckedIOException
      *             if the upload component fails to handle file contents
      * @throws IllegalStateException
      *             if the component is not usable
@@ -188,7 +188,7 @@ public void upload(String fileName, String contentType, byte[] contents) {
      *
      * @param file
      *            the file to upload
-     * @throws UncheckedIOException
+     * @throws java.io.UncheckedIOException
      *             if the upload component fails to handle file contents
      * @throws IllegalStateException
      *             if the component is not usable
@@ -350,11 +350,13 @@ public void removeFile(File file) {
      * the outcome the same way a user reads the upload file list in the
      * browser.
      * <p>
-     * Files are reported as {@link UploadStatus#UPLOADED} once the upload
-     * handler or receiver has consumed them, and as
-     * {@link UploadStatus#REJECTED} both when the client-side gate refused them
-     * and when Flow's server-side accepted type validation did, in which case
-     * neither shows up as a thrown exception.
+     * Files are reported as
+     * {@link com.vaadin.flow.component.upload.UploadTester.UploadStatus#UPLOADED}
+     * once the upload handler or receiver has consumed them, and as
+     * {@link com.vaadin.flow.component.upload.UploadTester.UploadStatus#REJECTED}
+     * both when the client-side gate refused them and when Flow's server-side
+     * accepted type validation did, in which case neither shows up as a thrown
+     * exception.
      *
      * @return the outcome of the last simulated upload, one entry per file, or
      *         an empty list if no upload has been simulated yet
diff --git a/shared/src/main/java/com/vaadin/flow/component/virtuallist/VirtualListTester.java b/shared/src/main/java/com/vaadin/flow/component/virtuallist/VirtualListTester.java
index c4b16279..46bf5776 100644
--- a/shared/src/main/java/com/vaadin/flow/component/virtuallist/VirtualListTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/virtuallist/VirtualListTester.java
@@ -87,15 +87,15 @@ public Y getItem(int index) {
 
     /**
      * Get the text that is shown on the client for the item at index.
-     * <p/>
+     * <p>
      * The index is zero-based.
-     * <p/>
+     * <p>
      * For the default renderer ColumnPathRenderer the result is the sent text
      * for defined object path.
-     * <p/>
+     * <p>
      * For a ComponentRenderer the result is the rendered component as
      * prettyString.
-     * <p/>
+     * <p>
      * More to be added as we find other renderers that need handling.
      *
      * @param index
@@ -171,14 +171,14 @@ private Renderer<Y> getItemRenderer() {
     /**
      * Get property value for item's LitRenderer.
      *
+     * @param <V>
+     *            the type of the LitRenderer property
      * @param index
      *            the zero-based index of the item
      * @param propertyName
      *            the name of the LitRenderer property
      * @param propertyClass
      *            the class of the value of the LitRenderer property
-     * @param <V>
-     *            the type of the LitRenderer property
      * @return value of the LitRenderer property
      * @throws IllegalArgumentException
      *             when the VirtualList is not using a LitRenderer or when the

From 64ea94b28d0f36cf6e16b84b58b1747975596654 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 19:25:09 +0000
Subject: [PATCH 09/13] docs: fix the doclint warnings in `junit6`, `spring`
 and `quarkus`

The whole reactor now builds clean under doclint, errors and warnings
both.

Most of the 35 were the `AbstractBrowserlessExtension` builder helpers
and the undocumented default constructor of every extension, test base,
lookup initializer and security customizer; those classes now declare an
explicit constructor. The rest were the public fields and constructors of
the Spring mocks.

Also replaces a `{@link #reload()}` that pointed into a package-private
class, which javadoc cannot link to, with `{@code reload()}`.
---
 CONVENTIONS.md                                |  6 +-
 de-kotlin-plan.md                             | 12 ++-
 guidelines/documenting.md                     |  7 +-
 .../AbstractBrowserlessExtension.java         | 96 ++++++++++++++++++-
 .../vaadin/browserless/BrowserlessTest.java   |  6 ++
 .../BrowserlessTestConfigExtension.java       |  6 ++
 .../browserless/TreeOnFailureExtension.java   |  6 ++
 .../quarkus/QuarkusBrowserlessTest.java       |  6 ++
 .../QuarkusSecurityContextHandler.java        |  6 ++
 .../quarkus/QuarkusSecurityCustomizer.java    |  6 ++
 .../quarkus/QuarkusTestLookupInitializer.java |  6 ++
 ...rowserlessTestSpringLookupInitializer.java |  6 ++
 .../browserless/SpringBrowserlessTest.java    |  6 ++
 .../SpringSecurityContextHandler.java         |  6 ++
 .../browserless/mocks/MockSpringServlet.java  | 19 ++++
 .../mocks/MockSpringServletService.java       | 15 +++
 .../mocks/MockSpringVaadinSession.java        | 11 +++
 .../mocks/MockWebApplicationContext.java      |  9 ++
 .../SpringSecurityRequestCustomizer.java      |  6 ++
 19 files changed, 229 insertions(+), 12 deletions(-)

diff --git a/CONVENTIONS.md b/CONVENTIONS.md
index 5460c6a9..3f391cab 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -148,8 +148,10 @@ commit messages.
 
 In a tester, spell cross-package `@link` and `@throws` targets out in full:
 `locator-processor` copies the Javadoc into the generated `*Locator`, which has
-no imports. `shared` builds clean under doclint, so every published member needs
-a description, its `@param`s and its `@return`.
+no imports. Every module builds clean under doclint, warnings included, so every
+published member needs a description, its `@param`s and its `@return` — a class
+that would otherwise get an undocumented default constructor declares an
+explicit one.
 
 See [`guidelines/documenting.md`](guidelines/documenting.md).
 
diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index 4cb5bef3..14820386 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -245,8 +245,8 @@ not the `tests="N"` attribute, which DynaTest under-reports. 1,448 before,
 
 ### Phase 7 — the doclint cleanup — done
 
-`shared` builds clean under doclint, errors and warnings both, and
-`<doclint>none</doclint>` is gone from its pom.
+Every module builds clean under doclint, errors and warnings both, and
+`<doclint>none</doclint>` is gone from `shared`'s pom.
 
 The "roughly 200 issues" the Phase 5 note quoted was **javadoc's output cap**,
 not the count: the tool stops after 100 errors and 100 warnings. The real
@@ -272,9 +272,11 @@ person reads a count rather than a ceiling.
   `[_rowSequence]`, `*skip*` — which render as literal brackets and asterisks.
   Those are now `{@link}`, `{@code}` and `<em>`.
 
-Still open, and untouched here because the ask was `shared`: `junit6`, `spring`
-and `quarkus` report 36 doclint warnings between them. They never failed a
-build, because doclint warnings do not.
+`junit6`, `spring` and `quarkus` accounted for a further 35 warnings — mostly
+the `AbstractBrowserlessExtension` builder helpers and the undocumented default
+constructor of every extension, test base and lookup initializer. They never
+failed a build, because doclint warnings do not, which is how they went
+unnoticed.
 
 ## Breaking changes
 
diff --git a/guidelines/documenting.md b/guidelines/documenting.md
index 87a3ad57..f426fbf4 100644
--- a/guidelines/documenting.md
+++ b/guidelines/documenting.md
@@ -47,9 +47,10 @@ order:
   tester and fails there. Write `{@link com.vaadin.flow.component.html.Span
   Span}`. Same-package names and `{@link #member}` are fine — the processor
   rewrites the latter to point back at the tester.
-- **Every published member needs a comment.** `shared` builds clean under
-  doclint, so a missing `@param`, `@return` or description shows up in the
-  `-Djavadocs` build.
+- **Every published member needs a comment.** Every module builds clean under
+  doclint, warnings included, so a missing `@param`, `@return` or description
+  shows up in the `-Djavadocs` build. A class that would otherwise get an
+  undocumented default constructor declares an explicit one.
 
 ## Documenting the mocks
 
diff --git a/junit6/src/main/java/com/vaadin/browserless/AbstractBrowserlessExtension.java b/junit6/src/main/java/com/vaadin/browserless/AbstractBrowserlessExtension.java
index 13c113fe..5a325cc0 100644
--- a/junit6/src/main/java/com/vaadin/browserless/AbstractBrowserlessExtension.java
+++ b/junit6/src/main/java/com/vaadin/browserless/AbstractBrowserlessExtension.java
@@ -56,58 +56,147 @@ abstract class AbstractBrowserlessExtension
 
     // --- Protected builder helpers ---
 
+    /**
+     * Adds the packages of the given classes to the packages scanned for
+     * routes.
+     *
+     * @param classes
+     *            classes whose packages are scanned
+     */
     protected void addViewPackages(Class<?>... classes) {
         Stream.of(classes).map(Class::getPackageName)
                 .forEach(viewPackages::add);
     }
 
+    /**
+     * Adds the given packages to the packages scanned for routes.
+     *
+     * @param packages
+     *            the packages to scan
+     */
     protected void addViewPackages(String... packages) {
         viewPackages.addAll(Arrays.asList(packages));
     }
 
+    /**
+     * Registers extra service classes with the lookup initializer.
+     *
+     * @param serviceClasses
+     *            the service classes to register
+     */
     protected void addServices(Class<?>... serviceClasses) {
         configuration.withLookupServices(serviceClasses);
     }
 
+    /**
+     * Adds the given packages to the packages scanned for component testers.
+     *
+     * @param packages
+     *            the packages to scan
+     */
     protected void addComponentTesterPackages(String... packages) {
         componentTesterPackages.addAll(Arrays.asList(packages));
     }
 
+    /**
+     * Adds the packages of the given classes to the packages scanned for
+     * component testers.
+     *
+     * @param classes
+     *            classes whose packages are scanned
+     */
     protected void addComponentTesterPackages(Class<?>... classes) {
         Stream.of(classes).map(Class::getPackageName)
                 .forEach(componentTesterPackages::add);
     }
 
+    /**
+     * Sets an application property on the deployment configuration.
+     *
+     * @param name
+     *            the property name
+     * @param value
+     *            the property value
+     */
     protected void addApplicationProperty(String name, String value) {
         configuration.withApplicationProperty(name, value);
     }
 
+    /**
+     * Sets several application properties on the deployment configuration.
+     *
+     * @param properties
+     *            the properties to set
+     */
     protected void addApplicationProperties(Map<String, String> properties) {
         configuration.withApplicationProperties(properties);
     }
 
+    /**
+     * Turns on the given feature flags.
+     *
+     * @param featureIds
+     *            the ids of the features to turn on
+     */
     protected void addFeatureFlags(String... featureIds) {
         configuration.withFeatureFlags(featureIds);
     }
 
+    /**
+     * Turns on the given feature flags.
+     *
+     * @param features
+     *            the features to turn on
+     */
     protected void addFeatureFlags(Feature... features) {
         configuration.withFeatureFlags(features);
     }
 
+    /**
+     * Turns the given feature flag on or off.
+     *
+     * @param featureId
+     *            the id of the feature
+     * @param enabled
+     *            whether the feature is on
+     */
     protected void addFeatureFlag(String featureId, boolean enabled) {
         configuration.withFeatureFlag(featureId, enabled);
     }
 
+    /**
+     * Turns the given feature flag on or off.
+     *
+     * @param feature
+     *            the feature
+     * @param enabled
+     *            whether the feature is on
+     */
     protected void addFeatureFlag(Feature feature, boolean enabled) {
         configuration.withFeatureFlag(feature, enabled);
     }
 
+    /**
+     * Merges the given configuration into the one this extension builds.
+     *
+     * @param configuration
+     *            the configuration to merge in
+     */
     protected void addConfiguration(BrowserlessConfiguration configuration) {
         this.configuration.withConfiguration(configuration);
     }
 
     // --- Lifecycle callbacks ---
 
+    /**
+     * Creates the Vaadin environment for a test, arming the cleanup action
+     * first so that a setup that fails halfway through still tears down.
+     *
+     * @param testInstance
+     *            the test instance, if the test has one
+     * @param ctx
+     *            the JUnit extension context
+     */
     protected void doInit(Object testInstance, ExtensionContext ctx) {
         BrowserlessConfiguration effectiveConfiguration = BrowserlessTestConfigExtension
                 .resolveConfiguration(ctx, configuration.build());
@@ -140,6 +229,9 @@ protected boolean isClassScoped() {
         return false;
     }
 
+    /**
+     * Runs the cleanup action armed by {@code doInit}, if there is one.
+     */
     protected void doCleanup() {
         if (cleanupAction != null) {
             cleanupAction.run();
@@ -352,8 +444,8 @@ public HasElement reload() {
     }
 
     /**
-     * Simulates a page reload (see {@link #reload()}) and verifies the
-     * resulting view is of the expected type.
+     * Simulates a page reload (see {@code reload()}) and verifies the resulting
+     * view is of the expected type.
      *
      * @param expectedTarget
      *            the expected view class after reload
diff --git a/junit6/src/main/java/com/vaadin/browserless/BrowserlessTest.java b/junit6/src/main/java/com/vaadin/browserless/BrowserlessTest.java
index 14c984b2..b493b3b0 100644
--- a/junit6/src/main/java/com/vaadin/browserless/BrowserlessTest.java
+++ b/junit6/src/main/java/com/vaadin/browserless/BrowserlessTest.java
@@ -130,6 +130,12 @@
 public abstract class BrowserlessTest extends BaseBrowserlessTest
         implements TesterWrappers {
 
+    /**
+     * Creates the test base; subclasses are instantiated by the test engine.
+     */
+    protected BrowserlessTest() {
+    }
+
     @BeforeEach
     @Override
     protected void initVaadinEnvironment() {
diff --git a/junit6/src/main/java/com/vaadin/browserless/BrowserlessTestConfigExtension.java b/junit6/src/main/java/com/vaadin/browserless/BrowserlessTestConfigExtension.java
index 5093fcf2..3b8c306d 100644
--- a/junit6/src/main/java/com/vaadin/browserless/BrowserlessTestConfigExtension.java
+++ b/junit6/src/main/java/com/vaadin/browserless/BrowserlessTestConfigExtension.java
@@ -41,6 +41,12 @@
 public class BrowserlessTestConfigExtension
         implements BeforeEachCallback, AfterEachCallback {
 
+    /**
+     * Creates the extension; JUnit instantiates it through {@code @ExtendWith}.
+     */
+    public BrowserlessTestConfigExtension() {
+    }
+
     @Override
     public void beforeEach(ExtensionContext context) {
         browserlessTest(context).ifPresent(test -> test
diff --git a/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java b/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
index e9000f12..5eb2f45c 100644
--- a/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
+++ b/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
@@ -32,6 +32,12 @@
  */
 public class TreeOnFailureExtension implements AfterTestExecutionCallback {
 
+    /**
+     * Creates the extension; JUnit instantiates it through {@code @ExtendWith}.
+     */
+    public TreeOnFailureExtension() {
+    }
+
     @Override
     public void afterTestExecution(ExtensionContext extensionContext) {
         boolean testFailed = extensionContext.getExecutionException()
diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusBrowserlessTest.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusBrowserlessTest.java
index 9f128226..1cadb10f 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusBrowserlessTest.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusBrowserlessTest.java
@@ -87,6 +87,12 @@
 public abstract class QuarkusBrowserlessTest extends BaseBrowserlessTest
         implements TesterWrappers {
 
+    /**
+     * Creates the test base; subclasses are instantiated by the test engine.
+     */
+    protected QuarkusBrowserlessTest() {
+    }
+
     @Override
     protected final String testingEngine() {
         return "JUnit 6";
diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityContextHandler.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityContextHandler.java
index 138e8ddb..9310801a 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityContextHandler.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityContextHandler.java
@@ -42,6 +42,12 @@
 public class QuarkusSecurityContextHandler
         implements SecurityContextHandler<SecurityIdentity> {
 
+    /**
+     * Creates the handler.
+     */
+    public QuarkusSecurityContextHandler() {
+    }
+
     @Override
     public void setupAuthentication(SecurityIdentity credentials) {
         SecurityIdentity identity = credentials != null ? credentials
diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityCustomizer.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityCustomizer.java
index 48c6689f..b971dd92 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityCustomizer.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusSecurityCustomizer.java
@@ -30,6 +30,12 @@
  */
 public class QuarkusSecurityCustomizer implements MockRequestCustomizer {
 
+    /**
+     * Creates the customizer; Vaadin looks it up through the service loader.
+     */
+    public QuarkusSecurityCustomizer() {
+    }
+
     @Override
     public void apply(MockRequest request) {
         request.principalProvider(() -> {
diff --git a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusTestLookupInitializer.java b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusTestLookupInitializer.java
index 501dcb38..1984b85e 100644
--- a/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusTestLookupInitializer.java
+++ b/quarkus/src/main/java/com/vaadin/browserless/quarkus/QuarkusTestLookupInitializer.java
@@ -37,6 +37,12 @@
  */
 public class QuarkusTestLookupInitializer extends LookupInitializer {
 
+    /**
+     * Creates the initializer; Vaadin looks it up through the service loader.
+     */
+    public QuarkusTestLookupInitializer() {
+    }
+
     @Override
     public void initialize(VaadinContext context,
             Map<Class<?>, Collection<Class<?>>> services,
diff --git a/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java b/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java
index 495eea82..1bca8fd2 100644
--- a/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java
+++ b/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java
@@ -47,6 +47,12 @@
 public class BrowserlessTestSpringLookupInitializer
         extends SpringLookupInitializer implements TestExecutionListener {
 
+    /**
+     * Creates the initializer; Vaadin looks it up through the service loader.
+     */
+    public BrowserlessTestSpringLookupInitializer() {
+    }
+
     private static final ThreadLocal<ApplicationContext> applicationContext = new ThreadLocal<>();
 
     @Override
diff --git a/spring/src/main/java/com/vaadin/browserless/SpringBrowserlessTest.java b/spring/src/main/java/com/vaadin/browserless/SpringBrowserlessTest.java
index 3f726c21..15b178dc 100644
--- a/spring/src/main/java/com/vaadin/browserless/SpringBrowserlessTest.java
+++ b/spring/src/main/java/com/vaadin/browserless/SpringBrowserlessTest.java
@@ -69,6 +69,12 @@
 public abstract class SpringBrowserlessTest extends BaseBrowserlessTest
         implements TesterWrappers {
 
+    /**
+     * Creates the test base; subclasses are instantiated by the test engine.
+     */
+    protected SpringBrowserlessTest() {
+    }
+
     @Autowired
     private ApplicationContext applicationContext;
 
diff --git a/spring/src/main/java/com/vaadin/browserless/SpringSecurityContextHandler.java b/spring/src/main/java/com/vaadin/browserless/SpringSecurityContextHandler.java
index bbbef3ba..79a4a809 100644
--- a/spring/src/main/java/com/vaadin/browserless/SpringSecurityContextHandler.java
+++ b/spring/src/main/java/com/vaadin/browserless/SpringSecurityContextHandler.java
@@ -46,6 +46,12 @@
 public class SpringSecurityContextHandler
         implements SecurityContextHandler<Authentication> {
 
+    /**
+     * Creates the handler.
+     */
+    public SpringSecurityContextHandler() {
+    }
+
     @Override
     public void setupAuthentication(Authentication credentials) {
         // SecurityContextHolder.getContext() never returns null — the strategy
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
index 254f47b6..e019651f 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
@@ -53,13 +53,32 @@
  */
 public class MockSpringServlet extends SpringServlet {
 
+    /**
+     * The routes registered when the service is created.
+     */
     @NonNull
     public final Routes routes;
+    /**
+     * The Spring context the views are instantiated from.
+     */
     @NonNull
     public final ApplicationContext ctx;
+    /**
+     * Produces the UI instances the sessions of this servlet hand out.
+     */
     @NonNull
     public final UIFactory uiFactory;
 
+    /**
+     * Creates the servlet.
+     *
+     * @param routes
+     *            the routes to register
+     * @param ctx
+     *            the Spring context the views are instantiated from
+     * @param uiFactory
+     *            produces the UI instances the sessions hand out
+     */
     public MockSpringServlet(@NonNull Routes routes,
 
             @NonNull ApplicationContext ctx, @NonNull UIFactory uiFactory) {
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
index 9bb49ec4..a4e76ef9 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServletService.java
@@ -43,9 +43,24 @@
  * @since 1.0
  */
 public class MockSpringServletService extends SpringVaadinServletService {
+    /**
+     * Produces the UI instances the sessions of this service hand out.
+     */
     @NonNull
     private final UIFactory uiFactory;
 
+    /**
+     * Creates the service.
+     *
+     * @param servlet
+     *            the servlet the service belongs to
+     * @param deploymentConfiguration
+     *            the deployment configuration to use
+     * @param ctx
+     *            the Spring context the views are instantiated from
+     * @param uiFactory
+     *            produces the UI instances the sessions hand out
+     */
     public MockSpringServletService(@NonNull MockSpringServlet servlet,
             @NonNull DeploymentConfiguration deploymentConfiguration,
             @NonNull ApplicationContext ctx, @NonNull UIFactory uiFactory) {
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
index 84dbd8c0..6e9919a6 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringVaadinSession.java
@@ -40,9 +40,20 @@
  * @since 1.0
  */
 public class MockSpringVaadinSession extends VaadinSession {
+    /**
+     * Produces the UI instances this session hands out.
+     */
     @NonNull
     private final UIFactory uiFactory;
 
+    /**
+     * Creates the session.
+     *
+     * @param service
+     *            the service the session belongs to
+     * @param uiFactory
+     *            produces the UI instances this session hands out
+     */
     public MockSpringVaadinSession(@NonNull VaadinService service,
             @NonNull UIFactory uiFactory) {
         super(service);
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java
index f78c7ad5..b83b2943 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockWebApplicationContext.java
@@ -50,6 +50,15 @@ public class MockWebApplicationContext implements WebApplicationContext {
     private final ApplicationContext appCtx;
     private final ServletContext servletContext;
 
+    /**
+     * Wraps a Spring context so that it also answers as a
+     * {@code WebApplicationContext}.
+     *
+     * @param appCtx
+     *            the context the calls are forwarded to
+     * @param servletContext
+     *            the servlet context to report
+     */
     public MockWebApplicationContext(ApplicationContext appCtx,
             ServletContext servletContext) {
         this.appCtx = appCtx;
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java b/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
index 49e7df5f..9993b815 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
@@ -26,6 +26,12 @@
  */
 public class SpringSecurityRequestCustomizer implements MockRequestCustomizer {
 
+    /**
+     * Creates the customizer; Vaadin looks it up through the service loader.
+     */
+    public SpringSecurityRequestCustomizer() {
+    }
+
     @Override
     public void apply(MockRequest request) {
         MockSpringServlet.applySpringSecurityIfPresent(request);

From c0cb7c6ab92b5a22f983fdd1f4f243030220eaff Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 19:33:13 +0000
Subject: [PATCH 10/13] refactor!: hide the `MockSpringServlet` and
 `SessionObjects` fields
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`MockSpringServlet.routes`, `.ctx` and `.uiFactory` were public final
fields. They are private now, behind `getRoutes()`,
`getApplicationContext()` and `getUiFactory()` — the shape
`MockVaadinServlet`, `MockService` and `MockVaadinSession` already use.
Reading `servlet.routes`, `servlet.ctx` or `servlet.uiFactory` stops
compiling; call the getter instead. There were no such callers in this
repository, and the class is marked internal.

`SessionObjects` gets the same treatment, but there it is a regression
fix rather than a change: it was a Kotlin `data class`, so the released
artifact exposes private fields plus `getSession()` and friends. The port
to Java flattened the four `val`s into public fields while keeping the
getters, which added API no release ever had. Its compiled surface now
matches 1.2.0-beta1 again.
---
 de-kotlin-plan.md                             |  5 +++
 .../browserless/internal/MockVaadin.java      | 18 ++++----
 .../browserless/internal/SessionObjects.java  | 11 +++--
 .../browserless/mocks/MockSpringServlet.java  | 43 ++++++++++++++++---
 4 files changed, 59 insertions(+), 18 deletions(-)

diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index 14820386..a9e293df 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -454,6 +454,11 @@ Reading the Kotlin source is not enough to know what the published API is: a
 a `object` adds an `INSTANCE`. Phase 1's first pass flattened properties into
 public fields in ten classes before this check caught it.
 
+The check only covers the classes it is pointed at. `SessionObjects`, a Kotlin
+`data class`, was flattened the same way in Phase 4 and slipped through until
+after the port; its four `val`s are private again, so its surface matches the
+released one.
+
 Build `main` in a throwaway worktree and diff the compiled surface:
 
 ```bash
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
index ac40f9e5..3b418eb1 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
@@ -647,19 +647,19 @@ private static void createSession(ServletContext ctx, UIFactory uiFactory) {
         SessionObjects objs = createSessionObjects(service);
 
         // install thread-locals
-        strongRefReq.set(objs.request);
-        CurrentInstance.set(VaadinRequest.class, objs.request);
-        VaadinSession.setCurrent(objs.session);
-        strongRefSession.set(objs.session);
-        strongRefRes.set(objs.response);
-        CurrentInstance.set(VaadinResponse.class, objs.response);
+        strongRefReq.set(objs.getRequest());
+        CurrentInstance.set(VaadinRequest.class, objs.getRequest());
+        VaadinSession.setCurrent(objs.getSession());
+        strongRefSession.set(objs.getSession());
+        strongRefRes.set(objs.getResponse());
+        CurrentInstance.set(VaadinResponse.class, objs.getResponse());
 
         // fire session init listeners
-        fireSessionInitListeners(service,
-                new SessionInitEvent(service, objs.session, objs.request));
+        fireSessionInitListeners(service, new SessionInitEvent(service,
+                objs.getSession(), objs.getRequest()));
 
         // create UI
-        createUI(uiFactory, objs.session);
+        createUI(uiFactory, objs.getSession());
     }
 
     /**
diff --git a/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java b/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
index c22617e6..32ba3a0c 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
@@ -35,19 +35,22 @@ public final class SessionObjects {
     /**
      * The session.
      */
-    public final VaadinSession session;
+    private final VaadinSession session;
+
     /**
      * The request bound to the session.
      */
-    public final VaadinRequest request;
+    private final VaadinRequest request;
+
     /**
      * The response bound to the session.
      */
-    public final VaadinResponse response;
+    private final VaadinResponse response;
+
     /**
      * The HTTP session the Vaadin session is stored in.
      */
-    public final MockHttpSession httpSession;
+    private final MockHttpSession httpSession;
 
     /**
      * Groups the four objects that make up one mocked user's session.
diff --git a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
index e019651f..df23c8eb 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
@@ -41,8 +41,8 @@
 import com.vaadin.flow.spring.SpringServlet;
 
 /**
- * Makes sure that the {@link #routes} are properly registered, and that
- * {@link MockSpringServletService} is used instead of vanilla
+ * Makes sure that the {@link #getRoutes() routes} are properly registered, and
+ * that {@link MockSpringServletService} is used instead of vanilla
  * {@link com.vaadin.flow.spring.SpringVaadinServletService}.
  *
  * <p>
@@ -57,17 +57,19 @@ public class MockSpringServlet extends SpringServlet {
      * The routes registered when the service is created.
      */
     @NonNull
-    public final Routes routes;
+    private final Routes routes;
+
     /**
      * The Spring context the views are instantiated from.
      */
     @NonNull
-    public final ApplicationContext ctx;
+    private final ApplicationContext ctx;
+
     /**
      * Produces the UI instances the sessions of this servlet hand out.
      */
     @NonNull
-    public final UIFactory uiFactory;
+    private final UIFactory uiFactory;
 
     /**
      * Creates the servlet.
@@ -88,6 +90,37 @@ public MockSpringServlet(@NonNull Routes routes,
         this.uiFactory = uiFactory;
     }
 
+    /**
+     * Returns the routes this servlet registers.
+     *
+     * @return the routes
+     */
+    @NonNull
+    public Routes getRoutes() {
+        return routes;
+    }
+
+    /**
+     * Returns the Spring context the views are instantiated from.
+     *
+     * @return the application context
+     */
+    @NonNull
+    public ApplicationContext getApplicationContext() {
+        return ctx;
+    }
+
+    /**
+     * Returns the factory producing the {@link com.vaadin.flow.component.UI} of
+     * every session this servlet's service creates.
+     *
+     * @return the UI factory
+     */
+    @NonNull
+    public UIFactory getUiFactory() {
+        return uiFactory;
+    }
+
     @Override
     protected DeploymentConfiguration createDeploymentConfiguration()
             throws ServletException {

From d9a47c9600e79cea8fd46c027956cad1cb813c32 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 19:46:12 +0000
Subject: [PATCH 11/13] docs: fix the doclint issues in the grid context menu
 testers

`GridContextMenuTester` and `GridTester.contextMenu` landed while
`shared` still had `<doclint>none</doclint>`, so their Javadoc was never
checked: 25 `<p/>` tags, which propagate into four generated `*Locator`
files, and a `{@link GridContextMenuTester#open()}` that does not resolve
once copied into a generated locator, since that file has no imports.

Also documents `GridUtils._internalId`, which became public for
`GridContextMenuSupport` to call from another package.
---
 .../browserless/component/GridUtils.java      |  4 ++
 .../flow/component/grid/GridTester.java       |  5 +-
 .../contextmenu/GridContextMenuTester.java    | 48 +++++++++----------
 3 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java b/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
index 52fe8cb6..7dfe2933 100644
--- a/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
+++ b/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
@@ -1786,6 +1786,10 @@ public static <T> void _deselectAll(Grid<T> grid) {
      * Returns the column's Internal ID. Not related to
      * {@link Grid.Column#getKey()} in any way. Auto-generated by the Grid. Not
      * really useful; mostly used internally by Vaadin.
+     *
+     * @param column
+     *            the column to read
+     * @return the column's internal id
      */
     public static String _internalId(Grid.Column<?> column) {
         try {
diff --git a/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java b/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
index 1f6f6eb3..7d2f9d48 100644
--- a/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/grid/GridTester.java
@@ -820,10 +820,11 @@ private void doSort(SortDirection currentDirection, Grid.Column<Y> col) {
 
     /**
      * Gets a tester for the context menu of this grid, targeting the given row.
-     * <p/>
+     * <p>
      * The index is 0 based and counts the rows the user sees. The menu is not
      * opened, so that assertions can be made on it first; open it with
-     * {@link GridContextMenuTester#open()}.
+     * {@link com.vaadin.flow.component.grid.contextmenu.GridContextMenuTester#open()
+     * GridContextMenuTester.open()}.
      *
      * <pre>
      * var menu = test(grid).contextMenu(0);
diff --git a/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java b/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java
index 8ec346d4..756c6f11 100644
--- a/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java
+++ b/shared/src/main/java/com/vaadin/flow/component/grid/contextmenu/GridContextMenuTester.java
@@ -32,13 +32,13 @@
 
 /**
  * Tester for GridContextMenu components.
- * <p/>
+ * <p>
  * A grid context menu is always about a row: the user right-clicks a row, and
  * the events the menu fires report that row. {@link #open(int)} therefore takes
  * the row to open the menu on, addressed by its zero-based index among the rows
  * the user sees, the same way {@link com.vaadin.flow.component.grid.GridTester}
  * addresses rows.
- * <p/>
+ * <p>
  * The menu content is not part of the UI until the menu opens, so
  * {@code clickItem(...)} and {@link #find(Class)} only see the items of an open
  * menu.
@@ -57,7 +57,7 @@ public class GridContextMenuTester<T extends GridContextMenu<Y>, Y>
 
     /**
      * Wrap grid context menu for testing.
-     * <p/>
+     * <p>
      * The menu targets no row, so it has to be opened with {@link #open(int)}.
      *
      * @param component
@@ -70,7 +70,7 @@ public GridContextMenuTester(T component) {
 
     /**
      * Wrap grid context menu for testing, targeting the given row.
-     * <p/>
+     * <p>
      * The index is 0 based and counts the rows the user sees. Opening the menu
      * with {@link #open()} opens it on that row.
      *
@@ -87,12 +87,12 @@ public GridContextMenuTester(T component, int row) {
     /**
      * Opens the context menu on the row it currently targets, as if the user
      * had asked for it in the browser.
-     * <p/>
+     * <p>
      * The target row is the one given to
      * {@link com.vaadin.flow.component.grid.GridTester#contextMenu(int)}, so
      * this method is the counterpart of that entry point. Use
      * {@link #open(int)} to open the menu on a row directly.
-     * <p/>
+     * <p>
      * It does not render any client-side overlay, it only simulates the
      * server-side state changes that opening the menu produces: the menu is
      * attached to the UI, so its items become findable and clickable, and a
@@ -114,7 +114,7 @@ public void open() {
     /**
      * Opens the context menu on the given row, as if the user had asked for it
      * in the browser.
-     * <p/>
+     * <p>
      * The index is 0 based and counts the rows the user sees. The row is
      * reported by the events the menu fires, so
      * {@code GridContextMenuItemClickEvent.getItem()} and
@@ -135,7 +135,7 @@ public void open(int row) {
     /**
      * Opens the context menu on the given row and column, as if the user had
      * asked for it in the browser.
-     * <p/>
+     * <p>
      * The column is reported by
      * {@code GridContextMenuOpenedEvent.getColumnId()}.
      *
@@ -188,17 +188,17 @@ public void close() {
 
     /**
      * Simulates a click on the item that matches the given text.
-     * <p/>
+     * <p>
      * For a nested menu item, provide the text of each menu item in the
      * hierarchy.
-     * <p/>
+     * <p>
      * The path to the menu item must reflect what is seen in the browser,
      * meaning that hidden items are ignored. If there are multiple visible
      * items at the same level with the same text, an
      * {@link IllegalStateException} is thrown because the target is ambiguous.
      * Disabled or invisible items cannot be clicked and will also cause an
      * {@link IllegalStateException}.
-     * <p/>
+     * <p>
      * The menu has to be open, since its items are not part of the UI before
      * that.
      *
@@ -221,15 +221,15 @@ public void clickItem(String topLevelText, String... nestedItemsText) {
 
     /**
      * Simulates a click on the item at the given position in the menu.
-     * <p/>
+     * <p>
      * For a nested menu item, provide the position of each sub menu that should
      * be navigated to reach the requested item.
-     * <p/>
+     * <p>
      * Positions are zero-based and refer only to items that are visible at each
      * menu level, i.e. hidden items are ignored (the same way as in the
      * browser). Disabled or invisible items cannot be clicked and will cause an
      * {@link IllegalStateException}.
-     * <p/>
+     * <p>
      * The menu has to be open, since its items are not part of the UI before
      * that.
      *
@@ -253,7 +253,7 @@ public void clickItem(int topLevelPosition, int... nestedItemsPositions) {
 
     /**
      * Checks if the checkable menu item matching given text is checked.
-     * <p/>
+     * <p>
      * For a nested menu item, provide the text of each menu item in the
      * hierarchy.
      *
@@ -283,7 +283,7 @@ public boolean isItemChecked(String topLevelText,
 
     /**
      * Checks if the checkable menu item at given position is checked.
-     * <p/>
+     * <p>
      * For a nested menu item, provide the position of each sub menu that should
      * be navigated to reach the requested item.
      *
@@ -314,7 +314,7 @@ public boolean isItemChecked(int topLevelPosition,
 
     /**
      * Gets the tooltip text of the menu item matching the given text.
-     * <p/>
+     * <p>
      * For a nested menu item, provide the text of each menu item in the
      * hierarchy.
      *
@@ -340,7 +340,7 @@ public String getItemTooltipText(String topLevelText,
 
     /**
      * Gets the tooltip text of the menu item at the given position in the menu.
-     * <p/>
+     * <p>
      * For a nested menu item, provide the position of each sub menu that should
      * be navigated to reach the requested item.
      *
@@ -367,16 +367,16 @@ public String getItemTooltipText(int topLevelPosition,
 
     /**
      * Gets the texts of the menu items, as the browser shows them.
-     * <p/>
+     * <p>
      * Hidden items are ignored, so the returned texts are aligned with the
      * positions used by {@link #clickItem(int, int...)}. A text can also be
      * given to {@link #clickItem(String, String...)}, as long as it identifies
      * a single enabled item: a text that several visible items share is
      * ambiguous, and a disabled item cannot be clicked.
-     * <p/>
+     * <p>
      * An item created from a component has no text of its own, and is reported
      * as an empty string. Use {@link #find(Class)} to reach such an item.
-     * <p/>
+     * <p>
      * The menu has to be open, since its items are not part of the UI before
      * that. The items are the ones the menu offers for the row it was opened
      * on, so a dynamic content handler has run by then.
@@ -410,13 +410,13 @@ public List<String> getItemTexts() {
     /**
      * Gets the texts of the items of the sub menu of the item matching the
      * given text, as the browser shows them.
-     * <p/>
+     * <p>
      * For a nested sub menu, provide the text of each menu item in the
      * hierarchy, the same way as in {@link #clickItem(String, String...)}.
-     * <p/>
+     * <p>
      * Hidden items are ignored at every level, both when following the path and
      * in the returned texts.
-     * <p/>
+     * <p>
      * The menu has to be open, since its items are not part of the UI before
      * that.
      *

From 419242bab068147d7f9bd684c30a23ed1779be78 Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Fri, 18 Sep 2026 19:51:02 +0000
Subject: [PATCH 12/13] test: restore the `MockVaadinTest` tests the Kotlin
 port dropped

`MockVaadinTest.kt` carried five `/* TODO: uncomment after importing
Locator APIs */` blocks, eight tests in all, and the port to Java dropped
them silently. They were not running, so the testcase-name check that
guarded the rest of the port could not see them.

The Java `Locator` they were waiting on exists now, so they are back:
navigation in a mocked environment, `beforeClientResponse` running once
per lookup, a dialog's contents being reachable while it is open, reload
re-navigating to the current URL, and the thread-pool example.
---
 de-kotlin-plan.md                             |   9 +
 .../browserless/internal/MockVaadinTest.java  | 180 ++++++++++++++++++
 2 files changed, 189 insertions(+)

diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
index a9e293df..f69e7fa2 100644
--- a/de-kotlin-plan.md
+++ b/de-kotlin-plan.md
@@ -243,6 +243,15 @@ block leaves no trace. Every step was checked by comparing the *multiset of
 not the `tests="N"` attribute, which DynaTest under-reports. 1,448 before,
 1,448 after, with all 225 renamed names pairing one-for-one.
 
+That check only sees tests that run. `MockVaadinTest.kt` carried five
+`/* TODO: uncomment after importing Locator APIs */` blocks, eight tests in
+all, and the port dropped them without a trace — navigation in a mocked
+environment, `beforeClientResponse` running once per lookup, a dialog's
+contents being reachable while it is open, reload re-navigating to the current
+URL, and the thread-pool example. The Java `Locator` they were waiting on
+exists, so they are back in `MockVaadinTest.java`. When a port deletes
+commented-out code, diff the comments too.
+
 ### Phase 7 — the doclint cleanup — done
 
 Every module builds clean under doclint, errors and warnings both, and
diff --git a/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java b/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java
index b30c3919..2f3f9afa 100644
--- a/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java
@@ -19,15 +19,20 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import com.example.base.HelloWorldView;
 import com.example.base.ParametrizedView;
+import com.example.base.WelcomeView;
 import com.example.base.child.ChildView;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
@@ -44,6 +49,7 @@
 import com.vaadin.flow.component.DetachEvent;
 import com.vaadin.flow.component.Text;
 import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.button.Button;
 import com.vaadin.flow.component.dialog.Dialog;
 import com.vaadin.flow.component.html.Div;
 import com.vaadin.flow.component.orderedlayout.VerticalLayout;
@@ -272,6 +278,31 @@ void closeUi_detachHappensOnlyWhenTheRequestIsDone() {
             assertFalse(UI.getCurrent().isAttached());
         }
 
+        @Test
+        void navigate_toAView_rendersIt() {
+            // MockVaadin.setup() navigates to "" while initializing the UI
+            Locator._get(Text.class, spec -> spec.setText("Welcome!"));
+
+            UI.getCurrent().navigate("helloworld");
+
+            Locator._get(Button.class,
+                    spec -> spec.setCaption("Hello, World!"));
+        }
+
+        @Test
+        void navigate_toAParametrizedView_rendersIt() {
+            UI.getCurrent().navigate("params/1");
+
+            Locator._get(ParametrizedView.class);
+        }
+
+        @Test
+        void navigate_toAViewWithAParentRoute_rendersIt() {
+            UI.getCurrent().navigate("parent/child");
+
+            Locator._get(ChildView.class);
+        }
+
         @Test
         void routeConfiguration_resolvesTheUrlsOfTheDiscoveredViews() {
             RouteConfiguration routeConfig = RouteConfiguration.forRegistry(
@@ -293,9 +324,62 @@ void routeConfiguration_resolvesTheUrlsOfTheDiscoveredViews() {
         }
     }
 
+    /**
+     * A lookup runs the blocks scheduled with {@link UI#beforeClientResponse},
+     * and runs each of them once. Tests <a href=
+     * "https://github.com/mvysny/karibu-testing/issues/11">karibu-testing#11</a>.
+     */
+    @Nested
+    class BeforeClientResponse {
+
+        @Test
+        void scheduledOnTheUi_runsOnceOnTheNextLookup() {
+            AtomicInteger ran = new AtomicInteger();
+            UI.getCurrent().beforeClientResponse(UI.getCurrent(),
+                    context -> assertEquals(1, ran.incrementAndGet(),
+                            "the block was supposed to be run only once"));
+
+            Locator._get(UI.class);
+
+            assertEquals(1, ran.get());
+        }
+
+        @Test
+        void scheduledOnANestedButton_runsOnceOnTheNextLookup() {
+            AtomicInteger ran = new AtomicInteger();
+            Button button = new Button();
+            UI.getCurrent().add(button);
+            UI.getCurrent()
+                    .beforeClientResponse(button, context -> assertEquals(1,
+                            ran.incrementAndGet(),
+                            "the block was supposed to be run only once"));
+
+            Locator._get(UI.class);
+
+            assertEquals(1, ran.get());
+        }
+    }
+
     @Nested
     class Dialogs {
 
+        @Test
+        void openDialog_putsItAndItsContentsInTheComponentTree() {
+            Locator._expectNone(Dialog.class);
+            Locator._expectNone(Div.class, spec -> spec.setText("Dialog Text"));
+
+            Dialog dialog = new Dialog(new Div(new Text("Dialog Text")));
+            dialog.open();
+
+            Locator._get(Dialog.class);
+            Locator._get(Div.class, spec -> spec.setText("Dialog Text"));
+
+            dialog.close();
+
+            Locator._expectNone(Div.class, spec -> spec.setText("Dialog Text"));
+            Locator._expectNone(Dialog.class);
+        }
+
         @Test
         void cleanupDialogs_closedDialog_isRemovedFromTheComponentTree() {
             Dialog dialog = new Dialog(new Div(new Text("Dialog Text")));
@@ -328,6 +412,25 @@ void reload_recreatesTheUi() {
             assertEquals(1, detachCalled.get());
         }
 
+        @Test
+        void reload_navigatesToTheCurrentUrl() {
+            Locator._get(WelcomeView.class);
+
+            UI.getCurrent().getPage().reload();
+
+            Locator._get(WelcomeView.class);
+
+            UI.getCurrent().navigate("helloworld");
+
+            Locator._expectNone(WelcomeView.class);
+            Locator._get(HelloWorldView.class);
+
+            UI.getCurrent().getPage().reload();
+
+            Locator._expectNone(WelcomeView.class);
+            Locator._get(HelloWorldView.class);
+        }
+
         @Test
         void reload_preservesTheSession() {
             VaadinSession session = VaadinSession.getCurrent();
@@ -514,6 +617,83 @@ void setup_inSeparateThreads_createsSeparateUisAndSessions()
             assertNotSame(firstSession.get(), secondSession.get());
         }
 
+        /**
+         * How an application runs browserless tests on a thread pool: the
+         * thread factory sets Vaadin up for every thread it creates, so each
+         * task gets its own UI and session.
+         */
+        @Test
+        void executorService_setsVaadinUpPerThread_andEveryTaskReachesTheService()
+                throws InterruptedException {
+            CallCountingService service = new CallCountingService();
+            ExecutorService executor = Executors.newFixedThreadPool(4,
+                    runnable -> new Thread(() -> {
+                        MockVaadin.setup(routes);
+                        runnable.run();
+                        MockVaadin.tearDown();
+                    }));
+            AtomicReference<Throwable> failure = new AtomicReference<>();
+
+            try {
+                for (int i = 0; i < 4; i++) {
+                    executor.submit(() -> {
+                        try {
+                            UI.getCurrent().navigate("helloworld");
+                            Locator._get(Button.class,
+                                    spec -> spec.setCaption("Hello, World!"))
+                                    .addClickListener(
+                                            event -> service.callService());
+                            ComponentUtils.serverClick(Locator._get(
+                                    Button.class,
+                                    spec -> spec.setCaption("Hello, World!")));
+                        } catch (Throwable t) {
+                            failure.compareAndSet(null, t);
+                        }
+                    });
+                }
+            } finally {
+                executor.shutdown();
+                assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS),
+                        "the tasks did not finish in time");
+            }
+
+            assertNull(failure.get(), () -> "a task failed: " + failure.get());
+            assertEquals(4, service.getCount());
+        }
+
+        /**
+         * Stands in for an application service: it only counts the calls, but
+         * it does so under a lock, so that a task running on the wrong thread
+         * or a lost Vaadin environment shows up as a wrong count.
+         */
+        private static class CallCountingService {
+
+            private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+
+            private int count;
+
+            void callService() {
+                lock.writeLock().lock();
+                try {
+                    Thread.sleep(10);
+                    count++;
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                } finally {
+                    lock.writeLock().unlock();
+                }
+            }
+
+            int getCount() {
+                lock.readLock().lock();
+                try {
+                    return count;
+                } finally {
+                    lock.readLock().unlock();
+                }
+            }
+        }
+
         private void newVaadinThread(AtomicReference<UI> ui,
                 AtomicReference<VaadinSession> session)
                 throws InterruptedException {

From 04797b4721645452869daa63b2ab0e24c643f81b Mon Sep 17 00:00:00 2001
From: Marco Collovati <mcollovati@gmail.com>
Date: Tue, 22 Sep 2026 14:16:17 +0000
Subject: [PATCH 13/13] fix: use the Java `PrettyPrintTree` in focus handling

The focus and blur simulation merged from main still called the Kotlin
facade `PrettyPrintTreeKt`, which no longer exists on this branch.
---
 .../src/main/java/com/vaadin/browserless/ComponentTester.java | 2 +-
 shared/src/main/java/com/vaadin/browserless/FocusTracker.java | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/shared/src/main/java/com/vaadin/browserless/ComponentTester.java b/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
index e600fc5a..3d8872c9 100644
--- a/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
+++ b/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
@@ -378,7 +378,7 @@ public void blur() {
     private void ensureComponentCanBeFocused() {
         if (!(component instanceof Focusable)) {
             throw new IllegalArgumentException(
-                    PrettyPrintTreeKt.toPrettyString(component)
+                    PrettyPrintTree.toPrettyString(component)
                             + " is not Focusable");
         }
         // Unlike other interactions, focus does not care about read-only: a
diff --git a/shared/src/main/java/com/vaadin/browserless/FocusTracker.java b/shared/src/main/java/com/vaadin/browserless/FocusTracker.java
index 5706c488..35a51445 100644
--- a/shared/src/main/java/com/vaadin/browserless/FocusTracker.java
+++ b/shared/src/main/java/com/vaadin/browserless/FocusTracker.java
@@ -23,7 +23,7 @@
 import org.slf4j.LoggerFactory;
 import tools.jackson.databind.node.ObjectNode;
 
-import com.vaadin.browserless.internal.PrettyPrintTreeKt;
+import com.vaadin.browserless.internal.PrettyPrintTree;
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.ComponentUtil;
 import com.vaadin.flow.component.Focusable;
@@ -248,7 +248,7 @@ private void updateFocused(Component expected, Component next) {
 
     private static UI uiOf(Component component) {
         return component.getUI()
-                .orElseThrow(() -> new IllegalStateException(PrettyPrintTreeKt
+                .orElseThrow(() -> new IllegalStateException(PrettyPrintTree
                         .toPrettyString(component)
                         + " is not attached to a UI, so it cannot take or lose focus"));
     }