diff --git a/.gitignore b/.gitignore
index 0be38590..91cf2899 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 target
 spotless-index
 .since-index
+*.iml
+.idea
diff --git a/CLAUDE.md b/CLAUDE.md
index 67522f20..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 for the older mock and internal layer in `shared/src/main/kotlin`
 - 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 +83,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 58769be8..5092e3cb 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -112,9 +112,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.
 
-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.
+This repository is written in Java; do not add Kotlin sources.
 
 See [`guidelines/architecture.md`](guidelines/architecture.md).
 
@@ -152,6 +150,13 @@ 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. 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).
 
 ## Testing
diff --git a/de-kotlin-plan.md b/de-kotlin-plan.md
new file mode 100644
index 00000000..f69e7fa2
--- /dev/null
+++ b/de-kotlin-plan.md
@@ -0,0 +1,499 @@
+# 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 |
+
+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`,
+`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 — done
+
+`BasicUtils`, `ComponentUtils`, `ElementUtils`, `DepthFirstTreeIterator`,
+`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
+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. 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` — 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). `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.
+
+`kotlin-reflect` was already dropped on `main` by `df099d0`, so this phase has
+no dependency change.
+
+### Phase 4 — `Locator` + `MockVaadin` — done
+
+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` +
+  `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.
+- `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 — 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()`
+  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`.
+- `_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` 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
+
+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.
+
+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
+`<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
+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>`.
+
+`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
+
+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.
+
+  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`.
+- **`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`.
+- **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,
+  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.
+
+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
+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/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/documenting.md b/guidelines/documenting.md
index b2b59a37..f426fbf4 100644
--- a/guidelines/documenting.md
+++ b/guidelines/documenting.md
@@ -41,6 +41,16 @@ 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.** 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/guidelines/repository.md b/guidelines/repository.md
index afed716e..61caa8de 100644
--- a/guidelines/repository.md
+++ b/guidelines/repository.md
@@ -5,14 +5,11 @@
 - **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.
 - **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.
-- **Dokka** for Javadoc in the mixed Java/Kotlin modules, `maven-javadoc-plugin`
-  elsewhere.
+- **maven-javadoc-plugin** for Javadoc in every module.
 
 ## Module structure
 
@@ -44,10 +41,10 @@ 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):
+- **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).
@@ -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/main/java/com/vaadin/browserless/AbstractBrowserlessExtension.java b/junit6/src/main/java/com/vaadin/browserless/AbstractBrowserlessExtension.java
index 5d0f0ed4..270e1ba6 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 b66456b1..5eb2f45c 100644
--- a/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
+++ b/junit6/src/main/java/com/vaadin/browserless/TreeOnFailureExtension.java
@@ -32,12 +32,18 @@
  */
 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()
                 .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/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..2f3f9afa
--- /dev/null
+++ b/junit6/src/test/java/com/vaadin/browserless/internal/MockVaadinTest.java
@@ -0,0 +1,825 @@
+/*
+ * 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.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;
+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.button.Button;
+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 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(
+                    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));
+        }
+    }
+
+    /**
+     * 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")));
+            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_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();
+            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());
+        }
+
+        /**
+         * 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 {
+            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 2dc6a545..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) { Button("foo").isTemplate }
-    }
-
-
-})
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 5495c25f..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/BasicUtilsTest.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.internal
-
-import com.github.mvysny.dynatest.DynaNodeGroup
-import com.github.mvysny.dynatest.DynaTestDsl
-import com.github.mvysny.karibudsl.v10.textField
-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
-import com.vaadin.browserless.expectThrows
-
-@DynaTestDsl
-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()
-            }
-        }
-        test("invisible textfield fails") {
-            expectThrows(
-                java.lang.IllegalStateException::class,
-                "The AttachedTextField\\[INVIS,.*] is not effectively visible".toRegex()
-            ) {
-                AttachedTextField().apply { isVisible = false }.checkEditableByUser()
-            }
-        }
-        test("non attached textfield fails") {
-            expectThrows(
-                java.lang.IllegalStateException::class,
-                "The TextField\\[.*] is not attached".toRegex()
-            ) {
-                TextField().checkEditableByUser()
-            }
-        }
-        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() }
-                }
-            }
-        }
-        test("textfield succeeds") {
-            AttachedTextField().checkEditableByUser()
-        }
-    }
-
-    group("expectNotEditableByUser") {
-        test("disabled textfield fails") {
-            AttachedTextField().apply { isEnabled = false }.expectNotEditableByUser()
-        }
-        test("invisible textfield fails") {
-            AttachedTextField().apply { isVisible = false }.expectNotEditableByUser()
-        }
-        test("textfield in invisible layout fails") {
-            VerticalLayout().apply {
-                isVisible = false
-                textField().also { it.expectNotEditableByUser() }
-            }
-        }
-        test("textfield succeeds") {
-            expectThrows(AssertionError::class, "The AttachedTextField\\[.*] is editable".toRegex()) {
-                AttachedTextField().expectNotEditableByUser()
-            }
-        }
-    }
-
-    group("fireDomEvent()") {
-        test("smoke") {
-            Div()._fireDomEvent("click")
-        }
-        test("listeners are called") {
-            val div = Div()
-            lateinit var event: DomEvent
-            div.element.addEventListener("click") { e -> event = e }
-            div._fireDomEvent("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) })
-            expect(20) { event.screenX }
-            expect(true) { event.isFromClient }
-        }
-    }
-
-    test("_focus") {
-        val f = AttachedTextField()
-        var called = false
-        f.addFocusListener { called = true }
-        f._focus()
-        expect(true) { called }
-    }
-
-    test("_blur") {
-        val f = AttachedTextField()
-        var called = false
-        f.addBlurListener { called = true }
-        f._blur()
-        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 076e8a80..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ComponentUtilsTest.kt
+++ /dev/null
@@ -1,280 +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.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")
-            t.removeFromParent()
-            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()
-            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()
-            fl.add(label)
-            expect(fl) { label.parent.orElse(null) }
-            expect(1) { fl.componentCount }
-        }
-    }
-
-    test("serverClick()") {
-        val b = Button()
-        var clicked = 0
-        b.addClickListener { clicked++ }
-        b.serverClick()
-        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") {
-        Button().addContextMenuListener({})
-    }
-
-    group("findAncestor") {
-        test("null on no parent") {
-            expect(null) { Button().findAncestor { false } }
-        }
-        test("null on no acceptance") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(null) { button.findAncestor { false } }
-        }
-        test("finds UI") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(UI.getCurrent()) { button.findAncestor { it is UI } }
-        }
-        test("doesn't find self") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(UI.getCurrent()) { button.findAncestor { true } }
-        }
-    }
-
-    group("findAncestorOrSelf") {
-        test("null on no parent") {
-            expect(null) { Button().findAncestorOrSelf { false } }
-        }
-        test("null on no acceptance") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(null) { button.findAncestorOrSelf { false } }
-        }
-        test("finds self") {
-            val button = Button()
-            UI.getCurrent().add(button)
-            expect(button) { button.findAncestorOrSelf { true } }
-        }
-    }
-
-    test("isNestedIn") {
-        expect(false) { Button().isNestedIn(UI.getCurrent()) }
-        val button = Button()
-        UI.getCurrent().add(button)
-        expect(true) { button.isNestedIn(UI.getCurrent()) }
-    }
-
-    test("isAttached") {
-        expect(true) { UI.getCurrent().isAttached() }
-        expect(false) { Button("foo").isAttached() }
-        expect(true) {
-            val button = Button()
-            UI.getCurrent().add(button)
-            button.isAttached()
-        }
-        UI.getCurrent().close()
-        expect(true) { UI.getCurrent().isAttached() }
-    }
-
-    test("insertBefore") {
-        val l = HorizontalLayout()
-        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() }
-    }
-
-    test("hasChildren") {
-        val l = HorizontalLayout()
-        expect(false) { l.hasChildren }
-        l.addComponentAsFirst(Span("first"))
-        expect(true) { l.hasChildren }
-        l.removeAll()
-        expect(false) { l.hasChildren }
-    }
-
-    /*
-    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") }
-            expect(true) {
-                div.classNames.containsAll(listOf("foo", "bar", "baz"))
-            }
-        }
-        test("addClassNames2(vararg)") {
-            val div = Div().apply { addClassNames2("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  ")
-            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  ")
-            expect(true) {
-                div.classNames.containsAll(listOf("three", "four"))
-            }
-        }
-        test("removeClassNames2") {
-            val div = Div().apply { addClassNames2("foo  bar    baz", "  one  two") }
-            div.removeClassNames2("  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  ")
-            expect(true) {
-                div.classNames.containsAll(listOf("foo", "one", "two"))
-            }
-        }
-    }
-
-    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 }
-        c = Button() // doesn't support placeholder
-        expect(null) { c.placeholder }
-        expectThrows(IllegalStateException::class, "Button doesn't support setting placeholder") {
-            c.placeholder = "foo"
-        }
-    }
-
-    group("label") {
-        test("TextField") {
-            val c: Component = TextField()
-            expect("") { c.label }
-            c.label = "foo"
-            expect("foo") { c.label }
-            c.label = ""
-            expect("") { c.label }
-        }
-        test("Checkbox") {
-            val c: Component = Checkbox()
-            expect("") { c.label }
-            c.label = "foo"
-            expect("foo") { c.label }
-            c.label = ""
-            expect("") { c.label }
-        }
-    }
-
-    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 }
-        val fl = FormLayout()
-        c = fl.addFormItem(Button(), "foo")
-        expect("foo") { c.caption }
-    }
-
-    test("Button.caption") {
-        val c = Button("foo")
-        expect("foo") { c.caption }
-        c.caption = ""
-        expect("") { c.caption }
-    }
-}
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 66a3cfc3..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) { root.walk().toList() }
-        expect(root) { root.walk().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 ec971faa..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ElementUtilsTest.kt
+++ /dev/null
@@ -1,117 +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.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 com.vaadin.browserless.expectList
-import kotlin.test.expect
-
-fun DynaNodeGroup.elementUtilsTests() {
-    beforeEach { MockVaadin.setup() }
-    afterEach { MockVaadin.tearDown() }
-
-    test("setOrRemoveAttribute") {
-        val t = Div().element
-        expect(null) { t.getAttribute("foo") }
-        t.setOrRemoveAttribute("foo", "bar")
-        expect("bar") { t.getAttribute("foo") }
-        t.setOrRemoveAttribute("foo", null)
-        expect(null) { t.getAttribute("foo") }
-    }
-
-    group("toggle class name") {
-        test("add") {
-            val t = Div()
-            t.classNames.toggle("test")
-            expect(setOf("test")) { t.classNames }
-        }
-        test("remove") {
-            val t = Div()
-            t.classNames.add("test")
-            t.classNames.toggle("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
-        l.insertBefore(second, first)
-        expect("second, first") { l.children.toList().joinToString { it.text } }
-        l.insertBefore(Span("third").element, first)
-        expect("second, third, first") { l.children.toList().joinToString { it.text } }
-    }
-
-    test("textRecursively2") {
-        expect("foo") { Span("foo").element.textRecursively2 }
-        expect("foobarbaz") {
-            val div = Div()
-            div.add(Span("foo"), Text("bar"), Paragraph("baz"))
-            div.element.textRecursively2
-        }
-        expect("foo") { Element("div").apply { setProperty("innerHTML", "foo") }.textRecursively2 }
-    }
-
-    group("getVirtualChildren()") {
-        test("initially empty") {
-            expectList() { Div().element.getVirtualChildren() }
-            expectList() { Span().element.getVirtualChildren() }
-            expectList() {
-                val b = Button()
-                UI.getCurrent().add(b)
-                b.element.getVirtualChildren()
-            }
-        }
-        test("add virtual child") {
-            val span = Span().element
-            val parent = Div()
-            parent.element.appendVirtualChild(span)
-            expectList(span) { parent.element.getVirtualChildren() }
-        }
-    }
-
-    test("getChildrenInSlot") {
-        expectList() { TextField().element.getChildrenInSlot("prefix") }
-        val div = Div()
-        expectList(div.element) { TextField().apply { prefixComponent = div } .element.getChildrenInSlot("prefix") }
-    }
-
-    test("clearSlot") {
-        val tf = TextField()
-        tf.prefixComponent = Div()
-        tf.element.clearSlot("prefix")
-        expectList() { tf.element.getChildrenInSlot("prefix") }
-        expect(null) { tf.prefixComponent }
-    }
-
-    test("fireDomEvent() smoke") {
-        val element = Div().element
-        element._fireDomEvent(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
deleted file mode 100644
index 300958b1..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/LocatorTest.kt
+++ /dev/null
@@ -1,428 +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.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 { testingLifecycleHook = MyLifecycleHook() }
-    afterEach { testingLifecycleHook = 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().apply { id_ = "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().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" } }
-        }
-        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(); testingLifecycleHook = 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)) { testingLifecycleHook }
-    testingLifecycleHook = 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 ef1c3a91..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/MockVaadinTest.kt
+++ /dev/null
@@ -1,594 +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.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()) { UI.getCurrent().toPrettyTree().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
-            UI.getCurrent()._close()
-            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()
-            ) { UI.getCurrent().toPrettyTree().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") {
-            currentRequest.mock.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 }
-        }
-
-        test("cookies in UI.init()") {
-            MockVaadin.tearDown()
-            var initCalled = false
-            MockVaadin.setup(uiFactory = {
-                currentRequest.mock.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") { VaadinSession.getCurrent().mock.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(servlet = 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(servlet = 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 dc7149f6..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/PrettyPrintTreeTest.kt
+++ /dev/null
@@ -1,364 +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.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.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().apply { id_ = "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("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
-    }
-}
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 8be5b3a7..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/RoutesTest.kt
+++ /dev/null
@@ -1,131 +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 = view.element.textRecursively2
-            errorMessage.contains("Could not navigate to 'A_VIEW_THAT_DOESNT_EXIST'")
-        }
-    }
-
-    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 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 ae6dc95a..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()(Button()) }
-        expect(false) { spec.toPredicate()(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()) }
-    }
-
-    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()) }
-        expect(true) {
-            spec.toPredicate()(CheckboxGroup<Int>().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate()(CheckboxGroup<Int>().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate()(CheckboxGroup<Int>()) }
-        expect(true) {
-            spec.toPredicate()(Select<Int>().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate()(Select<Int>().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate()(Select<Int>()) }
-        expect(true) {
-            spec.toPredicate()(ListBox<Int>().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate()(ListBox<Int>().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate()(ListBox<Int>()) }
-        expect(true) {
-            spec.toPredicate()(RadioButtonGroup<Int>().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate()(RadioButtonGroup<Int>().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate()(RadioButtonGroup<Int>()) }
-        // tests CustomField
-        expect(true) {
-            spec.toPredicate()(DateRangePopup().apply {
-                label = "foo"
-            })
-        }
-        expect(false) {
-            spec.toPredicate()(DateRangePopup().apply {
-                label = "bar"
-            })
-        }
-        expect(false) { spec.toPredicate()(DateRangePopup()) }
-
-        expect(true) { spec.toPredicate()(Input().apply { label = "foo" }) }
-        expect(false) { spec.toPredicate()(Input().apply { label = "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>()) }
-    }
-
-    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("")) }
-    }
-
-    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()) }
-    }
-}
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 721639e8..00000000
--- a/junit6/src/test/kotlin/com/vaadin/browserless/internal/ShortcutsTest.kt
+++ /dev/null
@@ -1,161 +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.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 3b5ba9f3..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 = { 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 7ec96c68..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 = session.attributes
-    }
-
-    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/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 2115215c..244db76c 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>
@@ -183,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>
@@ -216,20 +190,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/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/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/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/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..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;
@@ -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 {
@@ -64,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/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/shared/pom.xml b/shared/pom.xml
index cb432d2b..f77ec17a 100644
--- a/shared/pom.xml
+++ b/shared/pom.xml
@@ -15,103 +15,31 @@
 
     <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>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>
-                        <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>
-            <!-- 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>
             </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,11 +98,14 @@
             <scope>test</scope>
         </dependency>
 
+        <!-- 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>
@@ -196,13 +127,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/main/java/com/vaadin/browserless/BaseBrowserlessTest.java b/shared/src/main/java/com/vaadin/browserless/BaseBrowserlessTest.java
index e5bb70c0..9a8a3df3 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
      */
@@ -129,6 +142,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();
     }
@@ -146,6 +163,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<>();
 
@@ -284,10 +307,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) {
@@ -297,14 +320,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(
@@ -322,13 +345,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,
@@ -346,13 +369,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,
@@ -380,10 +403,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
      * @since 25.4
      */
@@ -414,11 +437,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) {
@@ -488,10 +536,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
      */
@@ -508,12 +556,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
      */
@@ -529,10 +577,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
      */
@@ -544,10 +592,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.
@@ -561,12 +609,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.
@@ -580,10 +628,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/BrowserlessDSL.java b/shared/src/main/java/com/vaadin/browserless/BrowserlessDSL.java
index b8167a38..4c57427e 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/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/BrowserlessUIContext.java b/shared/src/main/java/com/vaadin/browserless/BrowserlessUIContext.java
index 6c7760a2..33499ac5 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;
@@ -550,7 +549,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;
@@ -568,7 +567,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;
@@ -590,7 +589,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/CommercialTesterWrappers.java b/shared/src/main/java/com/vaadin/browserless/CommercialTesterWrappers.java
index d711e4e4..513e9b09 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
@@ -45,6 +47,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 fb557db0..19827c16 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;
@@ -77,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
@@ -101,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()}
@@ -122,7 +124,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 +144,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 +466,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 +497,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;
     }
 
@@ -743,10 +745,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
@@ -764,10 +766,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
@@ -844,6 +848,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
@@ -925,10 +931,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);
     }
 
     /**
@@ -946,18 +951,23 @@ 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
         // 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());
@@ -981,7 +991,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<>();
@@ -989,7 +999,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)
@@ -1016,8 +1026,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/ComponentTester.java b/shared/src/main/java/com/vaadin/browserless/ComponentTester.java
index 98048058..3d8872c9 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;
@@ -121,6 +121,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()
@@ -166,10 +168,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.
      */
@@ -232,7 +234,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);
@@ -249,6 +251,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()
      */
@@ -267,6 +271,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()
      */
@@ -299,11 +307,14 @@ 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()) {
             throw new IllegalStateException(
-                    PrettyPrintTreeKt.toPrettyString(component)
+                    PrettyPrintTree.toPrettyString(component)
                             + " is not visible!");
         }
     }
@@ -367,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
@@ -522,12 +533,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.
      */
@@ -541,9 +552,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));
@@ -556,12 +566,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(
@@ -663,6 +673,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.
      */
@@ -686,6 +698,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/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"));
     }
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 98dc72eb..b5be4efe 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
          * @since 25.3
          */
@@ -225,6 +281,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
          * @since 25.3
          */
@@ -235,6 +297,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...)
          * @since 25.3
          */
@@ -244,6 +312,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...)
          * @since 25.3
          */
@@ -253,6 +327,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)
          * @since 25.3
@@ -263,6 +345,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)
          * @since 25.3
@@ -273,6 +363,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
          * @since 25.3
          */
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/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/TesterWrappers.java b/shared/src/main/java/com/vaadin/browserless/TesterWrappers.java
index 1f8ada9a..c1bbf355 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);
@@ -187,11 +197,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);
     }
@@ -208,80 +232,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);
     }
@@ -303,76 +463,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,
@@ -381,20 +660,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);
     }
@@ -467,56 +780,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);
@@ -524,17 +914,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
      * @since 25.3
      */
@@ -544,19 +934,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
      * @since 25.3
      */
@@ -565,16 +955,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,
@@ -583,99 +1000,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
new file mode 100644
index 00000000..7dfe2933
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/component/GridUtils.java
@@ -0,0 +1,1815 @@
+/*
+ * 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 {@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.
+     */
+    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);
+    }
+
+    /**
+     * 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
+     * {@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,
+            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());
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * Returns the item on given row. Fails if the row index is invalid. Uses
+     * current Grid sorting.
+     *
+     * For {@link TreeGrid} this returns the x-th displayed row; skips children
+     * of collapsed nodes. Uses {@code _rowSequence}.
+     *
+     * 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.
+     */
+    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 {@code rowIndex} is larger
+     * than the number of items the data provider can provide. Uses current Grid
+     * sorting.
+     *
+     * For {@link TreeGrid} this returns the x-th displayed row; skips children
+     * of collapsed nodes. Uses {@code _rowSequence}.
+     *
+     * 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
+     *         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.
+     *
+     * @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 {
+            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 {@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 {@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) {
+            @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 {@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) {
+        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 {@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());
+    }
+
+    /**
+     * Returns all items in given data provider. Uses current Grid sorting.
+     *
+     * 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) {
+        return _fetch(grid, 0, BasicUtils._saneFetchLimit());
+    }
+
+    /**
+     * Returns the number of items in this data provider.
+     *
+     * 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) {
+            @SuppressWarnings("unchecked")
+            HierarchicalDataProvider<T, F> hp = (HierarchicalDataProvider<T, F>) provider;
+            return _size(hp, null, 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);
+    }
+
+    /**
+     * 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
+     * {@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 {@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);
+    }
+
+    /**
+     * Returns the number of items in this Grid.
+     *
+     * 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 {@link TreeGrid} since it walks through all
+     * items returned by {@code _rowSequence}.
+     *
+     * 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) {
+            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 {@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.
+     */
+    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 {@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 {@link Grid.Column#getKey()}
+     * @return a component produced by {@link ComponentRenderer} in given
+     *         {@link Grid} cell
+     * @throws IllegalStateException
+     *             if the renderer is not {@link 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
+     * {@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) {
+        T rowObject = _get(grid, rowIndex);
+        Grid.Column<T> column = _getColumnByKey(grid, columnKey);
+        return _getFormatted(column, rowObject);
+    }
+
+    /**
+     * 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);
+        return String.valueOf(value);
+    }
+
+    /**
+     * Returns the formatted row as a list of Strings, one for every visible
+     * 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<>();
+        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 {@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) {
+        T rowObject = _get(grid, rowIndex);
+        return _getFormattedRow(grid, rowObject);
+    }
+
+    /**
+     * Returns the formatted row as a list of Strings, one for every visible
+     * 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) {
+        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
+     * {@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) {
+        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
+     * {@code _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>
+     *
+     * @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<>();
+        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 {@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);
+        if (actual != count) {
+            throw new AssertionError(
+                    PrettyPrintTree.toPrettyString(grid) + ": expected " + count
+                            + " rows but got " + actual + "\n" + _dump(grid));
+        }
+    }
+
+    /**
+     * 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.
+     */
+    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 {@link ValueProvider} backing this
+     * {@link 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 {@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.
+     */
+    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 {@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.
+     */
+    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 {@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<>();
+        for (QuerySortOrder qso : sortOrder) {
+            orders.add(
+                    new GridSortOrder<>(_getColumnByKey(grid, qso.getSorted()),
+                            qso.getDirection()));
+        }
+        grid.sort(orders);
+    }
+
+    // ---------------------------------------------------------------------
+    // Click / select helpers
+    // ---------------------------------------------------------------------
+
+    /**
+     * 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)
+     * @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);
+    }
+
+    /**
+     * 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 {@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 <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
+     * @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);
+    }
+
+    /**
+     * 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 {@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 <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
+     * @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);
+    }
+
+    /**
+     * 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 {@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
+     *            `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);
+    }
+
+    /**
+     * 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);
+    }
+
+    // ---------------------------------------------------------------------
+    // TreeGrid helpers
+    // ---------------------------------------------------------------------
+
+    /**
+     * 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 {@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) {
+        Predicate<T> isExpanded = grid::isExpanded;
+        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 {@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 {@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 {@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,
+            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;
+    }
+
+    /**
+     * 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 {@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
+     * {@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();
+    }
+
+    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());
+    }
+
+    /**
+     * 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 -> {
+            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);
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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);
+    }
+
+    // ---------------------------------------------------------------------
+    // 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.
+     *
+     * @param c
+     *            the component to inspect
+     * @return the data provider currently set to this Component
+     */
+    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 {@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()) {
+            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 <T>
+     *            the grid item type
+     * @param grid
+     *            the grid to select in
+     * @param item
+     *            the item to select
+     */
+    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 <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
+     */
+    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 <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
+     * @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 <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
+     */
+    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
+     * {@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 {
+            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/BasicUtils.java b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
new file mode 100644
index 00000000..2f336f5f
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/BasicUtils.java
@@ -0,0 +1,334 @@
+/*
+ * 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 component
+     *            the component to fire the event on
+     * @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 component
+     *            the component to fire the event on
+     * @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
+     *
+     * @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);
+    }
+
+    /**
+     * 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) {
+            // 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).
+     *
+     * @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) {
+            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}.
+     * 
+     * @param component
+     *            the component to check
+     * @throws IllegalStateException
+     *             if any of the above doesn't hold.
+     */
+    public static void checkEditableByUser(Component component) {
+        if (!isEffectivelyVisible(component)) {
+            throw new IllegalStateException("The "
+                    + PrettyPrintTree.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 " + PrettyPrintTree.toPrettyString(component)
+                                + " is not enabled");
+            }
+        }
+        if (!isEffectivelyEnabled(component)) {
+            throw new IllegalStateException(
+                    "The " + PrettyPrintTree.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 " + PrettyPrintTree.toPrettyString(component)
+                                + " is read-only");
+            }
+        }
+        if (!component.isAttached()) {
+            throw new IllegalStateException(
+                    " The " + PrettyPrintTree.toPrettyString(component)
+                            + " is not attached");
+        }
+    }
+
+    /**
+     * 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.
+     */
+    public static void expectNotEditableByUser(Component component) {
+        try {
+            checkEditableByUser(component);
+        } catch (IllegalStateException ex) {
+            // okay
+            return;
+        }
+        throw new AssertionError("The "
+                + PrettyPrintTree.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 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.
+     */
+    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.
+     *
+     * @param <T>
+     *            the item type
+     * @param component
+     *            the component to focus
+     */
+    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.
+     *
+     * @param <T>
+     *            the item type
+     * @param component
+     *            the component to blur
+     */
+    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.
+     *
+     * @param ui
+     *            the UI to act on
+     */
+    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}.
+     *
+     * @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<>();
+        for (Element child : ElementUtils
+                .getVirtualChildren(component.getElement())) {
+            result.addAll(ElementUtils._findComponents(child));
+        }
+        return result;
+    }
+
+    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,
+        // failing instantly.
+        return Integer.MAX_VALUE / 1000;
+    }
+}
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
new file mode 100644
index 00000000..9909ec76
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/ComponentUtils.java
@@ -0,0 +1,796 @@
+/*
+ * 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.
+     *
+     * @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);
+    }
+
+    /**
+     * 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.
+     *
+     * @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) {
+        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`.
+     *
+     * @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);
+    }
+
+    /**
+     * 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) {
+        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.
+     *
+     * @param registration
+     *            the registration to remove
+     * @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.
+     *
+     * @param component
+     *            the component to detach
+     */
+    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.
+     *
+     * @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) {
+        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.
+     *
+     * @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) {
+        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}.
+     *
+     * @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) {
+        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.
+     *
+     * @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
+        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.
+     *
+     * @param component
+     *            the component to inspect
+     * @return the data provider currently set to this Component
+     */
+    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.
+     *
+     * @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) {
+        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}.
+     *
+     * @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();
+    }
+
+    /**
+     * 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();
+    }
+
+    /**
+     * 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
+        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.
+     *
+     * @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
+        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.
+     *
+     * @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
+        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.
+     *
+     * @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
+        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.
+     *
+     * @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
+        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.
+     *
+     * @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
+        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.
+     *
+     * @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
+        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;
+    }
+
+    /**
+     * 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);
+        } 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}.
+     *
+     * @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(
+                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}.
+     *
+     * 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>.
+     *
+     * **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.
+     *
+     * @param component
+     *            the component to inspect
+     * @return the component's label, or null if it has none
+     */
+    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);
+        }
+    }
+
+    /**
+     * 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)) {
+                _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.
+     *
+     * @param component
+     *            the component to inspect
+     * @return the component's caption, or null if it has none
+     */
+    @Deprecated
+    public static String caption(Component component) {
+        if (component instanceof Button) {
+            return ((Button) component).getText();
+        }
+        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) {
+            ((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.
+     *
+     * @param component
+     *            the component to close
+     */
+    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/CountRange.java b/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
new file mode 100644
index 00000000..15aa9862
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/CountRange.java
@@ -0,0 +1,130 @@
+/*
+ * 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);
+
+    /**
+     * The smallest accepted count, inclusive.
+     */
+    private final int start;
+
+    /**
+     * The largest accepted count, inclusive.
+     */
+    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/DepthFirstTreeIterator.java b/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.java
new file mode 100644
index 00000000..57c76322
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/DepthFirstTreeIterator.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.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;
+
+    /**
+     * Creates an iterator over the tree below the given node.
+     *
+     * @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.
+     *
+     * @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
+                .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..7018b8a4
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/ElementUtils.java
@@ -0,0 +1,242 @@
+/*
+ * 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 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) {
+        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 classList
+     *            the element's class list
+     * @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()`.
+     *
+     * @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) {
+        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}.
+     *
+     * @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
+        Node node = ElementUtil.toJsoup(new Document(""), 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();
+        }
+        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}.
+     *
+     * @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)) {
+            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.
+     *
+     * @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);
+    }
+
+    /**
+     * 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) {
+        return element.getChildren()
+                .filter(child -> slotName.equals(child.getAttribute("slot")))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * 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()) {
+            throw new IllegalArgumentException();
+        }
+        for (Element child : getChildrenInSlot(element, slotName)) {
+            child.removeFromParent();
+        }
+    }
+
+    /**
+     * 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<>();
+        ComponentUtil.findComponents(element, components::add);
+        return components;
+    }
+
+    /**
+     * 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/GridContextMenuSupport.java b/shared/src/main/java/com/vaadin/browserless/internal/GridContextMenuSupport.java
index 7c1a8f30..08481c2f 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;
@@ -148,7 +148,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/browserless/internal/Locator.java b/shared/src/main/java/com/vaadin/browserless/internal/Locator.java
new file mode 100644
index 00000000..70a884e8
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Locator.java
@@ -0,0 +1,650 @@
+/*
+ * 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 <T>
+     *            the item type
+     * @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)}.
+     *
+     * @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) {
+        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.
+     *
+     * @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) {
+        return _get(Utils.currentUI(), clazz, block);
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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,
+            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)}.
+     *
+     * @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) {
+        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}.
+     *
+     * @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) {
+        return _find(Utils.currentUI(), clazz, block);
+    }
+
+    /**
+     * 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());
+    }
+
+    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.
+     *
+     * @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>() {
+            @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.
+     *
+     * @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.
+     */
+    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);
+        }
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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}.
+     *
+     * @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) {
+        // 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);
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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) {
+        // 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);
+        });
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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();
+        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()));
+        }
+    }
+
+    /**
+     * Equivalent to {@code _expectInternalServerError("")}.
+     */
+    public static void _expectInternalServerError() {
+        _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();
+        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/MenuItemNavigation.java b/shared/src/main/java/com/vaadin/browserless/internal/MenuItemNavigation.java
index fd3fff2b..27d2426f 100644
--- a/shared/src/main/java/com/vaadin/browserless/internal/MenuItemNavigation.java
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MenuItemNavigation.java
@@ -272,7 +272,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..f06c9e94
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockInternalSeverError.java
@@ -0,0 +1,67 @@
+/*
+ * 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 {
+
+    /**
+     * Creates the error view.
+     */
+    public MockInternalSeverError() {
+    }
+
+    @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/MockRequestCustomizer.java b/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
new file mode 100644
index 00000000..7238a667
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockRequestCustomizer.java
@@ -0,0 +1,39 @@
+/*
+ * 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 {
+    /**
+     * 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
new file mode 100644
index 00000000..fed93938
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockRouteNotFoundError.java
@@ -0,0 +1,110 @@
+/*
+ * 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 {
+
+    /**
+     * Creates the error view.
+     */
+    public MockRouteNotFoundError() {
+    }
+
+    /**
+     * The exception the navigation failed with, recorded so the test can assert
+     * on it.
+     */
+    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/MockVaadin.java b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
new file mode 100644
index 00000000..3b418eb1
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/MockVaadin.java
@@ -0,0 +1,1157 @@
+/*
+ * 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 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
+     *            {@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
+     * @param configuration
+     *            the deployment configuration to use
+     */
+    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);
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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
+     * @param configuration
+     *            the deployment configuration to use
+     */
+    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);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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).
+     *
+     * @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,
+            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;
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * 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();
+        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.
+     *
+     * @param session
+     *            the session to act on
+     */
+    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.
+     *
+     * @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) {
+        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.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.getSession(), objs.getRequest()));
+
+        // create UI
+        createUI(uiFactory, objs.getSession());
+    }
+
+    /**
+     * 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) {
+            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 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
+     * {@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 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 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
+     */
+    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;
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * Internal function, do not call directly.
+     *
+     * Only usable when you are providing your own implementation of
+     * {@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) {
+        // 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.
+     *
+     * @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) {
+        fireSessionInitListeners(service,
+                new SessionInitEvent(service, session, request));
+    }
+
+    /**
+     * 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));
+    }
+
+    /**
+     * 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", ""));
+
+        /**
+         * 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;
+            this.uiFactory = uiFactory;
+            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()) {
+                return null;
+            }
+            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));
+            if (list == null || list.isEmpty()) {
+                return null;
+            }
+            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()) {
+                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/PrettyPrintTree.java b/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
new file mode 100644
index 00000000..6ec14c23
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/PrettyPrintTree.java
@@ -0,0 +1,453 @@
+/*
+ * 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);
+        }
+    }
+
+    /**
+     * 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<>());
+        for (Component child : TestingLifecycleHooks.getCurrent()
+                .getAllChildren(root)) {
+            result.children.add(ofVaadin(child));
+        }
+        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();
+    }
+
+    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 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) {
+        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
new file mode 100644
index 00000000..c90a77d4
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Renderers.java
@@ -0,0 +1,216 @@
+/*
+ * 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.
+     *
+     * @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,
+            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 PrettyPrintTree.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);
+        }
+    }
+
+    /**
+     * 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;
+        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}.
+     *
+     * @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();
+    }
+
+    /**
+     * 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(
+            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}.
+     *
+     * @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 {
+            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/Routes.java b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
new file mode 100644
index 00000000..57071946
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Routes.java
@@ -0,0 +1,407 @@
+/*
+ * 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.
+ */
+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) {
+        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}.
+     *
+     * @param sc
+     *            the servlet context to register the routes in
+     */
+    @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;
+    }
+
+    /**
+     * 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),
+                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.
+     *
+     * @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,
+            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.
+     *
+     * @param registry
+     *            the route registry to register into
+     */
+    @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/browserless/internal/SearchSpec.java b/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
new file mode 100644
index 00000000..ac3bec08
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/SearchSpec.java
@@ -0,0 +1,582 @@
+/*
+ * 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.
+ *
+ * @param <T>
+ *            the component type
+ */
+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;
+
+    /**
+     * 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;
+    }
+
+    // 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));
+    }
+
+    @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).
+     *
+     * @return a predicate which matches components based on this spec
+     */
+    @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..32ba3a0c
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/SessionObjects.java
@@ -0,0 +1,156 @@
+/*
+ * 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 {
+
+    /**
+     * The session.
+     */
+    private final VaadinSession session;
+
+    /**
+     * The request bound to the session.
+     */
+    private final VaadinRequest request;
+
+    /**
+     * The response bound to the session.
+     */
+    private final VaadinResponse response;
+
+    /**
+     * The HTTP session the Vaadin session is stored in.
+     */
+    private 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;
+        this.request = request;
+        this.response = response;
+        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);
+    }
+
+    @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/Shortcuts.java b/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
new file mode 100644
index 00000000..2b31f6f5
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Shortcuts.java
@@ -0,0 +1,208 @@
+/*
+ * 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.
+     *
+     * @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
+        // 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!
+     *
+     * @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) {
+        // 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/UIFactory.java b/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
new file mode 100644
index 00000000..7a18c525
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/UIFactory.java
@@ -0,0 +1,46 @@
+/*
+ * 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 {
+    /**
+     * 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
new file mode 100644
index 00000000..0fce6bda
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/internal/Utils.java
@@ -0,0 +1,298 @@
+/*
+ * 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.
+     *
+     * @return the major JVM version, e.g
+     */
+    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;
+    }
+
+    /**
+     * 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) {
+            throw new IllegalStateException(
+                    "No current request. Have you called MockVaadin.setup()?");
+        }
+        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) {
+            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.
+     *
+     * @return 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")) ```
+     *
+     * @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();
+    }
+
+    /**
+     * 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();
+    }
+
+    /**
+     * 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;
+    }
+
+    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;
+    }
+
+    /**
+     * 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);
+        } catch (ClassNotFoundException ex) {
+            try {
+                return Class.forName(className, true,
+                        Thread.currentThread().getContextClassLoader());
+            } catch (ClassNotFoundException ex2) {
+                return null;
+            }
+        }
+    }
+
+    /**
+     * 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);
+        if (clazz == null) {
+            throw new ClassNotFoundException(className);
+        }
+        return clazz;
+    }
+}
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 3d252d32..75a4f35d 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)
      * @since 25.3
      */
@@ -189,7 +236,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);
@@ -212,6 +265,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
@@ -236,6 +292,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();
@@ -257,6 +317,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
@@ -278,6 +342,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
@@ -315,6 +382,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();
@@ -323,6 +392,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();
@@ -339,6 +410,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();
@@ -372,6 +445,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
new file mode 100644
index 00000000..84c21eaf
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockContext.java
@@ -0,0 +1,530 @@
+/*
+ * 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 {
+
+    /**
+     * Creates an empty context.
+     */
+    public MockContext() {
+    }
+
+    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");
+    }
+
+    /**
+     * The directories {@link #getRealPath} resolves paths against.
+     */
+    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;
+    }
+
+    /**
+     * The context init parameters.
+     */
+    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"
+    }
+
+    /**
+     * The session timeout, in minutes.
+     */
+    private int sessionTimeout = 30;
+
+    @Override
+    public int getSessionTimeout() {
+        return sessionTimeout;
+    }
+
+    @Override
+    public void setSessionTimeout(int sessionTimeout) {
+        this.sessionTimeout = sessionTimeout;
+    }
+
+    /**
+     * The character encoding requests default to.
+     */
+    private String requestCharacterEncoding = null;
+
+    @Override
+    public String getRequestCharacterEncoding() {
+        return requestCharacterEncoding;
+    }
+
+    @Override
+    public void setRequestCharacterEncoding(String encoding) {
+        this.requestCharacterEncoding = encoding;
+    }
+
+    /**
+     * The character encoding responses default to.
+     */
+    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");
+    }
+
+    /**
+     * The context attributes.
+     */
+    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..9df84dac
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockHttpSession.java
@@ -0,0 +1,261 @@
+/*
+ * 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 {
+
+    /**
+     * 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);
+
+    /**
+     * 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..d4b9741d
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockInstantiator.java
@@ -0,0 +1,155 @@
+/*
+ * 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 {
+
+    /**
+     * The instantiator the calls are forwarded to.
+     */
+    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..17cb46b6
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockRequest.java
@@ -0,0 +1,759 @@
+/*
+ * 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;
+    }
+
+    /**
+     * 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 };
+        } 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();
+    }
+
+    /**
+     * 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
new file mode 100644
index 00000000..77d3588f
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockResponse.java
@@ -0,0 +1,312 @@
+/*
+ * 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 {
+
+    /**
+     * Creates an empty response.
+     */
+    public MockResponse() {
+    }
+
+    @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..7cb96e1b
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockService.java
@@ -0,0 +1,117 @@
+/*
+ * 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 {
+
+    /**
+     * Produces the UI instances the sessions of this service hand out.
+     */
+    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..f3cd85ac
--- /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.Utils;
+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, Utils.findClassOrThrow(
+                    "com.vaadin.flow.server.startup.ApplicationConfigurationFactory"));
+            dacfClass = Utils.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(Utils.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 = Utils.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..ebd2511a
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinServlet.java
@@ -0,0 +1,293 @@
+/*
+ * 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 {
+
+    /**
+     * 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;
+
+    /**
+     * 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
+     *
+     * @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
+        // 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
+     *
+     * @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) {
+        // 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
+     *
+     * @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) {
+        // 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);
+        }
+    }
+
+    /**
+     * 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);
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * 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 {
+            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..4bdee8b1
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockVaadinSession.java
@@ -0,0 +1,73 @@
+/*
+ * 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 {
+
+    /**
+     * Produces the UI instances this session hands out.
+     */
+    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..d0685c0b
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/MockedUI.java
@@ -0,0 +1,185 @@
+/*
+ * 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.ComponentUtils;
+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 {
+
+    /**
+     * Creates the UI.
+     */
+    public MockedUI() {
+    }
+
+    /** {@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) {
+            ComponentUtils.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..a827a706
--- /dev/null
+++ b/shared/src/main/java/com/vaadin/browserless/mocks/SessionAttributeMap.java
@@ -0,0 +1,211 @@
+/*
+ * 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;
+
+    /**
+     * 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);
+    }
+
+    @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/java/com/vaadin/flow/component/accordion/AccordionTester.java b/shared/src/main/java/com/vaadin/flow/component/accordion/AccordionTester.java
index 0adeb268..64624c79 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,12 +15,16 @@
  */
 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;
 
 /**
+ * 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 21417abf..1399cfaa 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;
@@ -120,9 +120,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 dc10997a..767b1de6 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 ab960a26..789d8358 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;
@@ -114,12 +114,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 cea8b984..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
@@ -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;
@@ -37,6 +37,8 @@
  *
  * @param <T>
  *            component type
+ * @param <V>
+ *            the item type
  * @since 1.0
  */
 @Tests(fqn = "com.vaadin.flow.component.checkbox.CheckboxGroup")
@@ -150,7 +152,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/combobox/ComboBoxTester.java b/shared/src/main/java/com/vaadin/flow/component/combobox/ComboBoxTester.java
index 85c996aa..a100cdca 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,12 +24,18 @@
 
 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;
 
 /**
+ * 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.
@@ -185,8 +191,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 89f39443..a9f9f085 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,12 +27,18 @@
 
 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;
 
 /**
+ * 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.
@@ -163,8 +169,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/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 8981c11e..f1ae2141 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.
@@ -492,7 +494,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")),
@@ -507,7 +509,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 148c1a30..802cc0ad 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
@@ -85,7 +85,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.
@@ -100,7 +100,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 e80816eb..aed39a14 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
@@ -85,7 +85,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 a5e3f631..5ae4e161 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 cdd03d13..4e075018 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.browserless.internal.RenderedComponentSupport;
 import com.vaadin.flow.component.Component;
@@ -69,12 +69,12 @@ public GridTester(T component) {
      * @return items in grid
      */
     public int size() {
-        return GridKt._size(getComponent());
+        return GridUtils._size(getComponent());
     }
 
     /**
      * Get the item at the given row index.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -82,12 +82,12 @@ public int size() {
      * @return grid item on row
      */
     public Y getRow(int row) {
-        return GridKt._get(getComponent(), row);
+        return GridUtils._get(getComponent(), row);
     }
 
     /**
      * Click on grid row.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -99,7 +99,7 @@ public void clickRow(int row) {
 
     /**
      * Click on grid row with given button.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -114,7 +114,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
@@ -128,7 +128,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
@@ -141,14 +141,14 @@ 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());
     }
 
     /**
      * Double-click on grid row.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -160,7 +160,7 @@ public void doubleClickRow(int row) {
 
     /**
      * Double-click on grid row with given button.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param row
@@ -175,7 +175,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
@@ -189,7 +189,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
@@ -202,16 +202,16 @@ 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());
     }
 
     /**
      * 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.
      *
@@ -223,13 +223,13 @@ 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);
     }
 
     /**
      * 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.
      *
@@ -239,21 +239,21 @@ public void select(int row) {
      */
     public void selectAll() {
         ensureComponentIsUsable();
-        GridKt._selectAll(getComponent());
+        GridUtils._selectAll(getComponent());
     }
 
     /**
      * 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.
@@ -268,16 +268,16 @@ public void selectAll() {
     public void deselect(int row) {
         ensureComponentIsUsable();
         final Y item = getRow(row);
-        GridKt._deselect(getComponent(), item);
+        GridUtils._deselect(getComponent(), item);
     }
 
     /**
      * 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
@@ -290,25 +290,25 @@ public void deselect(int row) {
      */
     public void deselectAll() {
         ensureComponentIsUsable();
-        GridKt._deselectAll(getComponent());
+        GridUtils._deselectAll(getComponent());
     }
 
     /**
      * 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 text of the component the grid
      * rendered for the cell, read through {@link #getCellComponent(int, int)}:
      * a row the client has not asked for yet is scrolled into view first, and a
      * cell the grid renders no component for fails the same way. A renderer
      * that returns no component renders an empty cell, so the text is empty
      * rather than {@literal null}.
-     * <p/>
+     * <p>
      * More to be added as we find other renderers that need handling.
      *
      * @param row
@@ -554,6 +554,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
@@ -562,8 +564,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
@@ -579,6 +579,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
@@ -587,8 +589,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
@@ -693,8 +693,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) {
@@ -746,8 +748,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) {
@@ -767,7 +772,7 @@ public Collection<Y> getSelected() {
 
     /**
      * Checks if the column at the given index is sortable.
-     * <p/>
+     * <p>
      * The index is 0 based.
      *
      * @param column
@@ -952,10 +957,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 8eba6959..0076dad1 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;
@@ -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.
@@ -58,7 +58,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
@@ -71,7 +71,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.
      *
@@ -88,12 +88,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
@@ -115,7 +115,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
@@ -136,7 +136,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()}.
      *
@@ -159,7 +159,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);
@@ -189,17 +189,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.
      *
@@ -222,15 +222,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.
      *
@@ -254,7 +254,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.
      *
@@ -284,7 +284,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.
      *
@@ -315,7 +315,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.
      *
@@ -341,7 +341,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.
      *
@@ -368,16 +368,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.
@@ -411,13 +411,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.
      *
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 1ae0eb11..d5437229 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;
@@ -81,7 +81,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/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/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/menubar/MenuBarTester.java b/shared/src/main/java/com/vaadin/flow/component/menubar/MenuBarTester.java
index 0b36752c..88b2cf9a 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/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/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/splitlayout/SplitLayoutTester.java b/shared/src/main/java/com/vaadin/flow/component/splitlayout/SplitLayoutTester.java
index 7141c831..bd416a7a 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/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 40d1ccb2..61adf996 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.
@@ -81,7 +81,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 1724e48e..e89dca82 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
@@ -39,14 +39,14 @@ public TextAreaTester(T component) {
 
     /**
      * Set the given value for the component, as the user would type it.
-     * <p/>
+     * <p>
      * A value that only breaks a validation constraint — shorter than
      * {@literal minLength}, not matching {@literal pattern}, or the empty value
      * on a required field — is committed all the same, because the browser
      * commits it too and simply leaves the field invalid. Assert that outcome
      * with {@link com.vaadin.flow.component.HasValidation#isInvalid()} instead
      * of expecting this method to throw.
-     * <p/>
+     * <p>
      * A value the user physically cannot type is refused: the browser truncates
      * what is over {@literal maxLength} and filters out the keystrokes
      * {@literal allowedCharPattern} does not match, so a longer value or a
@@ -73,7 +73,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.
@@ -88,7 +88,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 f3558af4..fd5e13f1 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
@@ -44,14 +44,14 @@ public TextFieldTester(T component) {
 
     /**
      * Set the given value for the component, as the user would type it.
-     * <p/>
+     * <p>
      * A value that only breaks a validation constraint — shorter than
      * {@literal minLength}, not matching {@literal pattern}, or the empty value
      * on a required field — is committed all the same, because the browser
      * commits it too and simply leaves the field invalid. Assert that outcome
      * with {@link com.vaadin.flow.component.HasValidation#isInvalid()} instead
      * of expecting this method to throw.
-     * <p/>
+     * <p>
      * A value the user physically cannot type is refused: the browser truncates
      * what is over {@literal maxLength} and filters out the keystrokes
      * {@literal allowedCharPattern} does not match, so a longer value or a
@@ -80,7 +80,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.
@@ -94,7 +94,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 1d53839b..1d9a4063 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
@@ -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.
@@ -99,7 +99,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 8a55b188..88c55f41 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
@@ -66,10 +67,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}.
      *
@@ -96,10 +97,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}.
      *
@@ -125,7 +126,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.
      *
@@ -144,7 +145,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.
      *
@@ -163,12 +164,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
@@ -220,7 +222,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 3eef8d77..0ebda41f 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
@@ -352,11 +352,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
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 f5a1e913..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/component/Grid.kt
+++ /dev/null
@@ -1,901 +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._fireEvent
-import com.vaadin.browserless.internal._getPresentationValue
-import com.vaadin.browserless.internal._saneFetchLimit
-import com.vaadin.browserless.internal.checkEditableByUser
-import com.vaadin.browserless.internal.filterNotBlank
-import com.vaadin.browserless.internal.size
-import com.vaadin.browserless.internal.template
-import com.vaadin.browserless.internal.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.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()}: 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("${this.toPrettyString()} column $columnKey: ComponentRenderer produced ${component.toPrettyString()} 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")
-//    }
-//}
-
-/**
- * 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("${this.toPrettyString()} 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")
-    }
-    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 renderer._getPresentationValue(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("${this.toPrettyString()}: 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("${this.toPrettyString()} 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()
-    // 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(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()
-    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)
-}
-
-/**
- * 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, "${grid.toPrettyString()} 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()
-    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()
-    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()
-    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()
-    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/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
deleted file mode 100644
index 5f4c1e42..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Locator.kt
+++ /dev/null
@@ -1,428 +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
-
-/**
- * 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 -> component.id_ == 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 (!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 = t.caption.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()} matching $spec: [${result.joinToString { it.toPrettyString() }}]. Component tree:\n${toPrettyTree()}"
-
-        // 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> {
-    testingLifecycleHook.awaitBeforeLookup()
-    val descendants: List<Component> = _walkAll().toList()
-    testingLifecycleHook.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()}")
-    }
-    return descendants.filter { it.isEffectivelyVisible() && 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 -> testingLifecycleHook.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 = "") {
-    testingLifecycleHook.awaitBeforeLookup()
-    val descendants: List<Component> = currentUI._walkAll().toList()
-    testingLifecycleHook.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()}")
-    }
-    if (!error.errorMessage.contains(expectedErrorMessage)) {
-        throw AssertionError("Expected InternalServerError with message '$expectedErrorMessage' but was '${error.errorMessage}'. Component tree:\n${currentUI.toPrettyTree()}")
-    }
-}
-
-/**
- * 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 89fb0774..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/MockVaadin.kt
+++ /dev/null
@@ -1,728 +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.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.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
- * 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 (!servlet.isInitialized) {
-            // 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(servlet.serviceSafe)
-        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) {
-            ui._close()
-        }
-        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 = createVaadinServletRequest(mockRequest, service)
-
-        // init Session.
-        val session: VaadinSession = service._createVaadinSession(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)
-        checkNotNull(session.browser.browserApplication) { "The WebBrowser has not been mocked properly" }
-
-        // init Vaadin Response
-        val response = 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()
-        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 = session.mock
-            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/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 4cf6d5a0..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/PrettyPrintTree.kt
+++ /dev/null
@@ -1,263 +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.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 testingLifecycleHook.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) {
-        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.isNotBlank()) {
-        list.add("label='$label'")
-    }
-    if (label != caption && caption.isNotBlank()) {
-        list.add("caption='$caption'")
-    }
-    if (!_text.isNullOrBlank() && _text != caption) {
-        list.add("text='$_text'")
-    }
-    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(outerHtml.ellipsize(100))
-    }
-    if (this is Grid<*> && this.beanType != null) {
-        list.add("<${this.beanType.simpleName}>")
-    }
-    if (this.dataProvider != null) {
-        list.add("dataprovider='${this.dataProvider}'")
-    }
-    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 (this.javaClass.hasCustomToString()) {
-        // 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/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
deleted file mode 100644
index c243a8d8..00000000
--- a/shared/src/main/kotlin/com/vaadin/browserless/internal/Routes.kt
+++ /dev/null
@@ -1,205 +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.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, sc.context)
-        checkNotNull(sc.context.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 && it.isRouteNotFound }) {
-            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)
-    }
-}
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/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/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/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/internal/AllTests.kt b/shared/src/test/kotlin/com/vaadin/browserless/internal/AllTests.kt
deleted file mode 100644
index 0da60122..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) { Button("foo").isTemplate }
-        expect(true) { MyLitTemplate().isTemplate }
-        expect(true) { MyPolymerTemplate().isTemplate }
-    }
-
-})
-
-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 ece89657..00000000
--- a/shared/src/test/kotlin/com/vaadin/browserless/mocks/BrowserlessLookupInitializerTest.kt
+++ /dev/null
@@ -1,86 +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.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))
-        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 to FakeServiceImpl::class))
-        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 to Object::class))
-        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 to FakeServiceImpl::class))
-
-        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 to FakeServiceImpl::class))
-
-        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(
-        override val additionalServices: Map<KClass<*>, KClass<*>>
-) : MockVaadinHelper.BrowserlessLookupInitializer() {
-    public override fun getServiceTypes(): Collection<Class<*>?> = super.getServiceTypes()
-}
diff --git a/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java b/spring/src/main/java/com/vaadin/browserless/BrowserlessTestSpringLookupInitializer.java
index 3708e0ca..1bca8fd2 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;
@@ -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
@@ -143,7 +149,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/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/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 5bde516d..df23c8eb 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/MockSpringServlet.java
@@ -22,8 +22,7 @@
 import java.security.Principal;
 import java.util.function.UnaryOperator;
 
-import kotlin.jvm.functions.Function0;
-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;
@@ -34,8 +33,7 @@
 
 import com.vaadin.browserless.internal.Routes;
 import com.vaadin.browserless.internal.UIFactory;
-import com.vaadin.browserless.internal.UtilsKt;
-import com.vaadin.flow.component.UI;
+import com.vaadin.browserless.internal.Utils;
 import com.vaadin.flow.function.DeploymentConfiguration;
 import com.vaadin.flow.server.ServiceException;
 import com.vaadin.flow.server.VaadinServletRequest;
@@ -43,40 +41,86 @@
 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>
+ * For internal use only. May be renamed or removed in a future release.
+ * 
  * @author mavi
  * @since 1.0
  */
 public class MockSpringServlet extends SpringServlet {
 
-    @NotNull
-    public final Routes routes;
-    @NotNull
-    public final ApplicationContext ctx;
-    @NotNull
-    public final UIFactory uiFactory;
+    /**
+     * The routes registered when the service is created.
+     */
+    @NonNull
+    private final Routes routes;
 
-    @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;
-    }
+    /**
+     * The Spring context the views are instantiated from.
+     */
+    @NonNull
+    private final ApplicationContext ctx;
 
-    public MockSpringServlet(@NotNull Routes routes,
+    /**
+     * Produces the UI instances the sessions of this servlet hand out.
+     */
+    @NonNull
+    private final UIFactory uiFactory;
 
-            @NotNull ApplicationContext ctx, @NotNull 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) {
         super(ctx, false);
         this.ctx = ctx;
         this.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 {
@@ -166,13 +210,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 -> {
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..a4e76ef9 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.jspecify.annotations.NonNull;
 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;
@@ -38,24 +36,34 @@
  * </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
  */
 public class MockSpringServletService extends SpringVaadinServletService {
-    @NotNull
+    /**
+     * Produces the UI instances the sessions of this service hand out.
+     */
+    @NonNull
     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) {
+    /**
+     * 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) {
         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 826c9697..6e9919a6 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 org.jspecify.annotations.NonNull;
 
 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;
 
@@ -35,22 +33,29 @@
  * {@link MockVaadin#afterSessionClose}.</li>
  * </ul>
  *
+ * <p>
+ * For internal use only. May be renamed or removed in a future release.
+ * 
  * @author mavi
  * @since 1.0
  */
 public class MockSpringVaadinSession extends VaadinSession {
-    @NotNull
+    /**
+     * Produces the UI instances this session hands out.
+     */
+    @NonNull
     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) {
+    /**
+     * 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);
         this.uiFactory = uiFactory;
     }
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..b83b2943 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
  */
@@ -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 7c442009..9993b815 100644
--- a/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
+++ b/spring/src/main/java/com/vaadin/browserless/mocks/SpringSecurityRequestCustomizer.java
@@ -19,13 +19,19 @@
 
 /**
  * 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
  */
 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);