diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000..9d12996c
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,70 @@
+<!--
+This template encodes the rules in CLAUDE.md and ARCHITECTURE.md.
+Delete sections that genuinely don't apply, but don't delete sections to avoid answering them.
+-->
+
+## What
+
+<!-- One or two sentences. What does this PR change? -->
+
+## Why
+
+<!-- The motivation. Not "what" again — the reason this change exists. Link issue if any. -->
+
+## How
+
+<!-- The approach. Anything non-obvious about the implementation. -->
+
+---
+
+## Architecture self-check
+
+> Required for every non-trivial PR. If a box is unchecked, explain why.
+
+- [ ] **No new duplication.** This PR does not add a type, constant, enum, or contract that already exists in another package. (If it consolidates one, note which item from `CLAUDE.md` §7 is being resolved.)
+- [ ] **No cross-adapter imports.** No code in `service`, `nightwatch-devtools`, or `selenium-devtools` imports from another adapter.
+- [ ] **No adapter imports in `backend` / `app`.** Neither package reaches into adapter internals.
+- [ ] **Typed contracts at boundaries.** Any new `fetch(...)`, `ws.send(...)`, or HTTP route has a typed request/response shape in `shared` (or in `service` types if `shared` doesn't exist yet, with a TODO to move).
+- [ ] **No `if (framework === '...')` outside an adapter.** Framework branching uses a typed `FrameworkId`.
+- [ ] **No new `any` at package boundaries.** Internal `any` is acceptable only at a documented framework-edge with a one-line comment.
+
+### Multi-adapter changes
+
+- [ ] This PR touches **more than one** adapter package.
+
+> If checked: **why isn't this in `core`?** Answer here:
+>
+> _<your answer>_
+
+---
+
+## Debt scoreboard
+
+> List the `CLAUDE.md` §7 debt items this PR resolves, partially resolves, or extends. Delete this section only if the PR genuinely affects no debt items.
+
+- Resolved: _<item, or "none">_
+- Partially resolved: _<item, or "none">_
+- New debt introduced: _<item, or "none — and explain why if any>_
+
+If new debt is introduced, it must be added to `CLAUDE.md` §7 in this PR.
+
+---
+
+## Testing
+
+- [ ] Unit tests for new logic in `shared` / `core` (required per `CLAUDE.md` §4).
+- [ ] Regression test for any bug fix (required per `CLAUDE.md` §4).
+- [ ] `pnpm build` passes.
+- [ ] `pnpm test` passes.
+- [ ] `pnpm lint` passes.
+- [ ] For UI/runtime changes: verified in `example/` (or `example` for the framework I changed).
+
+If any required item is skipped, say so here with the reason:
+
+_<your note, or "n/a">_
+
+---
+
+## Screenshots / recordings (UI changes only)
+
+<!-- Drop them in here. -->
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 00000000..6d4fecc0
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,235 @@
+# Architecture
+
+A descriptive map of how the pieces fit together. For conventions and coding standards, see [CLAUDE.md](./CLAUDE.md).
+
+---
+
+## At a glance
+
+A devtools dashboard for end-to-end browser tests. Three test frameworks (WebdriverIO, Nightwatch, Selenium) push the same normalized event stream through a single backend into a single browser UI.
+
+```
+[user's test framework]
+        │
+        ▼
+   [adapter]          thin: framework-specific hooks + driver patching
+        │
+        ▼
+     [core]           framework-agnostic capture/reporting library
+        │
+        ▼ (WS frames typed by shared)
+   [backend]          Fastify + WS gateway + baseline store + rerun spawner
+        │
+        ▼ (WS + HTTP, both typed by shared)
+     [app]            Lit browser UI, framework-agnostic
+```
+
+A separate piece, **`packages/script`**, is injected into the browser under test (not Node) to capture DOM mutations from the page's own JS context. It communicates back through the adapter, not directly to the backend.
+
+---
+
+## Packages
+
+The workspace is a pnpm monorepo. Two of the packages (`shared`, `core`) are workspace-internal — they're marked `"private": true` and never published; consumers bundle their code into their own `dist/`.
+
+### `packages/shared`
+
+Types, constants, enums, HTTP/WS contract definitions. Pure TypeScript, no runtime dependencies on any other package in the monorepo. Workspace-internal; inlined into every consumer at build time.
+
+Contains the canonical definitions for:
+
+- Domain types: `CommandLog`, `ConsoleLog`, `NetworkRequest`, `TraceMutation`, `Metadata`, `TraceLog`, `TraceType`, `TestStats`, `SuiteStats`, `TestStatus`, `TestError`, `ReporterError`, `PreservedAttempt`, `PreservedStep`, `PerformanceData`, `DocumentInfo`, `Viewport`, `ScreencastInfo`, `ScreencastFrame`, `ScreencastOptions`, `LogLevel`, `LogSource`.
+- WS wire format: `SocketMessage<T>`, `WsMessageScope`, `WsPayloadFor<T>`, `ClearExecutionDataWsPayload`, `ReplaceCommandWsPayload`.
+- Routing/scope constants: `WS_PATHS`, `WS_SCOPE`, `BASELINE_WS_SCOPE`, `TESTS_API`, `BASELINE_API`.
+- Process-control env vars: `REUSE_ENV`, `RUNNER_ENV`.
+- Defaults: `TIMING_BASE`, `DEFAULTS_BASE`, `SCREENCAST_DEFAULTS`.
+- File patterns: `SPEC_FILE_RE`, `FEATURE_FILE_RE` (the latter Cucumber-only).
+- Test-runner identification: `TestRunnerId = 'mocha' | 'jasmine' | 'cucumber' | 'nightwatch' | 'nightwatch-cucumber' | 'selenium-webdriver'`.
+
+Imports from: nothing. Imported by: every other package.
+
+### `packages/core`
+
+Framework-agnostic capture and reporting library. Workspace-internal; inlined into each adapter at build time.
+
+Contains:
+
+- `SessionCapturerBase` — orchestrates per-session capture (console/stream patching, WS connection, command-id bookkeeping, upstream-send guard with `onUpstreamDrop` hook).
+- `TestReporterBase` — common reporter behavior, extended by Nightwatch + Selenium reporters (Service uses `@wdio/reporter` from WDIO directly).
+- `ScreencastRecorderBase` — frame buffer + polling fallback shared by all three adapters.
+- `resolveAdapterOutputDir` — the dir-resolution helper that picks where screencast/trace files land (test-file dir → config dir → cwd, with a `node_modules/` skip).
+- Pure helpers: `assert-patcher`, `bidi` (`attachBidiHandlers`, `loadSeleniumSubmodule`, `arrayHeadersToObject`), `console` (`stripAnsi`, `detectLogLevel`, `createConsoleLogEntry`, `mapChromeBrowserLogs`, `chromeLogLevelToLogLevel`), `error` (`serializeError`, `errorMessage`), `finalize-screencast`, `net` (`isPortInUse`, `findFreePort`, `getRequestType`), `performance-capture` (`CAPTURE_PERFORMANCE_SCRIPT`, `applyPerformanceData`), `retry-tracker`, `script-loader` (`loadInjectableScript`, `pollUntilReady`), `stack` (`isUserCodeFrame`, `normalizeFilePath`, `getCallSourceFromStack`), `suite-helpers`, `test-discovery` (`findTestDefinitions`, `extractTestMetadata`), `uid` (`generateStableUid`, `deterministicUid`, `resetSignatureCounters`), `video-encoder` (`encodeToVideo`).
+
+Imports from: `shared`. Imported by: all three adapter packages.
+
+### `packages/service` — WebdriverIO adapter
+
+WebdriverIO-specific glue.
+
+Contains: WDIO service hooks (`beforeCommand`, `afterCommand`, `beforeTest`, `afterTest`, `beforeSession`, `afterSession`, `onPrepare`, `onComplete`), a reporter that extends WDIO's `Reporters.ReporterEntry`, the BiDi listener wiring (`bidi-listeners.ts`), launcher entry point, cucumber step-definition AST scanning, and the standalone runner (`standalone.ts`).
+
+Imports from: `@wdio/types`, `@wdio/reporter`, `@wdio/logger`, `@wdio/protocols`, `webdriverio`, `core`, `shared`.
+
+### `packages/nightwatch-devtools` — Nightwatch adapter
+
+Nightwatch-specific glue.
+
+Contains:
+
+- The `NightwatchDevToolsPlugin` class + factory in `index.ts`.
+- Lifecycle modules: `run-lifecycle.ts`, `test-lifecycle.ts`, `cucumber-lifecycle.ts`, `session-init.ts`, `event-hub.ts`.
+- `BrowserProxy` (in `helpers/`) that wraps Nightwatch's browser API and forwards each command into the session capturer.
+- A `SessionCapturer` subclass + a Nightwatch-flavored `SuiteManager` / `TestManager`.
+- BiDi opt-in support (gated on `bidi: true` in plugin options + the `webSocketUrl: true` capability).
+- Cucumber wiring: `cucumberHooks.cjs` (registered via the Cucumber `require` option), feature-file scanning, step-definition resolution.
+- A perf-log → NetworkRequest parser (`helpers/perfLogs.ts`) for the CDP perf-log path when BiDi isn't attached.
+
+Imports from: `@wdio/logger`, `core`, `shared`. Does not import: other adapter packages, `backend`, `app`.
+
+### `packages/selenium-devtools` — Selenium adapter
+
+Selenium-webdriver-specific glue.
+
+Contains:
+
+- `driverPatcher.ts` — wraps `selenium-webdriver`'s `WebDriver` / `WebElement` / `Builder` prototypes with command capture.
+- Per-runner hooks for Mocha, Jest, Jasmine, Vitest, and Cucumber (`runnerHooks/*.ts`).
+- Native BiDi via `selenium-webdriver/bidi`.
+- Driver-launch + dashboard-launch helpers, detached-backend mode, process-hook shutdown.
+- `SessionCapturer` subclass + Selenium-flavored `SuiteManager` / `TestManager`.
+
+Imports from: `core`, `shared`, `selenium-webdriver` (peer). Does not import: other adapter packages, `backend`, `app`.
+
+### `packages/backend`
+
+The server adapters connect to and the app talks to.
+
+Contains:
+
+- Fastify HTTP server.
+- WebSocket gateway: one connection per adapter worker, one per app client.
+- Baseline store (in-memory) for preserve-and-rerun; reuses `shared` types directly via thin `*Like` aliases (`baseline/types.ts`).
+- Test runner spawner (`runner.ts`) — spawns the user's `wdio` / `nightwatch` / `selenium` binary with rerun filters.
+- Framework-specific CLI args live in `framework-filters.ts` — a `switch` over `TestRunnerId` returning the right `FilterBuilder`. (The switch shape is deliberate: CodeQL trusts compile-time-known callable selection, table dispatch trips its `unvalidated-dynamic-method-call` query.)
+- Bin resolver (`bin-resolver.ts`) — finds the WDIO/Nightwatch CLI in the user's `node_modules/` or `npx` cache.
+- Worker-message handler (`worker-message-handler.ts`) — dispatches messages from spawned workers (config/sessionId/videoPath/...).
+
+Framework awareness lives only in `runner.ts` and `framework-filters.ts`, always through `TestRunnerId`, never magic strings.
+
+Imports from: `shared`. Does not import: any adapter package, `app`, or `core` (the backend doesn't capture; core is for capturers).
+
+### `packages/app`
+
+The browser UI.
+
+Contains:
+
+- Lit web components (sidebar/explorer, workbench/compare, workbench/console, workbench/network, workbench/snapshot, etc.).
+- WebSocket client for the live event stream.
+- Context providers (`@lit/context`) for each data stream.
+- `DataManagerController` — orchestrates the WS connection and the 11 context providers (one per scope).
+- Pure helpers: suite-merge logic, mark-running logic, run-detection logic, context-update transforms (`contextUpdates.ts`), runner-capability derivations (`runnerCapabilities.ts`).
+
+Imports from: `shared`. Does not import: any adapter package, `backend` directly (only via WS/HTTP), `core`.
+
+### `packages/script`
+
+Browser-injected runtime — runs **inside the page under test**, not in Node.
+
+Contains: DOM mutation observers, page-side trace collection, a small logger. It's loaded into the page via `loadInjectableScript()` (which reads the built `dist/script.js`) and communicates back through the WebDriver bridge (`executeScript` / `getLog`), not directly to the backend.
+
+The execution environment is the browser, not Node, so this package cannot import from `core` (Node-only) or from non-browser-safe parts of `shared`.
+
+### `examples/`
+
+Per-framework demo projects used for manual verification.
+
+- `examples/wdio/` — WebdriverIO with Mocha (default). Run via `pnpm demo:wdio`.
+- `examples/nightwatch/` — Nightwatch (both vanilla and Cucumber). Run via `pnpm demo:nightwatch`.
+- `examples/selenium/` — Selenium with subdirs for `mocha-test/`, `jest-test/`, `cucumber-test/`, `jasmine-test/`, `vitest-test/`. `pnpm demo:selenium` runs mocha; `pnpm --filter @wdio/selenium-devtools example:<runner>` runs the others.
+
+---
+
+## Data flow
+
+### A test run, end to end
+
+1. The user runs their normal command (`wdio run …`, `nightwatch test`, `mocha + selenium`, ...).
+2. The framework loads its adapter via service/plugin config.
+3. The adapter constructs a `SessionCapturer` (subclass of `core`'s `SessionCapturerBase`). The base class opens a WS connection to the backend, patches `console.*`, intercepts stdout/stderr, and installs the upstream-send guard.
+4. The framework fires lifecycle hooks (suite/test start, command, etc.). The adapter translates each into a `core` call.
+5. `core` builds the typed event per `shared` schema and pushes it through the WS.
+6. `backend` receives the event, optionally persists it (baseline store, video registry), and broadcasts to every connected app client.
+7. `app` updates its Lit components reactively via the context providers.
+
+### Preserve-and-rerun
+
+1. User clicks "📌 Preserve & Rerun" on a failed test in the dashboard.
+2. App POSTs to `/api/baseline/preserve` (typed contract in `shared`).
+3. Backend snapshots the failing attempt into the baseline store, then spawns a rerun via `runner.ts`.
+4. The rerun goes through the normal flow above.
+5. App receives both attempts and renders the side-by-side compare view.
+
+### Rerun mechanics
+
+`backend/src/runner.ts` is the only place outside an adapter that knows about specific frameworks. It uses `TestRunnerId` from shared and dispatches via `framework-filters.ts`'s `switch`:
+
+- `cucumber`: `--spec <feature[:line]>` and/or `--cucumberOpts.name <regex>`.
+- `mocha`/`jasmine`: `--spec <file>` + `--mochaOpts.grep`/`--jasmineOpts.grep`.
+- `nightwatch`: positional spec file + optional `--testcase <name>`.
+- `nightwatch-cucumber`: `--name <regex>` (feature files via `feature_path` config).
+- Unknown/missing: spec-only fallback.
+
+Everywhere else in the system, events are framework-agnostic.
+
+---
+
+## Boundaries
+
+Every data crossing between packages goes through a typed contract in `shared`:
+
+| Boundary | Direction | Transport | Lives in |
+|---|---|---|---|
+| Adapter → backend | One-way events (command, console, network, mutation, …) | WebSocket frames | `shared/ws.ts` (`SocketMessage<T>`) |
+| App → backend | Preserve, clear, run, stop, get-baseline | HTTP (Fastify) | `shared/baseline.ts`, `shared/runner.ts` |
+| Backend → app | Live event broadcast + API responses | WebSocket + HTTP | `shared/ws.ts`, `shared/baseline.ts` |
+| Backend → spawned worker | Run config, rerun env, video paths | Env vars + IPC | `shared/runner.ts` (`REUSE_ENV`, `RUNNER_ENV`) |
+| Script → adapter | Mutation events, trace data | `executeScript` return values + `getLog` channel | Implicit in adapter — script's payload shape is consumed by core's `processTracePayload` |
+
+New events or HTTP routes start with a `shared` change. The other packages then import the contract.
+
+---
+
+## Where things live
+
+The repo has converged on a clear ownership story. When in doubt, the top-down decision tree is:
+
+- A type, constant, enum, schema, or contract used by more than one package → **`shared`**.
+- Capture, parsing, normalization, sourcemap, UID, reporter, screencast, or WS-framing logic that doesn't depend on a specific framework's API → **`core`**.
+- A specific framework's hook, driver patch, or runner integration → the matching **adapter** package. Adapter code calls `core` for the actual work and only owns the hook registration.
+- A backend HTTP route, WS handler, or rerun behavior → **`backend`**, with the contract added to `shared` first.
+- UI → **`app`**, consuming `shared` contracts only.
+- Code that runs inside the browser under test → **`script`**.
+
+A few cross-cutting conventions follow from this layout:
+
+- Adapter packages don't import each other. Anything two adapters would both want lives in `core`.
+- Backend doesn't import adapter packages, and adapter packages don't import backend or app.
+- The script package is a leaf — adapters load its built bundle as a string and inject it; they don't import from it at runtime.
+- `shared` and `core` are private workspace packages. Consumers bundle them. The bundler config has to inline them (not externalize) or the published artifact won't resolve — see the build-config notes in `CLAUDE.md`.
+
+---
+
+## Current state
+
+The architecture above is the actual state of the repo. Where it diverges from the ideal, the divergences are tracked in [CLAUDE.md §7](./CLAUDE.md#known-debt).
+
+Notable in-place pieces worth knowing about:
+
+- `replaceCommand` has two semantics across adapters — Selenium mutates the existing entry in place (preserves `_id`/`id` continuity for chained calls); Nightwatch splices and reissues with a new `_id`. Both call the same `core/suite-helpers` factories; the storage strategy stays adapter-specific because the runner integrations differ.
+- `patchNodeAssert` is wired only in `selenium-devtools` (Selenium's primary assertion style is `node:assert`). The shared helper lives in `core/assert-patcher`; Service and Nightwatch can opt in via a one-line call when they need to, but it's not auto-enabled because both communities lean on chai/expect.
+- BiDi is auto-attached in Service and Selenium. Nightwatch is opt-in via `bidi: true` and requires `webSocketUrl: true` in capabilities — historically Nightwatch users haven't all enabled BiDi by default.
+- Performance API capture (`CAPTURE_PERFORMANCE_SCRIPT`) is identical across all three adapters; each wires it into its own afterCommand-equivalent path.
+- Output directory for screencast videos and trace files is resolved through `core/resolveAdapterOutputDir` — adapters feed `userConfiguredDir` (WDIO honors `wdio.conf.ts`'s `outputDir`/`rootDir`), `testFilePath` (Selenium/Nightwatch), and `configPath` (Nightwatch), and the helper picks the first writable, non-`node_modules/` candidate.
+
+For per-package implementation details, see each package's `README.md`
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..c3736982
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,262 @@
+# Repo conventions
+
+This file describes the conventions in place across the devtools monorepo — how code is organized, how packages relate to each other, how tests are structured, and what the coding style looks like. It's the companion to [ARCHITECTURE.md](./ARCHITECTURE.md): that file says where the pieces are; this one says why they're shaped the way they are and what to look for when adding or changing code.
+
+Anyone working in the repo, human or AI agent, can use this as the source of truth for "how do we do things here."
+
+---
+
+## What this repo is
+
+A devtools dashboard for end-to-end browser tests. Three test frameworks (WebdriverIO, Nightwatch, Selenium) push the same normalized event stream through a single backend into a single Lit-based browser UI. The adapters are deliberately thin — they translate framework hooks into calls on a shared core capture/reporting library and own only the framework-specific glue.
+
+Package map and data flow are in [ARCHITECTURE.md](./ARCHITECTURE.md). The summary: `shared` for types and contracts, `core` for framework-agnostic capture, three adapters (`service`, `nightwatch-devtools`, `selenium-devtools`) for framework glue, `backend` for the server, `app` for the UI, `script` for the page-injected runtime.
+
+---
+
+## Commands
+
+Run from repo root unless noted.
+
+| Command | What it does |
+|---|---|
+| `pnpm install` | Install workspace dependencies. |
+| `pnpm build` | Build all packages (`pnpm -r build`). |
+| `pnpm test` | Run vitest suite once. |
+| `pnpm test:watch` | Run vitest in watch mode. |
+| `pnpm test:coverage` | Run vitest with v8 coverage. The thresholds in `vitest.config.ts` are the floor — drops fail CI. |
+| `pnpm lint` | Lint all packages in parallel. Includes `eslint-plugin-security` for a subset of CodeQL findings; deeper taint-flow checks surface on the PR's CodeQL scan. |
+| `pnpm demo:wdio` / `pnpm demo:nightwatch` / `pnpm demo:selenium` | Run the per-framework example projects. Useful for manual verification of UI or runtime changes. |
+| `pnpm dev` | Run all packages in parallel dev mode. |
+
+`selenium-devtools` exposes per-runner variants of its example via `pnpm --filter @wdio/selenium-devtools example:mocha` / `:jest` / `:cucumber` / `:jasmine` / `:vitest`.
+
+---
+
+## Path aliases
+
+Defined in root `tsconfig.json`:
+
+| Alias | Resolves to |
+|---|---|
+| `@/*` | `packages/app/src/*` |
+| `@components/*` | `packages/app/src/components/*` |
+| `@core/*` | `packages/app/src/core/*` (app-internal — not the framework-agnostic `packages/core`) |
+| `@wdio/devtools-backend` / `*` | `packages/backend/src/...` |
+| `@wdio/devtools-script` / `*` | `packages/script/src/...` |
+| `@wdio/devtools-service` / `*` | `packages/service/src/...` |
+| `@wdio/selenium-devtools` / `*` | `packages/selenium-devtools/src/...` |
+| `@wdio/devtools-shared` / `*` | `packages/shared/src/...` |
+| `@wdio/devtools-core` / `*` | `packages/core/src/...` |
+
+These exist so imports stay short and grep-able. Long relative paths (`../../../components/…`) aren't used.
+
+The `@core/*` name is a historical alias for app-internal helpers and predates `packages/core`. They don't collide because they resolve to different roots, but the names are confusable.
+
+---
+
+## Conventions
+
+### One source of truth per concept
+
+Every shared type, constant, enum, schema, and HTTP/WS contract lives in `packages/shared`. Adapter packages and the app never re-declare a concept that already exists upstream — they re-export shared definitions when a local consumer name needs to stay stable (e.g. nightwatch's `TEST_FILE_PATTERN` is `export { SPEC_FILE_RE as TEST_FILE_PATTERN } from '@wdio/devtools-shared'`).
+
+When a duplicate is discovered, the next change that touches either copy consolidates them into shared.
+
+### Framework-agnostic logic lives in `core`
+
+Anything that captures, parses, normalizes, formats, or transports test-event data and doesn't depend on a specific framework's API lives in `packages/core`. Adapters call into core; they don't reimplement.
+
+If the same logical change would land in two or more adapters, the logic belongs in core. This rule produced the current `SessionCapturerBase`, `TestReporterBase`, `ScreencastRecorderBase`, `resolveAdapterOutputDir`, and the pure helpers around console capture, error serialization, UID generation, stack-trace parsing, BiDi attachment, and screencast finalization.
+
+Some helpers are framework-agnostic by nature but used in only one adapter today (e.g. nightwatch's `parseNetworkFromPerfLogs` for CDP perf-log parsing, selenium's `detectRunner`/`captureLaunchCommand`). They stay in their adapter until a second consumer appears; at that point they move to core.
+
+### Adapters are thin and isolated
+
+Adapter packages own only:
+
+- Framework-specific hook registration and lifecycle binding.
+- Framework-specific driver/browser patching.
+- Framework-specific config and capabilities.
+
+They import from `shared` and `core`, never from each other. They aren't imported by `backend` or `app`.
+
+### Backend and app are framework-agnostic
+
+`backend` and `app` import from `shared` only (for contracts) and from each other via the WS/HTTP boundary. Neither imports an adapter package.
+
+Framework-specific behavior in the backend is contained in two files: `runner.ts` and `framework-filters.ts`. Both branch on a typed `TestRunnerId` from shared, never on a magic string. The `framework-filters` dispatch is a `switch` over `TestRunnerId` (not a table lookup) so CodeQL's `unvalidated-dynamic-method-call` query trusts the call site.
+
+### Boundaries have typed contracts
+
+Every `fetch(...)` and `ws.send(...)` has a typed request/response shape in shared. `SocketMessage<T extends WsMessageScope>` is the canonical WS wire format — receivers narrow on `scope` to get the exact payload type per branch.
+
+No `any` crosses a package boundary. When a framework API forces a loosely-typed value (Nightwatch's `currentTest`, Selenium's BiDi events, raw HTTP payloads), the `any` is cast to a typed shape immediately at the boundary, with the cast site documenting why.
+
+### Workspace-internal packages stay bundled
+
+`packages/shared` and `packages/core` are `"private": true` and never published. Each consumer inlines their code into its own `dist/` at build time.
+
+- Both deps are listed in `devDependencies` with `workspace:^`, never in `dependencies`. Vite and tsup both externalize anything in `dependencies` by default; `devDependencies` is what gets inlined.
+- Neither is added to a bundler's `external` config. Vite's `external` callback receives both the bare package name *and* the resolved absolute path (e.g. `/Users/.../packages/core/src/index.ts`); a check for only one form silently externalizes the other.
+- The same callback receives bare relative imports (`./utils.js`, `../constants.js`). A check that allows only `./` will externalize `../`-style imports from subfolders and the dist crashes with `ERR_MODULE_NOT_FOUND` at install time.
+- `packages/service/vite.config.ts` is the canonical pattern for getting both right.
+- After any change to a bundler config or build script, `grep -E "@wdio/devtools-(core|shared)|/packages/(core|shared)/" packages/<pkg>/dist/*.js` should return nothing. That's how you catch the absolute-path leak.
+
+Bundlers in use: **vite** for `app`, `service`, `script`; **tsup** for `backend`, `nightwatch-devtools`, `selenium-devtools`.
+
+### Separation of concerns within a file
+
+Files own one concern:
+
+- UI components render. They don't `fetch`, manage WebSocket state, or run business logic.
+- Controllers and services own I/O and state. They don't render.
+- Backend route handlers wire requests to services. They don't contain business logic inline.
+- Reporters report. They don't also resolve sourcemaps, read files, and generate step UIDs in the same module.
+
+Mixed-concern files are split as they're touched. The app-side helpers like `contextUpdates.ts`, `runnerCapabilities.ts`, `renderDetailBlock.ts`, `compareUtils.ts`, `suite-merge.ts`, `mark-running.ts`, `run-detection.ts`, and `stepResolution.ts` are all extractions from larger god-files.
+
+### TypeScript
+
+- `strict: true` is on (root `tsconfig.json`).
+- No `any`. If a framework or library forces it, the `any` is isolated at the boundary and cast to a typed shape with a one-line comment explaining why. As of writing, there are no `no-explicit-any` warnings repo-wide.
+- No `as unknown as X` double-casts unless the reason is documented inline.
+- `type` for unions, `interface` for object shapes that may be extended.
+- Names exported from `shared` and `core` are public API of those packages — renames are breaking changes for downstream consumers.
+
+### Naming
+
+- One name per concept across the whole repo. The canonical test-status name is `TestStatus` in shared; the sidebar `TestState` is a value-only enum-style accessor over the same string union.
+- Constants are `SCREAMING_SNAKE_CASE`. Types are `PascalCase`. Functions and variables are `camelCase`. Files are `kebab-case.ts` unless they match a class name (`SessionCapturer.ts`).
+
+### File and function size
+
+Soft caps (warnings in `pnpm lint`, not errors):
+
+- **File**: 500 logic lines (blank lines and comments excluded). Files growing toward this cap are split as their sections are edited.
+- **Function**: 50 logic lines.
+
+A few declarative blocks (`#getInternals` accessor bags in the adapter plugins) exceed the function cap intentionally — splitting them artificially hurts readability. Those are marked with an inline `eslint-disable-next-line max-lines-per-function` plus a one-line justification.
+
+### Comments
+
+- Default to no comments. Names should explain *what*.
+- A comment is written only when the *why* is non-obvious: a hidden constraint, a workaround for a specific bug, a subtle invariant, behavior that would surprise a reader.
+- `// TODO`, `// added for X`, `// removed Y`, `// keep in sync` aren't used — the first three belong in git history; the fourth means a single source of truth is missing.
+- One line max. Multi-paragraph docstrings aren't used.
+
+### Error handling
+
+- Validation happens at boundaries (HTTP input, WS messages, framework callbacks). Internal code is trusted.
+- Errors aren't swallowed silently. `catch` only adds context, then rethrows or logs with enough detail to debug. Empty catches don't appear in production code.
+
+### Dead code
+
+Unused exports, unused imports, commented-out blocks, and `_unused` parameters get deleted when discovered. Git history is the safety net for "in case we need it later" code.
+
+---
+
+## Testing
+
+The repo uses **vitest** at the root. The current state: 566 tests across 47 files; thresholds at `vitest.config.ts` enforce a floor of 85/77/86/85 (statements/branches/functions/lines). Coverage is ratcheted upward as gaps close, never downward.
+
+### What gets tested
+
+- **`shared` and `core`**: unit tests for every exported function and type guard. These are the foundation; regressions cascade.
+- **Bug fixes (any package)**: a regression test that fails before the fix and passes after. When a real test is genuinely impossible (e.g. requires a live browser the infra doesn't have), the PR description says so.
+- **New HTTP/WS contracts**: a test that exercises the contract end-to-end at least once.
+
+### Adapter and backend logic
+
+Non-trivial parsing or transformation logic in adapters has unit tests. Hook wiring is verified manually via `examples/<framework>/`. `backend` and `app` test their non-UI logic (parsers, transforms, state reducers); UI verification is manual.
+
+### Manual verification
+
+For UI or runtime changes, `examples/<framework>/` is the verification harness. Type-checks and unit tests verify code correctness, not feature correctness — claiming a UI change works on the basis of `tsc --noEmit` alone misses the point.
+
+When CI can't run an example (no real browser), the PR description says so explicitly.
+
+### Skipping tests that depend on workspace-internal build artifacts
+
+A handful of tests need `@wdio/devtools-script` to be built first (the browser-injected bundle). CI test jobs sometimes run before that build step; those tests gate on `it.skipIf` after probing `createRequire(import.meta.url).resolve('@wdio/devtools-script')`. Locally they run normally.
+
+---
+
+## Workflow
+
+### When adding code
+
+The decision tree from [ARCHITECTURE.md "Where things live"](./ARCHITECTURE.md#where-things-live) is the starting point. The general shape:
+
+- Shared concept → `shared`.
+- Framework-agnostic capture/reporting logic → `core`.
+- Framework-specific glue → the matching adapter.
+- Server route/WS handler → `backend` (contract in `shared` first).
+- UI → `app`.
+- Code that runs in the browser under test → `script`.
+
+When the right place is ambiguous (something between `shared` and `core`, or between `core` and an adapter), the question that resolves it is: *who else would want this?* If the answer is "any future adapter would," it's `core`. If "only the framework with X-specific API does," it's the adapter.
+
+### While editing
+
+- Boy-scout rule applies: when touching a file or section, leave it more aligned with these conventions than it was found. Touch a duplicated type, consolidate it into shared. Touch a section of a god-file, split that section out. Touch a magic-string framework check, replace it with `TestRunnerId`. The cleanup scope matches the change scope — don't rewrite the whole file, but don't leave a clear convention violation in lines just touched.
+- New code doesn't introduce violations to match existing style. Where existing style violates these conventions, that's documented debt (§ Known debt), not a template.
+
+### Before pushing
+
+- `pnpm build`, `pnpm test`, `pnpm lint`. Don't push red.
+- For UI or runtime changes: verify in `examples/<framework>/`.
+- Deeper security findings (taint flow, polynomial-redos with adjacent quantifiers) surface on the PR's CodeQL scan; review and fix those before merge.
+
+### Commits
+
+- Small, focused. Don't bundle unrelated changes.
+- Imperative mood. The commit message explains *why*; the diff shows *what*.
+- New commits, not amends to pushed/shared commits.
+- No `--no-verify` to skip hooks. If a hook fails, the underlying issue gets fixed.
+
+### PRs
+
+- One concern per PR. A refactor and a feature are two PRs.
+- A PR touching more than one adapter package answers in its description: *why isn't this in `core`?*
+
+---
+
+## Known debt
+
+Documented divergences from the conventions above. They exist today as debt to be paid down, not exceptions to the rules. Each change reduces this list; new violations don't get added.
+
+### Architecture
+
+- `replaceCommand` has two semantics — Selenium mutates in place (preserves `_id`/`id` for chained calls); Nightwatch splices and reissues. Both call the same `core/suite-helpers` factories; the storage strategy stays adapter-specific because runner integrations differ. Could be unified by parameterizing the policy if the divergence ever causes a real problem.
+- `patchNodeAssert` is wired only in `selenium-devtools`. The shared helper lives in `core/assert-patcher`; Service and Nightwatch can opt in via a one-line call when ready. Not auto-enabled — both communities lean on chai/expect.
+- BiDi is auto-attached in Service and Selenium; Nightwatch is opt-in via `bidi: true` and requires `webSocketUrl: true` in capabilities.
+
+### File-size (raw line counts; soft cap is 500 logic lines)
+
+None of the entries below trigger the `max-lines` lint rule after `skipBlankLines`/`skipComments`. They're documented because their raw line count is over 500, and the next substantive change to any of them should still look for an extraction opportunity.
+
+- `packages/nightwatch-devtools/src/index.ts` (~536 raw). Cucumber/test/run-lifecycle, session-init, event-hub modules already extracted; remainder is the `PluginInternals` accessor bag plus per-method delegators plus the factory. Accept-as-is.
+- `packages/selenium-devtools/src/index.ts` (~560 raw). Session/test-lifecycle extracted; remainder is the `PluginInternals` accessor bag plus onCommand/onDriverCreated wiring. Same situation as nightwatch.
+- `packages/nightwatch-devtools/src/session.ts` (~468). `captureNetworkFromPerformanceLogs` + `captureBrowserLogs` + `captureTrace` are tightly coupled to NightwatchBrowser state. Coverage at 78% after recent backfill; further extraction would need rewriting the browser-coupling.
+
+### Test coverage gaps (worst-risk-first)
+
+Numbers reflect actual `pnpm test:coverage` output.
+
+- `packages/selenium-devtools/src/session.ts` — **83%**. Remaining branches are inside http-error / no-such-session paths that need a real driver to exercise.
+- `packages/nightwatch-devtools/src/session.ts` — **78%**. `takeScreenshotViaHttp` error branches need real WebDriver.
+- `packages/service/src/screencast.ts` — **76%**. CDP fast-path branches hard to exercise without a real Chrome.
+- `packages/backend/src/baselineStore.ts` — **91%**. Remaining 9% is leaf-error paths.
+
+The threshold gate in `vitest.config.ts` enforces the current floor — it ratchets upward as gaps close, never downward.
+
+### Type-safety
+
+No known violations. New ones get tracked here as discovered.
+
+---
+
+## Living document
+
+This file evolves with the repo. When a convention turns out to be wrong in practice, the right fix is to update the convention, not to silently break it. When a recurring decision point isn't covered here, it gets added.
diff --git a/README.md b/README.md
index 8e13fdc1..62a6448f 100644
--- a/README.md
+++ b/README.md
@@ -39,14 +39,14 @@ Works with **WebdriverIO**, **[Nightwatch.js](./packages/nightwatch-devtools/REA
 
 ### 🎬 Session Screencast
 - **Automatic Video Recording**: Captures a continuous `.webm` video of the browser session alongside the existing snapshot and DOM mutation views
-- **Cross-Browser**: Uses Chrome DevTools Protocol (CDP) push mode for Chrome/Chromium; automatically falls back to screenshot polling for Firefox, Safari, and other browsers (no configuration change needed)
+- **Per-framework modes**:
+  - **WebdriverIO**: CDP push mode for Chrome/Chromium (efficient, no per-command overhead); polling fallback for other browsers
+  - **Selenium WebDriver**: CDP push mode via `selenium-webdriver/bidi`; polling fallback otherwise
+  - **Nightwatch.js**: Polling mode (Nightwatch doesn't expose a stable CDP escape hatch); works on every browser Nightwatch supports
 - **Per-Session Videos**: Each browser session (including sessions created by `browser.reloadSession()`) produces its own recording, selectable from a dropdown in the UI
 - **Smart Trimming**: Leading blank frames before the first URL navigation are automatically removed so videos start at the first meaningful page action
 
-> **Note:** Screencast recording is currently supported for **WebdriverIO only**. Nightwatch.js support is planned for a future release.
->
-
-> For setup, configuration options, and prerequisites see the **[service README](./packages/service/README.md#screencast-recording)**.
+> For setup, configuration options, and prerequisites see each adapter's README: **[WebdriverIO](./packages/service/README.md#screencast-recording)** · **[Selenium](./packages/selenium-devtools/README.md)** · **[Nightwatch](./packages/nightwatch-devtools/README.md#screencast)**.
 
 ### 🐞 Preserve & Rerun (Compare)
 - **When the bug icon appears**: Only on test/suite rows in a `failed` state and the icon sits next to ▶ on hover, available wherever a plain rerun is supported (e.g. Cucumber scenarios at the scenario row, Mocha tests at the test or suite row)
@@ -54,7 +54,19 @@ Works with **WebdriverIO**, **[Nightwatch.js](./packages/nightwatch-devtools/REA
 - **Diagnose flaky tests**: See exactly which command differed between a pass and a fail without re-reading logs
 - **Pop out**: Open the comparison in a separate, themed window for a roomier view
 
-> **Note:** Preserve & Rerun is currently supported for **WebdriverIO only**. Nightwatch.js and Selenium support is planned for a future release.
+> Available across **WebdriverIO, Selenium WebDriver, and Nightwatch.js**. The rerun mechanism differs per framework (WDIO uses `--spec` + grep, Selenium substitutes a runner-specific filter flag like `--grep`/`--testNamePattern`, Nightwatch reads `DEVTOOLS_RERUN_LABEL`); the dashboard contract is identical.
+
+### 🌐 BiDi capture (browser console + JS exceptions + network)
+
+Real-time capture of browser-side events through the WebDriver BiDi protocol — entries arrive in the dashboard as they happen instead of being scraped after each command.
+
+| Adapter | BiDi source | Default | How to enable |
+|---|---|---|---|
+| **WebdriverIO** | WDIO's native `browser.on('log.entryAdded' \| 'network.*')` | On | Automatic when the driver advertises BiDi (Chrome ≥114) |
+| **Selenium WebDriver** | `selenium-webdriver/bidi/{logInspector, networkInspector}` | On when available | Automatic; `ensureBidiCapability` sets `webSocketUrl=true` on the Builder |
+| **Nightwatch.js** | Same `selenium-webdriver/bidi` inspectors (Nightwatch ships selenium-webdriver internally) | Opt-in | `globals: nightwatchDevtools({ bidi: true })` + `desiredCapabilities: { webSocketUrl: true }` |
+
+When BiDi is active in Selenium or Nightwatch, the per-command Chrome performance-log network-capture path is gated off so requests don't appear twice in the dashboard. The attach + sink logic lives in `@wdio/devtools-core`'s `bidi.ts` — same module both adapters consume.
 
 ### 🔍︎ TestLens
 - **Code Intelligence**: View test definitions directly in your editor
@@ -63,11 +75,13 @@ Works with **WebdriverIO**, **[Nightwatch.js](./packages/nightwatch-devtools/REA
 - **Status Indicators**: Visual feedback for test pass/fail states in the editor
 
 ### 🏗️ Architecture
-- **Frontend**: Lit web components with reactive state management (@lit/context)
+- **Frontend**: Lit web components with reactive state management (`@lit/context`)
 - **Backend**: Fastify server with WebSocket streaming for real-time updates
-- **Service**: WebdriverIO reporter integration with stable UID generation
+- **Shared core**: All three adapters share the same capture/reporting library (`@wdio/devtools-core`) — `SessionCapturerBase`, `TestReporterBase`, `ScreencastRecorderBase`, plus pure helpers for console/network/error/sourcemap/BiDi
 - **Process Management**: Tree-kill for proper cleanup of spawned processes
 
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for the full package map and data flow, and [CLAUDE.md](./CLAUDE.md) for the conventions in place across the repo.
+
 ## Demo
 
 ### 🛠️ Test Rerunner & Snapshot
@@ -143,7 +157,7 @@ pnpm install
 pnpm build
 
 # Run demo
-pnpm demo
+pnpm demo:wdio
 ```
 
 ## Nightwatch Integration
@@ -162,14 +176,18 @@ Using `selenium-webdriver` directly — under Mocha, Jest, Cucumber, or a plain
 
 ```
 packages/
+├── shared/                # Types, constants, HTTP/WS contracts — single source of truth
+├── core/                  # Framework-agnostic capture/reporting library (SessionCapturerBase, etc.)
 ├── app/                   # Frontend Lit-based UI application
-├── backend/               # Fastify server with test runner management
-├── service/               # WebdriverIO service and reporter
-├── script/                # Browser-injected trace collection script
-├── nightwatch-devtools/   # Nightwatch adapter plugin
-└── selenium-devtools/     # Selenium WebDriver adapter plugin
+├── backend/               # Fastify server, WS gateway, baseline store, rerun spawner
+├── script/                # Browser-injected trace collection script (runs in the page under test)
+├── service/               # WebdriverIO adapter (@wdio/devtools-service)
+├── nightwatch-devtools/   # Nightwatch adapter (@wdio/nightwatch-devtools)
+└── selenium-devtools/     # Selenium WebDriver adapter (@wdio/selenium-devtools)
 ```
 
+`shared` and `core` are workspace-internal (`"private": true`) — every consumer bundles them into its own `dist/` at build time. The three adapter packages each translate framework-specific hooks into calls on `core`'s shared capture library; `backend` and `app` import only from `shared` and communicate via the WS/HTTP boundary.
+
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
diff --git a/eslint.config.cjs b/eslint.config.cjs
index f037455e..ca64c748 100644
--- a/eslint.config.cjs
+++ b/eslint.config.cjs
@@ -5,6 +5,7 @@ const importPlugin = require('eslint-plugin-import')
 const unicorn = require('eslint-plugin-unicorn')
 const prettierConfig = require('eslint-config-prettier')
 const prettierPlugin = require('eslint-plugin-prettier')
+const security = require('eslint-plugin-security')
 
 module.exports = [
   {
@@ -86,11 +87,286 @@ module.exports = [
     }
   },
 
-  // TypeScript test files
+  // Code-quality warnings (CLAUDE.md §3).
+  // Kept as `warn` so existing legacy violations surface in IDE/CI without
+  // blocking the build. Promote to `error` once known debt (CLAUDE.md §7)
+  // is cleared.
+  // MUST come before the test-file override block — flat config rule blocks
+  // apply in order, so later blocks override earlier ones for matching files.
+  {
+    files: ['**/*.ts'],
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'warn',
+      'max-lines': [
+        'warn',
+        { max: 500, skipBlankLines: true, skipComments: true }
+      ],
+      'max-lines-per-function': [
+        'warn',
+        { max: 50, skipBlankLines: true, skipComments: true, IIFEs: true }
+      ]
+    }
+  },
+
+  // Security rules — local mirror of the high-signal CodeQL findings that
+  // burned us in CI. Keeps the round-trip short: `pnpm lint` flags the same
+  // patterns the PR's CodeQL scan would. GitHub-managed default-setup CodeQL
+  // still runs as the authoritative gate (it has taint flow /
+  // interprocedural analysis these rules can't match).
+  //
+  // Rule selection is conservative — rules that produced >0 true positives
+  // here or that fire on unambiguously bad patterns (eval, new Buffer).
+  // Excluded:
+  //   - detect-non-literal-fs-filename: 50+ false positives on legitimate
+  //     internal file reads (config/test-file discovery, source loading).
+  //   - detect-non-literal-require: createRequire patterns are by design.
+  //   - detect-object-injection: fires on every `arr[i]`.
+  //   - detect-possible-timing-attacks: not relevant for this dashboard.
+  {
+    files: ['**/*.{ts,tsx,js,mjs,cjs}'],
+    plugins: { security },
+    rules: {
+      // Matches CodeQL `js/polynomial-redos` + `js/redos`. The detector is
+      // somewhat over-conservative (flags benign `(\d+)?` patterns) but the
+      // false-positive cost (one-off review) is lower than missing a real
+      // ReDoS — keep at `warn`.
+      'security/detect-unsafe-regex': 'warn',
+      // Matches CodeQL `js/non-literal-regexp`. `new RegExp(userInput)` is a
+      // ReDoS vector; even when inputs are controlled it's worth eyes.
+      'security/detect-non-literal-regexp': 'warn',
+      // Matches CodeQL `js/code-injection`. Should never appear.
+      'security/detect-eval-with-expression': 'error',
+      // Node.js footguns that should never appear in production code.
+      'security/detect-buffer-noassert': 'error',
+      'security/detect-new-buffer': 'error',
+      'security/detect-pseudoRandomBytes': 'error'
+    }
+  },
+
+  // TypeScript test files — turns off the size rules. MUST come AFTER the
+  // production rules block above so the off-rule wins for matching files.
   {
     files: ['**/*.test.ts'],
     rules: {
-      'dot-notation': 'off'
+      'dot-notation': 'off',
+      'max-lines': 'off',
+      'max-lines-per-function': 'off',
+      // Test fixtures intentionally use `any` to construct partial mocks
+      // without restating every field of the real type. The cost of forcing
+      // proper types here is high (lots of `as unknown as RealType` casts)
+      // and the benefit is low — tests don't ship.
+      '@typescript-eslint/no-explicit-any': 'off',
+      // Tests legitimately build dynamic regexes from fixture data.
+      'security/detect-non-literal-regexp': 'off',
+      'security/detect-unsafe-regex': 'off'
+    }
+  },
+
+  // CLAUDE.md §2.3 — no cross-adapter imports.
+  // Adapters (service, nightwatch-devtools, selenium-devtools) own
+  // framework-specific glue only. Anything shared between them belongs in
+  // packages/core (and is currently duplicated — see CLAUDE.md §7).
+  {
+    files: ['packages/service/**/*.{ts,tsx,js,mjs,cjs}'],
+    rules: {
+      'no-restricted-imports': [
+        'error',
+        {
+          patterns: [
+            {
+              group: [
+                '@wdio/nightwatch-devtools',
+                '@wdio/nightwatch-devtools/*'
+              ],
+              message:
+                'Adapters must not import from each other (CLAUDE.md §2.3). Extract shared logic to packages/core.'
+            },
+            {
+              group: ['@wdio/selenium-devtools', '@wdio/selenium-devtools/*'],
+              message:
+                'Adapters must not import from each other (CLAUDE.md §2.3). Extract shared logic to packages/core.'
+            }
+          ]
+        }
+      ]
+    }
+  },
+  {
+    files: ['packages/nightwatch-devtools/**/*.{ts,tsx,js,mjs,cjs}'],
+    rules: {
+      'no-restricted-imports': [
+        'error',
+        {
+          patterns: [
+            {
+              group: ['@wdio/devtools-service', '@wdio/devtools-service/*'],
+              message:
+                'Adapters must not import from each other (CLAUDE.md §2.3). Extract shared logic to packages/core.'
+            },
+            {
+              group: ['@wdio/selenium-devtools', '@wdio/selenium-devtools/*'],
+              message:
+                'Adapters must not import from each other (CLAUDE.md §2.3). Extract shared logic to packages/core.'
+            }
+          ]
+        }
+      ]
+    }
+  },
+  {
+    files: ['packages/selenium-devtools/**/*.{ts,tsx,js,mjs,cjs}'],
+    rules: {
+      'no-restricted-imports': [
+        'error',
+        {
+          patterns: [
+            {
+              group: ['@wdio/devtools-service', '@wdio/devtools-service/*'],
+              message:
+                'Adapters must not import from each other (CLAUDE.md §2.3). Extract shared logic to packages/core.'
+            },
+            {
+              group: [
+                '@wdio/nightwatch-devtools',
+                '@wdio/nightwatch-devtools/*'
+              ],
+              message:
+                'Adapters must not import from each other (CLAUDE.md §2.3). Extract shared logic to packages/core.'
+            }
+          ]
+        }
+      ]
+    }
+  },
+
+  // CLAUDE.md §2.4 — backend does not import from adapters or app.
+  // Backend is framework-agnostic; framework branching uses a typed
+  // FrameworkId from packages/shared, never adapter internals.
+  {
+    files: ['packages/backend/**/*.{ts,tsx,js,mjs,cjs}'],
+    rules: {
+      'no-restricted-imports': [
+        'error',
+        {
+          patterns: [
+            {
+              group: ['@wdio/devtools-service', '@wdio/devtools-service/*'],
+              message:
+                'Backend must not depend on any adapter (CLAUDE.md §2.4). Move shared types/constants to packages/shared.'
+            },
+            {
+              group: [
+                '@wdio/nightwatch-devtools',
+                '@wdio/nightwatch-devtools/*'
+              ],
+              message:
+                'Backend must not depend on any adapter (CLAUDE.md §2.4). Move shared types/constants to packages/shared.'
+            },
+            {
+              group: ['@wdio/selenium-devtools', '@wdio/selenium-devtools/*'],
+              message:
+                'Backend must not depend on any adapter (CLAUDE.md §2.4). Move shared types/constants to packages/shared.'
+            },
+            {
+              group: ['@/*', '@components/*'],
+              message:
+                'Backend must not import from app (CLAUDE.md §2.4). App talks to backend over WS/HTTP using shared contracts.'
+            },
+            {
+              group: ['@wdio/devtools-core', '@wdio/devtools-core/*'],
+              message:
+                'Backend must not depend on core (CLAUDE.md §2.2). core is framework-agnostic adapter logic; backend only needs shared contracts.'
+            }
+          ]
+        }
+      ]
+    }
+  },
+
+  // CLAUDE.md §2.4 — app does not import from adapters or backend.
+  // App communicates with backend only over WS/HTTP, with contracts
+  // defined in packages/shared.
+  {
+    files: ['packages/app/**/*.{ts,tsx,js,mjs,cjs}'],
+    rules: {
+      'no-restricted-imports': [
+        'error',
+        {
+          patterns: [
+            {
+              group: ['@wdio/devtools-service', '@wdio/devtools-service/*'],
+              message:
+                'App must not import from adapters (CLAUDE.md §2.4). Move shared types/constants to packages/shared.'
+            },
+            {
+              group: [
+                '@wdio/nightwatch-devtools',
+                '@wdio/nightwatch-devtools/*'
+              ],
+              message:
+                'App must not import from adapters (CLAUDE.md §2.4). Move shared types/constants to packages/shared.'
+            },
+            {
+              group: ['@wdio/selenium-devtools', '@wdio/selenium-devtools/*'],
+              message:
+                'App must not import from adapters (CLAUDE.md §2.4). Move shared types/constants to packages/shared.'
+            },
+            {
+              group: ['@wdio/devtools-backend', '@wdio/devtools-backend/*'],
+              message:
+                'App must not import from backend directly (CLAUDE.md §2.4). Communicate via WS/HTTP using shared contracts.'
+            },
+            {
+              group: ['@wdio/devtools-core', '@wdio/devtools-core/*'],
+              message:
+                'App must not import from core (CLAUDE.md §2.2). core is framework-agnostic adapter logic; the app receives normalized events over WS.'
+            }
+          ]
+        }
+      ]
+    }
+  },
+
+  // CLAUDE.md §2.2 — core is for adapters only. Backend, app, and script
+  // must not depend on core. Core itself may only import from shared.
+  {
+    files: ['packages/core/**/*.{ts,tsx,js,mjs,cjs}'],
+    rules: {
+      'no-restricted-imports': [
+        'error',
+        {
+          patterns: [
+            {
+              group: ['@wdio/devtools-service', '@wdio/devtools-service/*'],
+              message:
+                'core must not depend on any adapter (CLAUDE.md §2.2). Adapters import core, not the other way around.'
+            },
+            {
+              group: [
+                '@wdio/nightwatch-devtools',
+                '@wdio/nightwatch-devtools/*'
+              ],
+              message:
+                'core must not depend on any adapter (CLAUDE.md §2.2). Adapters import core, not the other way around.'
+            },
+            {
+              group: ['@wdio/selenium-devtools', '@wdio/selenium-devtools/*'],
+              message:
+                'core must not depend on any adapter (CLAUDE.md §2.2). Adapters import core, not the other way around.'
+            },
+            {
+              group: ['@wdio/devtools-backend', '@wdio/devtools-backend/*'],
+              message:
+                'core must not depend on backend (CLAUDE.md §2.2). core is the lower layer.'
+            },
+            {
+              group: ['@/*', '@components/*'],
+              message:
+                'core must not depend on app (CLAUDE.md §2.2). core is Node-side adapter logic.'
+            }
+          ]
+        }
+      ]
     }
   }
 ]
diff --git a/example/package.json b/example/package.json
deleted file mode 100644
index 4d5f4e03..00000000
--- a/example/package.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "name": "examples",
-  "type": "module",
-  "devDependencies": {
-    "@wdio/cli": "9.27.0",
-    "@wdio/cucumber-framework": "9.27.0",
-    "@wdio/devtools-service": "workspace:*",
-    "@wdio/globals": "9.27.0",
-    "@wdio/local-runner": "9.27.0",
-    "@wdio/spec-reporter": "9.27.0",
-    "@wdio/types": "9.27.0",
-    "expect-webdriverio": "^5.4.0",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "tsx": "^4.20.3",
-    "typescript": "^6.0.2"
-  },
-  "scripts": {
-    "wdio": "wdio run ./wdio.conf.ts"
-  }
-}
diff --git a/packages/nightwatch-devtools/example/README.md b/examples/nightwatch/README.md
similarity index 100%
rename from packages/nightwatch-devtools/example/README.md
rename to examples/nightwatch/README.md
diff --git a/packages/nightwatch-devtools/example/nightwatch.conf.cjs b/examples/nightwatch/nightwatch.conf.cjs
similarity index 53%
rename from packages/nightwatch-devtools/example/nightwatch.conf.cjs
rename to examples/nightwatch/nightwatch.conf.cjs
index 5e2467d7..a817bf57 100644
--- a/packages/nightwatch-devtools/example/nightwatch.conf.cjs
+++ b/examples/nightwatch/nightwatch.conf.cjs
@@ -1,8 +1,10 @@
 // Simple import - just require the package
+const path = require('node:path')
 const nightwatchDevtools = require('@wdio/nightwatch-devtools').default
 
 module.exports = {
-  src_folders: ['example/tests'],
+  // Resolve relative to this config file so the path holds regardless of CWD.
+  src_folders: [path.resolve(__dirname, 'tests')],
   output_folder: false, // Skip generating nightwatch reports for this example
   // Add custom reporter to capture commands
   custom_commands_path: [],
@@ -21,6 +23,10 @@ module.exports = {
 
       desiredCapabilities: {
         browserName: 'chrome',
+        // Required for chromedriver to expose the BiDi WebSocket channel.
+        // Without this, attachBidiHandlers silently fails and the perf-log
+        // fallback takes over.
+        webSocketUrl: true,
         'goog:chromeOptions': {
           args: [
             '--headless',
@@ -31,8 +37,17 @@ module.exports = {
         },
         'goog:loggingPrefs': { performance: 'ALL' }
       },
-      // Simple configuration - just call the function to get globals
-      globals: nightwatchDevtools({ port: 3000 })
+      // Simple configuration - just call the function to get globals.
+      // - screencast: polling-mode .webm written to cwd as
+      //   nightwatch-video-<sessionId>.webm.
+      // - bidi: opt-in WebDriver BiDi capture for console + network. When
+      //   attached, the per-command Chrome perf-log network path is gated
+      //   off to avoid duplicate entries.
+      globals: nightwatchDevtools({
+        port: 3000,
+        screencast: { enabled: true, pollIntervalMs: 200 },
+        bidi: true
+      })
     }
   }
 }
diff --git a/examples/nightwatch/package.json b/examples/nightwatch/package.json
new file mode 100644
index 00000000..f3be394e
--- /dev/null
+++ b/examples/nightwatch/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "@wdio/devtools-example-nightwatch",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Nightwatch demo project used by pnpm demo:nightwatch. Needs its own node_modules so the backend's rerun spawner can resolve the nightwatch binary from this directory.",
+  "scripts": {
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@wdio/nightwatch-devtools": "workspace:^",
+    "nightwatch": "^3.16.0"
+  }
+}
diff --git a/packages/nightwatch-devtools/example/tests/login.js b/examples/nightwatch/tests/login.js
similarity index 100%
rename from packages/nightwatch-devtools/example/tests/login.js
rename to examples/nightwatch/tests/login.js
diff --git a/packages/nightwatch-devtools/example/tests/sample.js b/examples/nightwatch/tests/sample.js
similarity index 100%
rename from packages/nightwatch-devtools/example/tests/sample.js
rename to examples/nightwatch/tests/sample.js
diff --git a/examples/selenium/cucumber-test/cucumber.json b/examples/selenium/cucumber-test/cucumber.json
new file mode 100644
index 00000000..d479ab56
--- /dev/null
+++ b/examples/selenium/cucumber-test/cucumber.json
@@ -0,0 +1,12 @@
+{
+  "default": {
+    "import": [
+      "../../examples/selenium/cucumber-test/features/support/setup.js",
+      "../../examples/selenium/cucumber-test/features/support/world.js",
+      "../../examples/selenium/cucumber-test/features/support/steps.js"
+    ],
+    "paths": ["../../examples/selenium/cucumber-test/features/*.feature"],
+    "publishQuiet": true,
+    "format": ["progress"]
+  }
+}
diff --git a/packages/selenium-devtools/example/cucumber-test/features/login.feature b/examples/selenium/cucumber-test/features/login.feature
similarity index 100%
rename from packages/selenium-devtools/example/cucumber-test/features/login.feature
rename to examples/selenium/cucumber-test/features/login.feature
diff --git a/packages/selenium-devtools/example/cucumber-test/features/support/setup.js b/examples/selenium/cucumber-test/features/support/setup.js
similarity index 100%
rename from packages/selenium-devtools/example/cucumber-test/features/support/setup.js
rename to examples/selenium/cucumber-test/features/support/setup.js
diff --git a/packages/selenium-devtools/example/cucumber-test/features/support/steps.js b/examples/selenium/cucumber-test/features/support/steps.js
similarity index 100%
rename from packages/selenium-devtools/example/cucumber-test/features/support/steps.js
rename to examples/selenium/cucumber-test/features/support/steps.js
diff --git a/packages/selenium-devtools/example/cucumber-test/features/support/world.js b/examples/selenium/cucumber-test/features/support/world.js
similarity index 100%
rename from packages/selenium-devtools/example/cucumber-test/features/support/world.js
rename to examples/selenium/cucumber-test/features/support/world.js
diff --git a/packages/selenium-devtools/example/jest-test/jest.config.json b/examples/selenium/jest-test/jest.config.json
similarity index 100%
rename from packages/selenium-devtools/example/jest-test/jest.config.json
rename to examples/selenium/jest-test/jest.config.json
diff --git a/packages/selenium-devtools/example/jest-test/test/example.js b/examples/selenium/jest-test/test/example.js
similarity index 100%
rename from packages/selenium-devtools/example/jest-test/test/example.js
rename to examples/selenium/jest-test/test/example.js
diff --git a/packages/selenium-devtools/example/mocha-test/test/example.js b/examples/selenium/mocha-test/test/example.js
similarity index 100%
rename from packages/selenium-devtools/example/mocha-test/test/example.js
rename to examples/selenium/mocha-test/test/example.js
diff --git a/examples/selenium/package.json b/examples/selenium/package.json
new file mode 100644
index 00000000..cb046553
--- /dev/null
+++ b/examples/selenium/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "@wdio/devtools-example-selenium",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Selenium WebDriver demo project used by pnpm demo:selenium. Imports selenium-webdriver directly; needs its own node_modules.",
+  "type": "module",
+  "scripts": {
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@wdio/selenium-devtools": "workspace:^",
+    "selenium-webdriver": "^4.44.0"
+  },
+  "devDependencies": {
+    "@cucumber/cucumber": "^13.0.0"
+  }
+}
diff --git a/example/features/login.feature b/examples/wdio/features/login.feature
similarity index 100%
rename from example/features/login.feature
rename to examples/wdio/features/login.feature
diff --git a/example/features/pageobjects/login.page.ts b/examples/wdio/features/pageobjects/login.page.ts
similarity index 100%
rename from example/features/pageobjects/login.page.ts
rename to examples/wdio/features/pageobjects/login.page.ts
diff --git a/example/features/pageobjects/page.ts b/examples/wdio/features/pageobjects/page.ts
similarity index 100%
rename from example/features/pageobjects/page.ts
rename to examples/wdio/features/pageobjects/page.ts
diff --git a/example/features/pageobjects/secure.page.ts b/examples/wdio/features/pageobjects/secure.page.ts
similarity index 100%
rename from example/features/pageobjects/secure.page.ts
rename to examples/wdio/features/pageobjects/secure.page.ts
diff --git a/example/features/step-definitions/steps.ts b/examples/wdio/features/step-definitions/steps.ts
similarity index 100%
rename from example/features/step-definitions/steps.ts
rename to examples/wdio/features/step-definitions/steps.ts
diff --git a/examples/wdio/package.json b/examples/wdio/package.json
new file mode 100644
index 00000000..d3cc2104
--- /dev/null
+++ b/examples/wdio/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "examples",
+  "type": "module",
+  "devDependencies": {
+    "@wdio/cli": "9.27.2",
+    "@wdio/cucumber-framework": "9.27.2",
+    "@wdio/devtools-service": "workspace:*",
+    "@wdio/globals": "9.27.2",
+    "@wdio/local-runner": "9.27.2",
+    "@wdio/spec-reporter": "9.27.2",
+    "@wdio/types": "9.27.2",
+    "expect-webdriverio": "^5.6.7",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "wdio": "wdio run ./wdio.conf.ts"
+  }
+}
diff --git a/example/tsconfig.json b/examples/wdio/tsconfig.json
similarity index 100%
rename from example/tsconfig.json
rename to examples/wdio/tsconfig.json
diff --git a/example/wdio.conf.ts b/examples/wdio/wdio.conf.ts
similarity index 97%
rename from example/wdio.conf.ts
rename to examples/wdio/wdio.conf.ts
index 24ddf975..73e88052 100644
--- a/example/wdio.conf.ts
+++ b/examples/wdio/wdio.conf.ts
@@ -128,18 +128,19 @@ export const config: Options.Testrunner = {
   // your test setup with almost no effort. Unlike plugins, they don't add new
   // commands. Instead, they hook themselves up into the test process.
   services: [
-    [
-      'devtools',
-      {
-        screencast: {
-          enabled: true,
-          captureFormat: 'jpeg', // 'jpeg' or 'png' — frame format sent by Chrome over CDP
-          quality: 70, // JPEG quality 0–100
-          maxWidth: 1280, // max frame width in px
-          maxHeight: 720 // max frame height in px
-        }
-      }
-    ]
+    'devtools'
+    // [
+    //   'devtools',
+    //   {
+    //     screencast: {
+    //       enabled: true,
+    //       captureFormat: 'jpeg', // 'jpeg' or 'png' — frame format sent by Chrome over CDP
+    //       quality: 70, // JPEG quality 0–100
+    //       maxWidth: 1280, // max frame width in px
+    //       maxHeight: 720 // max frame height in px
+    //     }
+    //   }
+    // ]
   ],
   //
   // Framework you want to run your specs with.
diff --git a/package.json b/package.json
index 783835e6..5e4c703e 100644
--- a/package.json
+++ b/package.json
@@ -3,8 +3,9 @@
   "type": "module",
   "scripts": {
     "build": "pnpm -r build",
-    "demo": "wdio run ./example/wdio.conf.ts",
+    "demo:wdio": "wdio run ./examples/wdio/wdio.conf.ts",
     "demo:nightwatch": "pnpm --filter @wdio/nightwatch-devtools example",
+    "demo:selenium": "pnpm --filter @wdio/selenium-devtools example",
     "dev": "pnpm --parallel dev",
     "preview": "pnpm --parallel preview",
     "test": "vitest run",
@@ -18,7 +19,7 @@
   "pnpm": {
     "overrides": {
       "vite": "^8.0.7",
-      "@types/node": "25.5.2",
+      "@types/node": "25.9.1",
       "@codemirror/state": "6.5.4"
     },
     "onlyBuiltDependencies": [
@@ -27,32 +28,34 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "25.5.2",
-    "@typescript-eslint/eslint-plugin": "^8.40.0",
-    "@typescript-eslint/parser": "^8.40.0",
-    "@typescript-eslint/utils": "^8.40.0",
-    "@vitest/browser": "^4.0.16",
-    "autoprefixer": "^10.4.27",
-    "eslint": "^10.2.0",
+    "@types/node": "25.9.1",
+    "@typescript-eslint/eslint-plugin": "^8.60.1",
+    "@typescript-eslint/parser": "^8.60.1",
+    "@typescript-eslint/utils": "^8.60.1",
+    "@vitest/browser": "^4.1.8",
+    "@vitest/coverage-v8": "^4.1.8",
+    "autoprefixer": "^10.5.0",
+    "eslint": "^10.4.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-prettier": "^5.5.6",
+    "eslint-plugin-security": "4.0.0",
     "eslint-plugin-unicorn": "^64.0.0",
-    "happy-dom": "^20.0.11",
+    "happy-dom": "^20.9.0",
     "npm-run-all": "^4.1.5",
-    "postcss": "^8.5.9",
-    "postcss-lit": "^1.2.0",
-    "prettier": "^3.6.2",
-    "tailwindcss": "^4.1.12",
+    "postcss": "^8.5.15",
+    "postcss-lit": "^1.4.1",
+    "prettier": "^3.8.3",
+    "tailwindcss": "^4.3.0",
     "ts-node": "^10.9.2",
-    "tsx": "^4.20.4",
-    "typescript": "^6.0.2",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
     "unplugin-icons": "^23.0.1",
-    "vite": "^8.0.7",
-    "vitest": "^4.0.16",
-    "webdriverio": "^9.19.1"
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8",
+    "webdriverio": "^9.27.2"
   },
   "dependencies": {
-    "@wdio/cli": "9.27.0"
+    "@wdio/cli": "9.27.2"
   }
 }
diff --git a/packages/app/package.json b/packages/app/package.json
index 5ab423dc..d9182e6a 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@wdio/devtools-app",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Browser devtools extension for debugging WebdriverIO tests.",
   "type": "module",
   "repository": {
@@ -19,31 +19,32 @@
   "dependencies": {
     "@codemirror/lang-javascript": "^6.2.5",
     "@codemirror/theme-one-dark": "^6.1.3",
-    "@codemirror/view": "^6.38.1",
+    "@codemirror/view": "^6.43.0",
     "@iconify-json/mdi": "^1.2.3",
     "@lit/context": "^1.1.6",
     "@wdio/devtools-service": "workspace:*",
-    "@wdio/protocols": "9.27.0",
+    "@wdio/protocols": "9.27.2",
     "codemirror": "^6.0.2",
-    "lit": "^3.3.2",
+    "lit": "^3.3.3",
     "placeholder-loading": "^0.7.0",
     "pointer-tracker": "^2.5.3",
-    "preact": "^10.27.1"
+    "preact": "^10.29.2"
   },
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
   "devDependencies": {
-    "@tailwindcss/postcss": "^4.1.18",
-    "@wdio/reporter": "9.27.0",
-    "autoprefixer": "^10.4.21",
-    "postcss": "^8.5.6",
+    "@tailwindcss/postcss": "^4.3.0",
+    "@wdio/devtools-shared": "workspace:^",
+    "@wdio/reporter": "9.27.2",
+    "autoprefixer": "^10.5.0",
+    "postcss": "^8.5.15",
     "postcss-import": "^16.1.1",
-    "rollup": "^4.47.0",
-    "stylelint": "^17.6.0",
+    "rollup": "^4.61.0",
+    "stylelint": "^17.12.0",
     "stylelint-config-recommended": "^18.0.0",
     "stylelint-config-tailwindcss": "^1.0.1",
-    "tailwindcss": "~4.2.2",
-    "typescript": "6.0.2",
-    "vite": "8.0.7"
+    "tailwindcss": "~4.3.0",
+    "typescript": "6.0.3",
+    "vite": "^8.0.16"
   }
 }
diff --git a/packages/app/src/app.ts b/packages/app/src/app.ts
index 1852322f..c98fa1cf 100644
--- a/packages/app/src/app.ts
+++ b/packages/app/src/app.ts
@@ -1,7 +1,7 @@
 import './tailwind.css'
 import { css, html, nothing } from 'lit'
 import { customElement, query } from 'lit/decorators.js'
-import { TraceType, type TraceLog } from '@wdio/devtools-service/types'
+import { TraceType, type TraceLog } from '@wdio/devtools-shared'
 
 import { Element } from '@core/element'
 import { DataManagerController } from './controller/DataManager.js'
diff --git a/packages/app/src/components/browser/snapshot-styles.ts b/packages/app/src/components/browser/snapshot-styles.ts
new file mode 100644
index 00000000..d996ca18
--- /dev/null
+++ b/packages/app/src/components/browser/snapshot-styles.ts
@@ -0,0 +1,135 @@
+import { css } from 'lit'
+
+/** Component styles for `<wdio-devtools-snapshot>`. Pulled out of snapshot.ts
+ *  so the main component file stays focused on the iframe/screencast logic. */
+export const snapshotStyles = css`
+  :host {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    padding: 2rem !important;
+    align-items: center;
+    justify-content: center;
+    box-sizing: border-box !important;
+  }
+
+  section {
+    box-sizing: border-box;
+    width: calc(100% - 0px); /* host padding already applied */
+    height: calc(100% - 0px);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    background: var(--vscode-sideBar-background);
+    padding: 0.5rem;
+    gap: 0;
+  }
+
+  .frame-dot {
+    border-radius: 50%;
+    height: 12px;
+    width: 12px;
+    margin: 1em 0.25em;
+    flex-shrink: 0;
+  }
+
+  .frame-dot:nth-child(1) {
+    background-color: var(--vscode-notificationsErrorIcon-foreground, #e51400);
+  }
+
+  .frame-dot:nth-child(2) {
+    background-color: var(
+      --vscode-notificationsWarningIcon-foreground,
+      #bf8803
+    );
+  }
+
+  .frame-dot:nth-child(3) {
+    background-color: var(--vscode-ports-iconRunningProcessForeground, #369432);
+  }
+
+  iframe {
+    background-color: white;
+    position: absolute;
+    top: 0;
+    left: 0;
+    border: none;
+    border-radius: 0 0 0.5rem 0.5rem;
+  }
+
+  .screenshot-overlay {
+    position: absolute;
+    inset: 0;
+    background: #111;
+    display: flex;
+    align-items: flex-start;
+    justify-content: center;
+    border-radius: 0 0 0.5rem 0.5rem;
+    overflow: hidden;
+  }
+
+  .screenshot-overlay img {
+    max-width: 100%;
+    height: auto;
+    display: block;
+  }
+
+  .screencast-player {
+    width: 100%;
+    height: 100%;
+    object-fit: contain;
+    background: #111;
+    border-radius: 0 0 0.5rem 0.5rem;
+    display: block;
+  }
+
+  .iframe-wrapper {
+    position: relative;
+    flex: 1;
+    min-height: 0;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .view-toggle {
+    display: flex;
+    gap: 2px;
+    margin-left: 0.5rem;
+    flex-shrink: 0;
+  }
+
+  .view-toggle button {
+    padding: 2px 10px;
+    font-size: 11px;
+    font-family: inherit;
+    border: 1px solid var(--vscode-editorSuggestWidget-border, #454545);
+    background: transparent;
+    color: var(--vscode-input-foreground, #ccc);
+    cursor: pointer;
+    border-radius: 3px;
+    line-height: 20px;
+    transition:
+      background 0.1s,
+      color 0.1s;
+  }
+
+  .view-toggle button.active {
+    background: var(--vscode-button-background, #0e639c);
+    color: var(--vscode-button-foreground, #fff);
+    border-color: transparent;
+  }
+
+  .video-select {
+    font-size: 11px;
+    font-family: inherit;
+    padding: 2px 4px;
+    border: 1px solid var(--vscode-dropdown-border, #454545);
+    border-radius: 3px;
+    background: var(--vscode-dropdown-background, #3c3c3c);
+    color: var(--vscode-dropdown-foreground, #ccc);
+    cursor: pointer;
+    line-height: 20px;
+    margin-left: 4px;
+  }
+`
diff --git a/packages/app/src/components/browser/snapshot.ts b/packages/app/src/components/browser/snapshot.ts
index 6bce7775..d2a218cc 100644
--- a/packages/app/src/components/browser/snapshot.ts
+++ b/packages/app/src/components/browser/snapshot.ts
@@ -1,18 +1,19 @@
 import { Element } from '@core/element'
-import { html, css, nothing } from 'lit'
+import { html, nothing } from 'lit'
 import { consume } from '@lit/context'
+import { snapshotStyles } from './snapshot-styles.js'
 
 import { type ComponentChildren, h, render, type VNode } from 'preact'
 import { customElement, query } from 'lit/decorators.js'
 import type { SimplifiedVNode } from '../../../../script/types'
-import type { CommandLog } from '@wdio/devtools-service/types'
+import type { CommandLog } from '@wdio/devtools-shared'
 
 import {
   mutationContext,
   metadataContext,
   commandContext
 } from '../../controller/context.js'
-import type { Metadata } from '@wdio/devtools-service/types'
+import type { Metadata } from '@wdio/devtools-shared'
 
 import '~icons/mdi/world.js'
 import '../placeholder.js'
@@ -25,17 +26,31 @@ declare global {
   }
 }
 
-function transform(node: any): VNode<{}> {
+interface SerializedVNode {
+  type?: string
+  props?: {
+    children?: SerializedVNode | SerializedVNode[] | string | number
+  } & Record<string, unknown>
+}
+type TransformInput = SerializedVNode | string | number | null
+
+function transform(node: TransformInput): VNode<{}> {
   if (typeof node !== 'object' || node === null) {
     // Plain string/number text node — return as-is for Preact to render as text.
-    return node as VNode<{}>
+    return node as unknown as VNode<{}>
   }
 
   const { children, ...props } = node.props ?? {}
   /**
    * ToDo(Christian): fix way we collect data on added nodes in script
    */
-  if (!node.type && children?.type) {
+  if (
+    !node.type &&
+    children &&
+    typeof children === 'object' &&
+    !Array.isArray(children) &&
+    children.type
+  ) {
     return transform(children)
   }
 
@@ -77,146 +92,7 @@ export class DevtoolsBrowser extends Element {
   @consume({ context: commandContext, subscribe: true })
   commands: CommandLog[] = []
 
-  static styles = [
-    ...Element.styles,
-    css`
-      :host {
-        width: 100%;
-        height: 100%;
-        display: flex;
-        padding: 2rem !important;
-        align-items: center;
-        justify-content: center;
-        box-sizing: border-box !important;
-      }
-
-      section {
-        box-sizing: border-box;
-        width: calc(100% - 0px); /* host padding already applied */
-        height: calc(100% - 0px);
-        display: flex;
-        flex-direction: column;
-        overflow: hidden;
-        background: var(--vscode-sideBar-background);
-        padding: 0.5rem;
-        gap: 0;
-      }
-
-      .frame-dot {
-        border-radius: 50%;
-        height: 12px;
-        width: 12px;
-        margin: 1em 0.25em;
-        flex-shrink: 0;
-      }
-
-      .frame-dot:nth-child(1) {
-        background-color: var(
-          --vscode-notificationsErrorIcon-foreground,
-          #e51400
-        );
-      }
-
-      .frame-dot:nth-child(2) {
-        background-color: var(
-          --vscode-notificationsWarningIcon-foreground,
-          #bf8803
-        );
-      }
-
-      .frame-dot:nth-child(3) {
-        background-color: var(
-          --vscode-ports-iconRunningProcessForeground,
-          #369432
-        );
-      }
-
-      iframe {
-        background-color: white;
-        position: absolute;
-        top: 0;
-        left: 0;
-        border: none;
-        border-radius: 0 0 0.5rem 0.5rem;
-      }
-
-      .screenshot-overlay {
-        position: absolute;
-        inset: 0;
-        background: #111;
-        display: flex;
-        align-items: flex-start;
-        justify-content: center;
-        border-radius: 0 0 0.5rem 0.5rem;
-        overflow: hidden;
-      }
-
-      .screenshot-overlay img {
-        max-width: 100%;
-        height: auto;
-        display: block;
-      }
-
-      .screencast-player {
-        width: 100%;
-        height: 100%;
-        object-fit: contain;
-        background: #111;
-        border-radius: 0 0 0.5rem 0.5rem;
-        display: block;
-      }
-
-      .iframe-wrapper {
-        position: relative;
-        flex: 1;
-        min-height: 0;
-        overflow: hidden;
-        display: flex;
-        flex-direction: column;
-      }
-
-      .view-toggle {
-        display: flex;
-        gap: 2px;
-        margin-left: 0.5rem;
-        flex-shrink: 0;
-      }
-
-      .view-toggle button {
-        padding: 2px 10px;
-        font-size: 11px;
-        font-family: inherit;
-        border: 1px solid var(--vscode-editorSuggestWidget-border, #454545);
-        background: transparent;
-        color: var(--vscode-input-foreground, #ccc);
-        cursor: pointer;
-        border-radius: 3px;
-        line-height: 20px;
-        transition:
-          background 0.1s,
-          color 0.1s;
-      }
-
-      .view-toggle button.active {
-        background: var(--vscode-button-background, #0e639c);
-        color: var(--vscode-button-foreground, #fff);
-        border-color: transparent;
-      }
-
-      .video-select {
-        font-size: 11px;
-        font-family: inherit;
-        padding: 2px 4px;
-        border: 1px solid var(--vscode-dropdown-border, #454545);
-        border-radius: 3px;
-        background: var(--vscode-dropdown-background, #3c3c3c);
-        color: var(--vscode-dropdown-foreground, #ccc);
-        cursor: pointer;
-        line-height: 20px;
-        margin-left: 4px;
-      }
-    `
-  ]
+  static styles = [...Element.styles, snapshotStyles]
 
   @query('iframe')
   iframe?: HTMLIFrameElement
@@ -258,8 +134,11 @@ export class DevtoolsBrowser extends Element {
     // viewport may not be serialized yet (race between metadata message and
     // first resize event), or may arrive without dimensions — fall back to
     // sensible defaults so we never throw.
-    const viewportWidth = (metadata.viewport as any)?.width || 1280
-    const viewportHeight = (metadata.viewport as any)?.height || 800
+    const viewport = metadata.viewport as
+      | { width?: number; height?: number }
+      | undefined
+    const viewportWidth = viewport?.width || 1280
+    const viewportHeight = viewport?.height || 800
     if (!viewportWidth || !viewportHeight) {
       return
     }
@@ -559,19 +438,97 @@ export class DevtoolsBrowser extends Element {
     return null
   }
 
+  #renderViewToggle() {
+    if (this.#videos.length === 0) {
+      return nothing
+    }
+    return html`
+      <div class="view-toggle">
+        <button
+          class=${this.#viewMode === 'snapshot' ? 'active' : ''}
+          @click=${() => this.#setViewMode('snapshot')}
+        >
+          Snapshot
+        </button>
+        <button
+          class=${this.#viewMode === 'video' ? 'active' : ''}
+          @click=${() => this.#setViewMode('video')}
+        >
+          Screencast
+        </button>
+        ${this.#videos.length > 1
+          ? html`<select
+              class="video-select"
+              @change=${(e: Event) => {
+                this.#setActiveVideo(
+                  Number((e.target as HTMLSelectElement).value)
+                )
+                this.#setViewMode('video')
+              }}
+            >
+              ${this.#videos.map(
+                (_v, i) =>
+                  html`<option
+                    value=${i}
+                    ?selected=${this.#activeVideoIdx === i}
+                  >
+                    Recording ${i + 1}
+                  </option>`
+              )}
+            </select>`
+          : nothing}
+      </div>
+    `
+  }
+
+  #renderViewport(hasMutations: number | null) {
+    if (this.#viewMode === 'video' && this.#activeVideoUrl) {
+      return html`<div class="iframe-wrapper">
+        <video
+          class="screencast-player"
+          src="${this.#activeVideoUrl}"
+          controls
+        ></video>
+      </div>`
+    }
+    if (this.#screenshotData) {
+      return html`<div class="iframe-wrapper">
+        <div
+          class="screenshot-overlay"
+          style="position:relative;flex:1;min-height:0;"
+        >
+          <img src="data:image/png;base64,${this.#screenshotData}" />
+        </div>
+      </div>`
+    }
+    if (hasMutations) {
+      return html`<div class="iframe-wrapper">
+        <iframe class="origin-top-left"></iframe>
+      </div>`
+    }
+    const autoScreenshot = hasMutations ? null : this.#latestAutoScreenshot
+    if (autoScreenshot) {
+      return html`<div class="iframe-wrapper">
+        <div
+          class="screenshot-overlay"
+          style="position:relative;flex:1;min-height:0;"
+        >
+          <img src="data:image/png;base64,${autoScreenshot}" />
+        </div>
+      </div>`
+    }
+    return html`<wdio-devtools-placeholder
+      style="height: 100%"
+    ></wdio-devtools-placeholder>`
+  }
+
   render() {
-    /**
-     * render a browser state if it hasn't before
-     */
+    // Render the initial browser state lazily on first mutation arrival.
     if (this.mutations && this.mutations.length && !this.#activeUrl) {
       this.#setIframeSize()
       this.#renderBrowserState()
     }
-
     const hasMutations = this.mutations && this.mutations.length
-    const autoScreenshot = hasMutations ? null : this.#latestAutoScreenshot
-    const displayScreenshot = this.#screenshotData ?? autoScreenshot
-
     return html`
       <section
         class="w-full h-full bg-sideBarBackground rounded-lg border-2 border-panelBorder shadow-xl"
@@ -590,79 +547,9 @@ export class DevtoolsBrowser extends Element {
             ></icon-mdi-world>
             <span class="truncate">${this.#activeUrl}</span>
           </div>
-          ${this.#videos.length > 0
-            ? html`
-                <div class="view-toggle">
-                  <button
-                    class=${this.#viewMode === 'snapshot' ? 'active' : ''}
-                    @click=${() => this.#setViewMode('snapshot')}
-                  >
-                    Snapshot
-                  </button>
-                  <button
-                    class=${this.#viewMode === 'video' ? 'active' : ''}
-                    @click=${() => this.#setViewMode('video')}
-                  >
-                    Screencast
-                  </button>
-                  ${this.#videos.length > 1
-                    ? html`<select
-                        class="video-select"
-                        @change=${(e: Event) => {
-                          this.#setActiveVideo(
-                            Number((e.target as HTMLSelectElement).value)
-                          )
-                          this.#setViewMode('video')
-                        }}
-                      >
-                        ${this.#videos.map(
-                          (_v, i) =>
-                            html`<option
-                              value=${i}
-                              ?selected=${this.#activeVideoIdx === i}
-                            >
-                              Recording ${i + 1}
-                            </option>`
-                        )}
-                      </select>`
-                    : nothing}
-                </div>
-              `
-            : nothing}
+          ${this.#renderViewToggle()}
         </header>
-        ${this.#viewMode === 'video' && this.#activeVideoUrl
-          ? html`<div class="iframe-wrapper">
-              <video
-                class="screencast-player"
-                src="${this.#activeVideoUrl}"
-                controls
-              ></video>
-            </div>`
-          : this.#screenshotData
-            ? html`<div class="iframe-wrapper">
-                <div
-                  class="screenshot-overlay"
-                  style="position:relative;flex:1;min-height:0;"
-                >
-                  <img src="data:image/png;base64,${this.#screenshotData}" />
-                </div>
-              </div>`
-            : hasMutations
-              ? html`<div class="iframe-wrapper">
-                  <iframe class="origin-top-left"></iframe>
-                </div>`
-              : displayScreenshot
-                ? html`<div class="iframe-wrapper">
-                    <div
-                      class="screenshot-overlay"
-                      style="position:relative;flex:1;min-height:0;"
-                    >
-                      <img src="data:image/png;base64,${displayScreenshot}" />
-                    </div>
-                  </div>`
-                : html`<wdio-devtools-placeholder
-                    style="height: 100%"
-                  ></wdio-devtools-placeholder>`}
+        ${this.#renderViewport(hasMutations)}
       </section>
     `
   }
diff --git a/packages/app/src/components/inputs/traceLoader.ts b/packages/app/src/components/inputs/traceLoader.ts
index bdefc5b3..ada25ccf 100644
--- a/packages/app/src/components/inputs/traceLoader.ts
+++ b/packages/app/src/components/inputs/traceLoader.ts
@@ -1,7 +1,7 @@
 import { Element } from '@core/element'
 import { html } from 'lit'
 import { customElement, property } from 'lit/decorators.js'
-import type { TraceLog } from '@wdio/devtools-service/types'
+import type { TraceLog } from '@wdio/devtools-shared'
 
 @customElement('wdio-devtools-trace-loader')
 export class DevtoolsTraceLoader extends Element {
diff --git a/packages/app/src/components/sidebar/constants.ts b/packages/app/src/components/sidebar/constants.ts
index 97c7d2c0..46e6f67a 100644
--- a/packages/app/src/components/sidebar/constants.ts
+++ b/packages/app/src/components/sidebar/constants.ts
@@ -1,6 +1,7 @@
 import { TestState } from './types.js'
+import type { TestStatus } from './types.js'
 
-export const STATE_MAP: Record<string, TestState> = {
+export const STATE_MAP: Record<string, TestStatus> = {
   running: TestState.RUNNING,
   failed: TestState.FAILED,
   passed: TestState.PASSED,
diff --git a/packages/app/src/components/sidebar/explorer.ts b/packages/app/src/components/sidebar/explorer.ts
index 08b639be..3ee8a88b 100644
--- a/packages/app/src/components/sidebar/explorer.ts
+++ b/packages/app/src/components/sidebar/explorer.ts
@@ -2,26 +2,33 @@ import { Element } from '@core/element'
 import { html, css, nothing, type TemplateResult } from 'lit'
 import { customElement, property } from 'lit/decorators.js'
 import { consume } from '@lit/context'
-import type { Metadata } from '@wdio/devtools-service/types'
+import type { Metadata } from '@wdio/devtools-shared'
 import { repeat } from 'lit/directives/repeat.js'
 import { suiteContext, metadataContext } from '../../controller/context.js'
 import type {
   SuiteStatsFragment,
   TestStatsFragment
 } from '../../controller/types.js'
-import type {
-  TestEntry,
-  RunCapabilities,
-  RunnerOptions,
-  TestRunDetail
-} from './types.js'
+import type { TestEntry, TestRunDetail } from './types.js'
 import { TestState } from './types.js'
+import { getTestEntry } from './test-entry-state.js'
+import {
+  getCapabilityWarning,
+  getConfigPath,
+  getFramework,
+  getLaunchCommand,
+  getRerunCommand,
+  getRunCapabilities,
+  getRunDisabledReason,
+  isRunDisabled,
+  isRunDisabledDetail
+} from './runnerCapabilities.js'
 import {
-  DEFAULT_CAPABILITIES,
-  FRAMEWORK_CAPABILITIES,
-  STATE_MAP
-} from './constants.js'
-import { BASELINE_API } from '../workbench/compare/constants.js'
+  BASELINE_API,
+  TESTS_API,
+  type BaselinePreserveRequest,
+  type RunnerRequestBody
+} from '@wdio/devtools-shared'
 
 import '~icons/mdi/play.js'
 import '~icons/mdi/stop.js'
@@ -127,7 +134,7 @@ export class DevtoolsSidebarExplorer extends CollapseableEntry {
     )
 
     // Forward preserveBaseline so the backend knows whether to drop baselines.
-    const payload = {
+    const payload: RunnerRequestBody = {
       ...detail,
       runAll: detail.uid === '*',
       framework: this.#getFramework(),
@@ -137,12 +144,12 @@ export class DevtoolsSidebarExplorer extends CollapseableEntry {
       launchCommand: this.#getLaunchCommand(),
       preserveBaseline: detail.preserveBaseline === true
     }
-    await this.#postToBackend('/api/tests/run', payload)
+    await this.#postToBackend(TESTS_API.run, payload)
   }
 
   async #handleTestStop(event: Event) {
     event.stopPropagation()
-    await this.#postToBackend('/api/tests/stop', {})
+    await this.#postToBackend(TESTS_API.stop, {})
   }
 
   async #handlePreserveAndRerun(event: Event) {
@@ -155,13 +162,14 @@ export class DevtoolsSidebarExplorer extends CollapseableEntry {
 
     // Snapshot the current run BEFORE the rerun clears live data.
     try {
+      const body: BaselinePreserveRequest = {
+        testUid: detail.uid,
+        scope: detail.entryType
+      }
       const response = await fetch(BASELINE_API.preserve, {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-          testUid: detail.uid,
-          scope: detail.entryType
-        })
+        body: JSON.stringify(body)
       })
       if (!response.ok) {
         const errorText = await response.text()
@@ -191,7 +199,10 @@ export class DevtoolsSidebarExplorer extends CollapseableEntry {
     )
   }
 
-  async #postToBackend(path: string, body: Record<string, unknown>) {
+  async #postToBackend(
+    path: typeof TESTS_API.run | typeof TESTS_API.stop,
+    body: RunnerRequestBody | Record<string, never>
+  ) {
     try {
       const response = await fetch(path, {
         method: 'POST',
@@ -255,7 +266,7 @@ export class DevtoolsSidebarExplorer extends CollapseableEntry {
       })
     )
 
-    void this.#postToBackend('/api/tests/run', {
+    const payload: RunnerRequestBody = {
       uid: '*',
       entryType: 'suite',
       runAll: true,
@@ -263,89 +274,44 @@ export class DevtoolsSidebarExplorer extends CollapseableEntry {
       configFile: this.#getConfigPath(),
       rerunCommand: this.#getRerunCommand(),
       launchCommand: this.#getLaunchCommand()
-    })
+    }
+    void this.#postToBackend(TESTS_API.run, payload)
   }
 
   #stopActiveRun() {
-    void this.#postToBackend('/api/tests/stop', {
-      uid: '*'
-    })
-  }
-
-  #getFramework(): string | undefined {
-    return this.#getRunnerOptions()?.framework
+    // Backend ignores the body for /api/tests/stop — sending {} keeps the
+    // typed helper happy without changing behavior.
+    void this.#postToBackend(TESTS_API.stop, {})
   }
 
-  #getRunnerOptions(): RunnerOptions | undefined {
-    return this.metadata?.options as RunnerOptions | undefined
+  #getFramework() {
+    return getFramework(this.metadata)
   }
-
-  #getRunCapabilities(): RunCapabilities {
-    const options = this.#getRunnerOptions()
-    if (options?.runCapabilities) {
-      return {
-        ...DEFAULT_CAPABILITIES,
-        ...options.runCapabilities
-      }
-    }
-    const framework = options?.framework?.toLowerCase() ?? ''
-    return FRAMEWORK_CAPABILITIES[framework] || DEFAULT_CAPABILITIES
+  #getRunCapabilities() {
+    return getRunCapabilities(this.metadata)
   }
-
   #isRunDisabled(entry: TestEntry) {
-    const caps = this.#getRunCapabilities()
-    if (entry.type === 'test' && !caps.canRunTests) {
-      return true
-    }
-    if (entry.type === 'suite' && !caps.canRunSuites) {
-      return true
-    }
-    return false
+    return isRunDisabled(this.metadata, entry)
   }
-
   #isRunDisabledDetail(detail: TestRunDetail) {
-    const caps = this.#getRunCapabilities()
-    if (detail.entryType === 'test' && !caps.canRunTests) {
-      return true
-    }
-    if (detail.entryType === 'suite' && !caps.canRunSuites) {
-      return true
-    }
-    return false
+    return isRunDisabledDetail(this.metadata, detail)
   }
-
   #surfaceCapabilityWarning(detail: TestRunDetail) {
-    const message =
-      detail.entryType === 'test'
-        ? 'Single-test execution is not supported by this framework.'
-        : 'Suite execution is disabled by this framework.'
     window.dispatchEvent(
-      new CustomEvent('app-logs', {
-        detail: message
-      })
+      new CustomEvent('app-logs', { detail: getCapabilityWarning(detail) })
     )
   }
-
   #getRunDisabledReason(entry: TestEntry) {
-    if (!this.#isRunDisabled(entry)) {
-      return undefined
-    }
-    return entry.type === 'test'
-      ? 'Single-test execution is not supported by this framework.'
-      : 'Suite execution is not supported by this framework.'
+    return getRunDisabledReason(this.metadata, entry)
   }
-
-  #getConfigPath(): string | undefined {
-    const options = this.#getRunnerOptions()
-    return options?.configFilePath || options?.configFile
+  #getConfigPath() {
+    return getConfigPath(this.metadata)
   }
-
-  #getRerunCommand(): string | undefined {
-    return this.#getRunnerOptions()?.rerunCommand
+  #getRerunCommand() {
+    return getRerunCommand(this.metadata)
   }
-
-  #getLaunchCommand(): string | undefined {
-    return this.#getRunnerOptions()?.launchCommand
+  #getLaunchCommand() {
+    return getLaunchCommand(this.metadata)
   }
 
   #renderEntry(entry: TestEntry): TemplateResult {
@@ -403,243 +369,65 @@ export class DevtoolsSidebarExplorer extends CollapseableEntry {
     )
   }
 
-  #isRunning(entry: TestStatsFragment | SuiteStatsFragment): boolean {
-    if ('tests' in entry) {
-      // Fastest path: any explicitly running descendant
-      if (
-        (entry.tests ?? []).some((t) => t.state === 'running') ||
-        (entry.suites ?? []).some((s) => this.#isRunning(s))
-      ) {
-        return true
-      }
-
-      const hasPendingTests = (entry.tests ?? []).some(
-        (t) => t.state === 'pending'
-      )
-      const hasPendingSuites = (entry.suites ?? []).some((s) =>
-        this.#hasPending(s)
-      )
-      const suiteState = entry.state
-
-      // If the suite was explicitly marked 'running' (e.g. by markTestAsRunning)
-      // and still has pending children, it's actively executing.
-      if (suiteState === 'running' && (hasPendingTests || hasPendingSuites)) {
-        return true
-      }
-
-      // Mixed terminal + pending children = run is in progress regardless of
-      // explicit suite state (handles Nightwatch Cucumber where the feature
-      // suite state may be undefined in the JSON payload).
-      const allDescendants = [...(entry.tests ?? []), ...(entry.suites ?? [])]
-      const hasSomeTerminal = allDescendants.some(
-        (t) =>
-          t.state === 'passed' || t.state === 'failed' || t.state === 'skipped'
-      )
-      if ((hasPendingTests || hasPendingSuites) && hasSomeTerminal) {
-        return true
-      }
-
-      return false
-    }
-    // For individual tests rely on explicit state only.
-    return entry.state === 'running'
-  }
-
-  #hasPending(entry: TestStatsFragment | SuiteStatsFragment): boolean {
-    if ('tests' in entry) {
-      if (entry.state === 'pending') {
-        return true
-      }
-      if ((entry.tests ?? []).some((t) => t.state === 'pending')) {
-        return true
-      }
-      if ((entry.suites ?? []).some((s) => this.#hasPending(s))) {
-        return true
-      }
-      return false
-    }
-    return entry.state === 'pending'
-  }
-
-  #hasFailed(entry: TestStatsFragment | SuiteStatsFragment): boolean {
-    if ('tests' in entry) {
-      // Check if any immediate test failed
-      if ((entry.tests ?? []).find((t) => t.state === 'failed')) {
-        return true
-      }
-      // Check if any nested suite has failures
-      if ((entry.suites ?? []).some((s) => this.#hasFailed(s))) {
-        return true
-      }
-      return false
-    }
-    // For individual tests
-    return entry.state === 'failed'
-  }
-
-  #computeEntryState(
-    entry: TestStatsFragment | SuiteStatsFragment
-  ): TestState | 'pending' {
-    // For suites, check running state from children FIRST — this ensures that
-    // a rerun (which clears end times) shows the spinner immediately, even if
-    // the suite still has a cached 'passed'/'failed' state from the previous run.
-    if ('tests' in entry && this.#isRunning(entry)) {
-      return TestState.RUNNING
-    }
-
-    const state = entry.state
-
-    // A suite with an explicit 'pending' state is always in-progress from the
-    // UI's perspective — the backend uses 'pending' to signal a new run is
-    // starting. Skip the children check: stale terminal children from the
-    // previous run must not cause the suite to appear as passed.
-    if ('tests' in entry && state === 'pending') {
-      return TestState.RUNNING
-    }
-
-    // For suites with no explicit terminal state, derive from children.
-    // A suite with state=undefined or state=running that has no terminal
-    // children yet is still in-progress — don't show PASSED prematurely.
-    if ('tests' in entry && (state === null || state === 'running')) {
-      const allDescendants = [...(entry.tests ?? []), ...(entry.suites ?? [])]
-      if (allDescendants.length > 0) {
-        const allTerminal = allDescendants.every(
-          (t) =>
-            t.state === 'passed' ||
-            t.state === 'failed' ||
-            t.state === 'skipped'
-        )
-        if (!allTerminal) {
-          // Still has non-terminal children — treat as running/loading
-          return TestState.RUNNING
-        }
-      }
-    }
-
-    // Check explicit terminal state
-    const mappedState = state ? STATE_MAP[state] : undefined
-    if (mappedState) {
-      return mappedState
-    }
-
-    // For suites, compute state from children
-    if ('tests' in entry) {
-      if (this.#hasFailed(entry)) {
-        return TestState.FAILED
-      }
-      return TestState.PASSED
-    }
-
-    // For individual leaf tests: pending = spinner (run is in progress),
-    // not circle (which implies "never run").
-    if (state === 'pending') {
-      return TestState.RUNNING
-    }
-
-    return entry.end ? TestState.PASSED : 'pending'
+  #getTestEntry(entry: TestStatsFragment | SuiteStatsFragment): TestEntry {
+    return getTestEntry(entry, this.#filterEntry.bind(this))
   }
 
-  #getTestEntry(entry: TestStatsFragment | SuiteStatsFragment): TestEntry {
-    if ('tests' in entry) {
-      const entries = [...(entry.tests ?? []), ...(entry.suites ?? [])]
-      // A suite whose children are themselves suites is a feature/file-level
-      // container (Cucumber feature or test file). Tag it as 'feature' so the
-      // backend runner can distinguish it from a scenario/spec-level suite and
-      // avoid applying a --name filter that would match no scenarios.
-      const hasChildSuites = entry.suites && entry.suites.length > 0
-      const derivedType = hasChildSuites ? 'feature' : entry.type || 'suite'
-      return {
-        uid: entry.uid,
-        label: entry.title ?? '',
-        type: 'suite',
-        state: this.#computeEntryState(entry),
-        callSource: entry.callSource,
-        specFile: entry.file,
-        fullTitle: entry.title ?? '',
-        featureFile: entry.featureFile,
-        featureLine: entry.featureLine,
-        suiteType: derivedType,
-        children: Object.values(entries)
-          .map(this.#getTestEntry.bind(this))
-          .filter(this.#filterEntry.bind(this))
-      }
-    }
-    return {
-      uid: entry.uid,
-      label: entry.title ?? '',
-      type: 'test',
-      state: this.#computeEntryState(entry),
-      callSource: entry.callSource,
-      specFile: entry.file,
-      fullTitle: entry.fullTitle || entry.title,
-      featureFile: entry.featureFile,
-      featureLine: entry.featureLine,
-      children: []
-    }
+  #renderHeaderToolbar() {
+    const canRunAll = this.#getRunCapabilities().canRunAll
+    const runBtnCls = canRunAll
+      ? 'hover:bg-toolbarHoverBackground'
+      : 'opacity-30 cursor-not-allowed'
+    const iconCls = (color: string) => (canRunAll ? `group-hover:${color}` : '')
+    return html`
+      <nav class="flex ml-auto">
+        <button
+          class="p-1 rounded text-sm group ${runBtnCls}"
+          ?disabled=${!canRunAll}
+          @click="${() => this.#runAllSuites()}"
+        >
+          <icon-mdi-play class="${iconCls('text-chartsGreen')}"></icon-mdi-play>
+        </button>
+        <button
+          class="p-1 rounded text-sm group ${runBtnCls}"
+          ?disabled=${!canRunAll}
+          @click="${() => this.#stopActiveRun()}"
+        >
+          <icon-mdi-stop class="${iconCls('text-chartsRed')}"></icon-mdi-stop>
+        </button>
+        <button
+          class="p-1 rounded hover:bg-toolbarHoverBackground text-sm group"
+        >
+          <icon-mdi-eye class="group-hover:text-chartsYellow"></icon-mdi-eye>
+        </button>
+        <button
+          class="p-1 rounded hover:bg-toolbarHoverBackground text-sm group"
+        >
+          ${this.renderCollapseOrExpandIcon('group-hover:text-chartsBlue')}
+        </button>
+      </nav>
+    `
   }
 
   render() {
     if (!this.suites) {
       return
     }
-
     const rootSuites = this.suites
       .flatMap((s) => Object.values(s))
       .filter((suite) => !suite.parent)
-
     const uniqueSuites = Array.from(
       new Map(rootSuites.map((suite) => [suite.uid, suite])).values()
     )
-
     const suites = uniqueSuites
       .map(this.#getTestEntry.bind(this))
       .filter(this.#filterEntry.bind(this))
-
     return html`
       <header class="pl-4 py-2 flex shadow-md pr-2">
         <h3 class="flex content-center flex-wrap uppercase font-bold text-sm">
           Tests
         </h3>
-        <nav class="flex ml-auto">
-          <button
-            class="p-1 rounded text-sm group ${this.#getRunCapabilities()
-              .canRunAll
-              ? 'hover:bg-toolbarHoverBackground'
-              : 'opacity-30 cursor-not-allowed'}"
-            ?disabled=${!this.#getRunCapabilities().canRunAll}
-            @click="${() => this.#runAllSuites()}"
-          >
-            <icon-mdi-play
-              class="${this.#getRunCapabilities().canRunAll
-                ? 'group-hover:text-chartsGreen'
-                : ''}"
-            ></icon-mdi-play>
-          </button>
-          <button
-            class="p-1 rounded text-sm group ${this.#getRunCapabilities()
-              .canRunAll
-              ? 'hover:bg-toolbarHoverBackground'
-              : 'opacity-30 cursor-not-allowed'}"
-            ?disabled=${!this.#getRunCapabilities().canRunAll}
-            @click="${() => this.#stopActiveRun()}"
-          >
-            <icon-mdi-stop
-              class="${this.#getRunCapabilities().canRunAll
-                ? 'group-hover:text-chartsRed'
-                : ''}"
-            ></icon-mdi-stop>
-          </button>
-          <button
-            class="p-1 rounded hover:bg-toolbarHoverBackground text-sm group"
-          >
-            <icon-mdi-eye class="group-hover:text-chartsYellow"></icon-mdi-eye>
-          </button>
-          <button
-            class="p-1 rounded hover:bg-toolbarHoverBackground text-sm group"
-          >
-            ${this.renderCollapseOrExpandIcon('group-hover:text-chartsBlue')}
-          </button>
-        </nav>
+        ${this.#renderHeaderToolbar()}
       </header>
       <wdio-test-suite>
         ${suites.length
@@ -666,5 +454,5 @@ function getSearchableLabel(entry: TestEntry): string[] {
   if (entry.children.length === 0) {
     return [entry.label]
   }
-  return entry.children.map(getSearchableLabel) as any as string[]
+  return entry.children.flatMap(getSearchableLabel)
 }
diff --git a/packages/app/src/components/sidebar/filter.ts b/packages/app/src/components/sidebar/filter.ts
index db607c23..7ee639ff 100644
--- a/packages/app/src/components/sidebar/filter.ts
+++ b/packages/app/src/components/sidebar/filter.ts
@@ -36,13 +36,14 @@ export class DevtoolsSidebarFilter extends Element {
   @query('input[name="filter"]')
   queryInput?: HTMLInputElement
 
-  #updateState(change: any) {
-    if (!change.target) {
+  #updateState(change: Event) {
+    const target = change.target as HTMLInputElement | null
+    if (!target) {
       return
     }
-    this.#filterState = change.target.checked
-      ? this.#filterState + Number(change.target.value)
-      : this.#filterState - Number(change.target.value)
+    this.#filterState = target.checked
+      ? this.#filterState + Number(target.value)
+      : this.#filterState - Number(target.value)
     this.requestUpdate()
     this.#emitState()
   }
@@ -99,6 +100,15 @@ export class DevtoolsSidebarFilter extends Element {
     return this.#filterQuery
   }
 
+  #renderStateCheckbox(state: FilterState, label: string, id: string) {
+    return html`
+      <li>
+        <input type="checkbox" value="${state}" name="${id}" id="${id}" />
+        <label for="${id}">${label}</label>
+      </li>
+    `
+  }
+
   render() {
     return html`
       <button
@@ -128,33 +138,13 @@ export class DevtoolsSidebarFilter extends Element {
           class="${this.#isStateFilterOpen ? 'show' : 'hidden'}"
         >
           <ul class="block w-full">
-            <li>
-              <input
-                type="checkbox"
-                value="${FilterState.PASSED}"
-                name="passed"
-                id="passed"
-              />
-              <label for="passed">Passed</label>
-            </li>
-            <li>
-              <input
-                type="checkbox"
-                value="${FilterState.FAILED}"
-                name="failed"
-                id="failed"
-              />
-              <label for="failed">Failed</label>
-            </li>
-            <li>
-              <input
-                type="checkbox"
-                value="${FilterState.SKIPPED}"
-                name="skipped"
-                id="skipped"
-              />
-              <label for="skipped">Skipped</label>
-            </li>
+            ${this.#renderStateCheckbox(FilterState.PASSED, 'Passed', 'passed')}
+            ${this.#renderStateCheckbox(FilterState.FAILED, 'Failed', 'failed')}
+            ${this.#renderStateCheckbox(
+              FilterState.SKIPPED,
+              'Skipped',
+              'skipped'
+            )}
           </ul>
         </form>
       </div>
diff --git a/packages/app/src/components/sidebar/runnerCapabilities.ts b/packages/app/src/components/sidebar/runnerCapabilities.ts
new file mode 100644
index 00000000..3c66b64d
--- /dev/null
+++ b/packages/app/src/components/sidebar/runnerCapabilities.ts
@@ -0,0 +1,103 @@
+/**
+ * Pure derivations from the runner metadata. Used by the sidebar explorer
+ * (and tests) to decide whether the Run/Rerun buttons should be enabled.
+ * Extracted from explorer.ts so the Lit component stays under the
+ * file-size cap.
+ */
+
+import type { Metadata } from '@wdio/devtools-shared'
+import type {
+  RunCapabilities,
+  RunnerOptions,
+  TestEntry,
+  TestRunDetail
+} from './types.js'
+import { DEFAULT_CAPABILITIES, FRAMEWORK_CAPABILITIES } from './constants.js'
+
+export function getRunnerOptions(
+  metadata: Metadata | undefined
+): RunnerOptions | undefined {
+  return metadata?.options as RunnerOptions | undefined
+}
+
+export function getFramework(
+  metadata: Metadata | undefined
+): string | undefined {
+  return getRunnerOptions(metadata)?.framework
+}
+
+export function getRunCapabilities(
+  metadata: Metadata | undefined
+): RunCapabilities {
+  const options = getRunnerOptions(metadata)
+  if (options?.runCapabilities) {
+    return { ...DEFAULT_CAPABILITIES, ...options.runCapabilities }
+  }
+  const framework = options?.framework?.toLowerCase() ?? ''
+  return FRAMEWORK_CAPABILITIES[framework] || DEFAULT_CAPABILITIES
+}
+
+export function isRunDisabled(
+  metadata: Metadata | undefined,
+  entry: TestEntry
+): boolean {
+  const caps = getRunCapabilities(metadata)
+  if (entry.type === 'test' && !caps.canRunTests) {
+    return true
+  }
+  if (entry.type === 'suite' && !caps.canRunSuites) {
+    return true
+  }
+  return false
+}
+
+export function isRunDisabledDetail(
+  metadata: Metadata | undefined,
+  detail: TestRunDetail
+): boolean {
+  const caps = getRunCapabilities(metadata)
+  if (detail.entryType === 'test' && !caps.canRunTests) {
+    return true
+  }
+  if (detail.entryType === 'suite' && !caps.canRunSuites) {
+    return true
+  }
+  return false
+}
+
+export function getRunDisabledReason(
+  metadata: Metadata | undefined,
+  entry: TestEntry
+): string | undefined {
+  if (!isRunDisabled(metadata, entry)) {
+    return undefined
+  }
+  return entry.type === 'test'
+    ? 'Single-test execution is not supported by this framework.'
+    : 'Suite execution is not supported by this framework.'
+}
+
+export function getCapabilityWarning(detail: TestRunDetail): string {
+  return detail.entryType === 'test'
+    ? 'Single-test execution is not supported by this framework.'
+    : 'Suite execution is disabled by this framework.'
+}
+
+export function getConfigPath(
+  metadata: Metadata | undefined
+): string | undefined {
+  const options = getRunnerOptions(metadata)
+  return options?.configFilePath || options?.configFile
+}
+
+export function getRerunCommand(
+  metadata: Metadata | undefined
+): string | undefined {
+  return getRunnerOptions(metadata)?.rerunCommand
+}
+
+export function getLaunchCommand(
+  metadata: Metadata | undefined
+): string | undefined {
+  return getRunnerOptions(metadata)?.launchCommand
+}
diff --git a/packages/app/src/components/sidebar/test-entry-state.ts b/packages/app/src/components/sidebar/test-entry-state.ts
new file mode 100644
index 00000000..af7b6112
--- /dev/null
+++ b/packages/app/src/components/sidebar/test-entry-state.ts
@@ -0,0 +1,174 @@
+import type {
+  SuiteStatsFragment,
+  TestStatsFragment
+} from '../../controller/types.js'
+import { STATE_MAP } from './constants.js'
+import { TestState } from './types.js'
+import type { TestEntry, TestStatus } from './types.js'
+
+type Fragment = TestStatsFragment | SuiteStatsFragment
+
+/** A suite is "running" when there are pending children + at least one
+ *  terminal child, or when the suite itself is marked running with pending
+ *  children. Tests fall through to their explicit state. */
+export function isRunning(entry: Fragment): boolean {
+  if ('tests' in entry) {
+    if (
+      (entry.tests ?? []).some((t) => t.state === 'running') ||
+      (entry.suites ?? []).some((s) => isRunning(s))
+    ) {
+      return true
+    }
+
+    const hasPendingTests = (entry.tests ?? []).some(
+      (t) => t.state === 'pending'
+    )
+    const hasPendingSuites = (entry.suites ?? []).some((s) => hasPending(s))
+    const suiteState = entry.state
+
+    if (suiteState === 'running' && (hasPendingTests || hasPendingSuites)) {
+      return true
+    }
+
+    // Mixed terminal + pending = run in progress regardless of explicit suite
+    // state (Nightwatch-Cucumber leaves feature.state undefined in the JSON).
+    const allDescendants = [...(entry.tests ?? []), ...(entry.suites ?? [])]
+    const hasSomeTerminal = allDescendants.some(
+      (t) =>
+        t.state === 'passed' || t.state === 'failed' || t.state === 'skipped'
+    )
+    if ((hasPendingTests || hasPendingSuites) && hasSomeTerminal) {
+      return true
+    }
+    return false
+  }
+  return entry.state === 'running'
+}
+
+export function hasPending(entry: Fragment): boolean {
+  if ('tests' in entry) {
+    if (entry.state === 'pending') {
+      return true
+    }
+    if ((entry.tests ?? []).some((t) => t.state === 'pending')) {
+      return true
+    }
+    if ((entry.suites ?? []).some((s) => hasPending(s))) {
+      return true
+    }
+    return false
+  }
+  return entry.state === 'pending'
+}
+
+export function hasFailed(entry: Fragment): boolean {
+  if ('tests' in entry) {
+    if ((entry.tests ?? []).find((t) => t.state === 'failed')) {
+      return true
+    }
+    if ((entry.suites ?? []).some((s) => hasFailed(s))) {
+      return true
+    }
+    return false
+  }
+  return entry.state === 'failed'
+}
+
+export function computeEntryState(entry: Fragment): TestStatus {
+  // Suites: check running from children FIRST. A rerun clears end times but
+  // not stale 'passed'/'failed' state — show the spinner before falling
+  // through to the cached terminal value.
+  if ('tests' in entry && isRunning(entry)) {
+    return TestState.RUNNING
+  }
+
+  const state = entry.state
+
+  // 'pending' on a suite = backend signaling a new run starting. Skip
+  // children check; stale terminal children must not flip suite to passed.
+  if ('tests' in entry && state === 'pending') {
+    return TestState.RUNNING
+  }
+
+  // Suite with no explicit terminal state — derive from children. If any
+  // child is non-terminal, the run is still in progress.
+  if ('tests' in entry && (state === null || state === 'running')) {
+    const allDescendants = [...(entry.tests ?? []), ...(entry.suites ?? [])]
+    if (allDescendants.length > 0) {
+      const allTerminal = allDescendants.every(
+        (t) =>
+          t.state === 'passed' || t.state === 'failed' || t.state === 'skipped'
+      )
+      if (!allTerminal) {
+        return TestState.RUNNING
+      }
+    }
+  }
+
+  const mappedState = state ? STATE_MAP[state] : undefined
+  if (mappedState) {
+    return mappedState
+  }
+
+  if ('tests' in entry) {
+    if (hasFailed(entry)) {
+      return TestState.FAILED
+    }
+    return TestState.PASSED
+  }
+
+  // Leaf test: pending → spinner (run is in progress), NOT circle (which
+  // would imply "never run").
+  if (state === 'pending') {
+    return TestState.RUNNING
+  }
+  return entry.end ? TestState.PASSED : 'pending'
+}
+
+/**
+ * Map a raw suite/test fragment to the sidebar's `TestEntry` shape.
+ * `filterEntry` is passed in because it depends on component-level filter
+ * state — the sidebar holds the active filter and decides which children
+ * stay visible.
+ */
+export function getTestEntry(
+  entry: Fragment,
+  filterEntry: (entry: TestEntry) => boolean
+): TestEntry {
+  if ('tests' in entry) {
+    const entries = [...(entry.tests ?? []), ...(entry.suites ?? [])]
+    // A suite whose children are themselves suites is a feature/file-level
+    // container (Cucumber feature or test file). Tag it as 'feature' so the
+    // backend runner can distinguish it from a scenario/spec-level suite and
+    // avoid applying a --name filter that would match no scenarios.
+    const hasChildSuites = entry.suites && entry.suites.length > 0
+    const derivedType = hasChildSuites ? 'feature' : entry.type || 'suite'
+    return {
+      uid: entry.uid,
+      label: entry.title ?? '',
+      type: 'suite',
+      state: computeEntryState(entry),
+      callSource: entry.callSource,
+      specFile: entry.file,
+      fullTitle: entry.title ?? '',
+      featureFile: entry.featureFile,
+      featureLine: entry.featureLine,
+      suiteType: derivedType,
+      children: Object.values(entries)
+        .map((e) => getTestEntry(e, filterEntry))
+        .filter(filterEntry)
+    }
+  }
+  return {
+    uid: entry.uid,
+    label: entry.title ?? '',
+    type: 'test',
+    state: computeEntryState(entry),
+    callSource: entry.callSource,
+    specFile: entry.file,
+    fullTitle: entry.fullTitle || entry.title,
+    featureFile: entry.featureFile,
+    featureLine: entry.featureLine,
+    children: []
+  }
+}
diff --git a/packages/app/src/components/sidebar/test-suite.ts b/packages/app/src/components/sidebar/test-suite.ts
index ed237955..576d6969 100644
--- a/packages/app/src/components/sidebar/test-suite.ts
+++ b/packages/app/src/components/sidebar/test-suite.ts
@@ -3,7 +3,7 @@ import { html, css, nothing } from 'lit'
 import { customElement, property } from 'lit/decorators.js'
 
 import { CollapseableEntry } from './collapseableEntry.js'
-import type { TestRunDetail } from './types.js'
+import type { TestRunDetail, TestStatus } from './types.js'
 import { TestState } from './types.js'
 
 import '~icons/mdi/chevron-right.js'
@@ -49,7 +49,7 @@ export class ExplorerTestEntry extends CollapseableEntry {
   uid?: string
 
   @property({ type: String })
-  state?: TestState
+  state?: TestStatus
 
   @property({ type: String, attribute: 'call-source' })
   callSource?: string
@@ -234,14 +234,97 @@ export class ExplorerTestEntry extends CollapseableEntry {
     ></icon-mdi-checkbox-blank-circle-outline>`
   }
 
-  render() {
-    const hasNoChildren = !this.hasChildren
-    const isCollapsed = this.isCollapsed === 'true'
+  #renderStopButton() {
+    return html`
+      <button
+        class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group/button"
+        title="Stop run"
+        @click="${(event: Event) => this.#stopEntry(event)}"
+      >
+        <icon-mdi-stop
+          class="group-hover/button:text-chartsRed"
+        ></icon-mdi-stop>
+      </button>
+    `
+  }
+
+  #renderRunButton() {
     const runTooltip = this.runDisabled
       ? this.runDisabledReason ||
         'Single-step execution is controlled by its scenario.'
       : 'Run this entry'
+    return html`
+      <button
+        class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group/button ${this
+          .runDisabled
+          ? 'opacity-60 cursor-not-allowed hover:bg-transparent'
+          : ''}"
+        title="${runTooltip}"
+        ?disabled=${this.runDisabled}
+        @click="${(event: Event) => this.#runEntry(event)}"
+      >
+        <icon-mdi-play
+          class="${this.runDisabled
+            ? ''
+            : 'group-hover/button:text-chartsGreen'}"
+        ></icon-mdi-play>
+      </button>
+    `
+  }
 
+  #renderRunStopButtons() {
+    if (this.isRunning) {
+      return this.runDisabled ? nothing : this.#renderStopButton()
+    }
+    return html`
+      ${this.#renderRunButton()}
+      ${this.hasFailed && !this.runDisabled
+        ? html`
+            <button
+              class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group/button"
+              title="Preserve current run and rerun for comparison"
+              @click="${(event: Event) => this.#preserveAndRerun(event)}"
+            >
+              <icon-mdi-bug-play
+                class="group-hover/button:text-chartsBlue"
+              ></icon-mdi-bug-play>
+            </button>
+          `
+        : nothing}
+    `
+  }
+
+  #renderToolbar(hasNoChildren: boolean) {
+    return html`
+      <nav
+        class="flex-none ml-auto mr-1 transition-opacity opacity-0 group-hover/sidebar:opacity-100"
+      >
+        ${this.#renderRunStopButtons()}
+        <button
+          class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group"
+          @click="${() => this.#viewSource()}"
+        >
+          <icon-mdi-eye class="group-hover:text-chartsYellow"></icon-mdi-eye>
+        </button>
+        ${!hasNoChildren
+          ? html`
+              <button
+                class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group"
+                @click="${() => this.#toggleEntry()}"
+              >
+                ${this.renderCollapseOrExpandIcon(
+                  'group-hover:text-chartsBlue'
+                )}
+              </button>
+            `
+          : nothing}
+      </nav>
+    `
+  }
+
+  render() {
+    const hasNoChildren = !this.hasChildren
+    const isCollapsed = this.isCollapsed === 'true'
     return html`
       <section class="block mt-2 text-sm flex w-full group/sidebar">
         <button
@@ -262,73 +345,7 @@ export class ExplorerTestEntry extends CollapseableEntry {
           ${this.testStateIcon}
           <slot name="label" class="mx-2 mt-1 block flex-initial shrink"></slot>
         </span>
-        <nav
-          class="flex-none ml-auto mr-1 transition-opacity opacity-0 group-hover/sidebar:opacity-100"
-        >
-          ${!this.isRunning
-            ? html`
-                <button
-                  class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group/button ${this
-                    .runDisabled
-                    ? 'opacity-60 cursor-not-allowed hover:bg-transparent'
-                    : ''}"
-                  title="${runTooltip}"
-                  ?disabled=${this.runDisabled}
-                  @click="${(event: Event) => this.#runEntry(event)}"
-                >
-                  <icon-mdi-play
-                    class="${this.runDisabled
-                      ? ''
-                      : 'group-hover/button:text-chartsGreen'}"
-                  ></icon-mdi-play>
-                </button>
-                ${this.hasFailed && !this.runDisabled
-                  ? html`
-                      <button
-                        class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group/button"
-                        title="Preserve current run and rerun for comparison"
-                        @click="${(event: Event) =>
-                          this.#preserveAndRerun(event)}"
-                      >
-                        <icon-mdi-bug-play
-                          class="group-hover/button:text-chartsBlue"
-                        ></icon-mdi-bug-play>
-                      </button>
-                    `
-                  : nothing}
-              `
-            : !this.runDisabled
-              ? html`
-                  <button
-                    class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group/button"
-                    title="Stop run"
-                    @click="${(event: Event) => this.#stopEntry(event)}"
-                  >
-                    <icon-mdi-stop
-                      class="group-hover/button:text-chartsRed"
-                    ></icon-mdi-stop>
-                  </button>
-                `
-              : nothing}
-          <button
-            class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group"
-            @click="${() => this.#viewSource()}"
-          >
-            <icon-mdi-eye class="group-hover:text-chartsYellow"></icon-mdi-eye>
-          </button>
-          ${!hasNoChildren
-            ? html`
-                <button
-                  class="p-1 rounded hover:bg-toolbarHoverBackground my-1 group"
-                  @click="${() => this.#toggleEntry()}"
-                >
-                  ${this.renderCollapseOrExpandIcon(
-                    'group-hover:text-chartsBlue'
-                  )}
-                </button>
-              `
-            : nothing}
-        </nav>
+        ${this.#renderToolbar(hasNoChildren)}
       </section>
       <section class="block ml-4 ${!isCollapsed ? '' : 'hidden'}">
         <slot name="children"></slot>
diff --git a/packages/app/src/components/sidebar/types.ts b/packages/app/src/components/sidebar/types.ts
index b1168590..cf72e77d 100644
--- a/packages/app/src/components/sidebar/types.ts
+++ b/packages/app/src/components/sidebar/types.ts
@@ -41,9 +41,19 @@ export interface TestRunDetail {
   preserveBaseline?: boolean
 }
 
-export enum TestState {
-  PASSED = 'passed',
-  FAILED = 'failed',
-  RUNNING = 'running',
-  SKIPPED = 'skipped'
-}
+import type { TestStatus } from '@wdio/devtools-shared'
+
+/**
+ * Enum-style accessor for the canonical TestStatus values. Use the
+ * shared TestStatus type for type annotations; this object is for
+ * readable value comparisons (`state === TestState.PASSED`).
+ */
+export const TestState = {
+  PASSED: 'passed',
+  FAILED: 'failed',
+  RUNNING: 'running',
+  SKIPPED: 'skipped',
+  PENDING: 'pending'
+} as const satisfies Record<string, TestStatus>
+
+export type { TestStatus } from '@wdio/devtools-shared'
diff --git a/packages/app/src/components/tabs.ts b/packages/app/src/components/tabs.ts
index 90d94204..2762a327 100644
--- a/packages/app/src/components/tabs.ts
+++ b/packages/app/src/components/tabs.ts
@@ -31,7 +31,7 @@ export class DevtoolsTabs extends Element {
     const tabElement = this.tabs.find(
       (el) => el.getAttribute('label') === tabId
     )
-    const badge = (tabElement as any)?.badge
+    const badge = (tabElement as { badge?: number } | undefined)?.badge
     const showBadge = badge && badge > 0
 
     return html`
diff --git a/packages/app/src/components/workbench.ts b/packages/app/src/components/workbench.ts
index 7740083b..9159f82c 100644
--- a/packages/app/src/components/workbench.ts
+++ b/packages/app/src/components/workbench.ts
@@ -9,7 +9,7 @@ import {
   networkRequestContext,
   baselineContext
 } from '../controller/context.js'
-import type { PreservedAttempt } from '@wdio/devtools-service/types'
+import type { PreservedAttempt } from '@wdio/devtools-shared'
 
 import '~icons/mdi/arrow-collapse-down.js'
 import '~icons/mdi/arrow-collapse-up.js'
@@ -120,81 +120,93 @@ export class DevtoolsWorkbench extends Element {
   @query('section[data-horizontal-resizer-window]')
   horizontalResizerWindow?: HTMLElement
 
-  render() {
-    // When collapsed keep previous full behavior; when expanded no fixed height class
-    const heightWorkbench = this.#toolbarCollapsed ? 'h-full flex-1' : ''
-
-    const styleWorkbench = this.#toolbarCollapsed
-      ? ''
-      : (() => {
-          const m = this.#dragVertical.getPosition().match(/(\d+(?:\.\d+)?)px/)
-          const raw = m ? parseFloat(m[1]) : window.innerHeight * 0.7
-          const capped = Math.min(raw, window.innerHeight * 0.7)
-          const paneHeight = Math.max(MIN_WORKBENCH_HEIGHT, capped)
-          return `flex:0 0 ${paneHeight}px; height:${paneHeight}px; max-height:70vh; min-height:0;`
-        })()
+  #computeWorkbenchPaneStyle(): string {
+    if (this.#toolbarCollapsed) {
+      return ''
+    }
+    const m = this.#dragVertical.getPosition().match(/(\d+(?:\.\d+)?)px/)
+    const raw = m ? parseFloat(m[1]) : window.innerHeight * 0.7
+    const capped = Math.min(raw, window.innerHeight * 0.7)
+    const paneHeight = Math.max(MIN_WORKBENCH_HEIGHT, capped)
+    return `flex:0 0 ${paneHeight}px; height:${paneHeight}px; max-height:70vh; min-height:0;`
+  }
 
-    const sidebarStyle = this.#workbenchSidebarCollapsed
-      ? 'width:0; flex:0 0 0; overflow:hidden;'
-      : (() => {
-          const pos = this.#dragHorizontal.getPosition()
-          const m = pos.match(/flex-basis:\s*([\d.]+)px/)
-          const w = m ? m[1] : MIN_METATAB_WIDTH
-          return `${pos}; flex:0 0 auto; min-width:${w}px; max-width:${w}px;`
-        })()
+  #computeSidebarStyle(): string {
+    if (this.#workbenchSidebarCollapsed) {
+      return 'width:0; flex:0 0 0; overflow:hidden;'
+    }
+    const pos = this.#dragHorizontal.getPosition()
+    const m = pos.match(/flex-basis:\s*([\d.]+)px/)
+    const w = m ? m[1] : MIN_METATAB_WIDTH
+    return `${pos}; flex:0 0 auto; min-width:${w}px; max-width:${w}px;`
+  }
 
+  #renderActionsSidebar() {
     return html`
-      <section
-        data-horizontal-resizer-window
-        class="flex relative w-full ${heightWorkbench} min-h-0 overflow-hidden"
-        style="${styleWorkbench}"
+      <wdio-devtools-tabs
+        cacheId="activeActionsTab"
+        class="h-full flex flex-col border-r-[1px] border-r-panelBorder ${this
+          .#workbenchSidebarCollapsed
+          ? 'hidden'
+          : ''}"
       >
-        <section data-sidebar class="flex-none" style="${sidebarStyle}">
-          <wdio-devtools-tabs
-            cacheId="activeActionsTab"
-            class="h-full flex flex-col border-r-[1px] border-r-panelBorder ${this
-              .#workbenchSidebarCollapsed
-              ? 'hidden'
-              : ''}"
+        <wdio-devtools-tab label="Actions">
+          <wdio-devtools-actions></wdio-devtools-actions>
+        </wdio-devtools-tab>
+        <wdio-devtools-tab label="Metadata">
+          <wdio-devtools-metadata></wdio-devtools-metadata>
+        </wdio-devtools-tab>
+        <nav class="ml-auto" slot="actions">
+          <button
+            @click="${() => this.#toggle('workbenchSidebar')}"
+            class="flex h-10 w-10 items-center justify-center pointer ml-auto hover:bg-toolbarHoverBackground"
           >
-            <wdio-devtools-tab label="Actions">
-              <wdio-devtools-actions></wdio-devtools-actions>
-            </wdio-devtools-tab>
-            <wdio-devtools-tab label="Metadata">
-              <wdio-devtools-metadata></wdio-devtools-metadata>
-            </wdio-devtools-tab>
-            <nav class="ml-auto" slot="actions">
-              <button
-                @click="${() => this.#toggle('workbenchSidebar')}"
-                class="flex h-10 w-10 items-center justify-center pointer ml-auto hover:bg-toolbarHoverBackground"
-              >
-                <icon-mdi-arrow-collapse-left></icon-mdi-arrow-collapse-left>
-              </button>
-            </nav>
-          </wdio-devtools-tabs>
-          ${this.#workbenchSidebarCollapsed
-            ? html`
-                <button
-                  @click="${() => this.#toggle('workbenchSidebar')}"
-                  class="absolute top-2 left-2 bg-sideBarBackground flex h-10 w-10 items-center justify-center cursor-pointer rounded-md shadow hover:bg-toolbarHoverBackground border border-panelBorder"
-                >
-                  <icon-mdi-arrow-collapse-right></icon-mdi-arrow-collapse-right>
-                </button>
-              `
-            : nothing}
-        </section>
-        ${!this.#workbenchSidebarCollapsed
-          ? this.#dragHorizontal.getSlider('z-30')
-          : nothing}
-        <section
-          class="basis-auto text-gray-500 flex items-center justify-center flex-grow"
-        >
-          <wdio-devtools-browser></wdio-devtools-browser>
-        </section>
-      </section>
-      ${!this.#toolbarCollapsed
-        ? this.#dragVertical.getSlider('z-[999] -mt-[5px] pointer-events-auto')
+            <icon-mdi-arrow-collapse-left></icon-mdi-arrow-collapse-left>
+          </button>
+        </nav>
+      </wdio-devtools-tabs>
+      ${this.#workbenchSidebarCollapsed
+        ? html`
+            <button
+              @click="${() => this.#toggle('workbenchSidebar')}"
+              class="absolute top-2 left-2 bg-sideBarBackground flex h-10 w-10 items-center justify-center cursor-pointer rounded-md shadow hover:bg-toolbarHoverBackground border border-panelBorder"
+            >
+              <icon-mdi-arrow-collapse-right></icon-mdi-arrow-collapse-right>
+            </button>
+          `
         : nothing}
+    `
+  }
+
+  #renderCompareTabIfAvailable() {
+    if ((this.baselines?.size || 0) === 0) {
+      return nothing
+    }
+    return html`
+      <wdio-devtools-tab label="Compare" .badge="${this.baselines?.size || 0}">
+        <wdio-devtools-compare></wdio-devtools-compare>
+      </wdio-devtools-tab>
+    `
+  }
+
+  #renderToolbarCollapseButton() {
+    if (!this.#toolbarCollapsed) {
+      return nothing
+    }
+    return html`
+      <button
+        @click="${() => this.#toggle('toolbar')}"
+        class="fixed z-[9999] right-2 bottom-2 bg-sideBarBackground flex h-10 w-10 items-center justify-center cursor-pointer rounded-md shadow hover:bg-toolbarHoverBackground border border-panelBorder group"
+      >
+        <icon-mdi-arrow-collapse-up
+          class="group-hover:text-chartsBlue"
+        ></icon-mdi-arrow-collapse-up>
+      </button>
+    `
+  }
+
+  #renderWorkbenchTabs() {
+    return html`
       <wdio-devtools-tabs
         cacheId="activeWorkbenchTab"
         class="relative z-10 border-t-[1px] border-t-panelBorder ${this
@@ -222,16 +234,7 @@ export class DevtoolsWorkbench extends Element {
         >
           <wdio-devtools-network></wdio-devtools-network>
         </wdio-devtools-tab>
-        ${(this.baselines?.size || 0) > 0
-          ? html`
-              <wdio-devtools-tab
-                label="Compare"
-                .badge="${this.baselines?.size || 0}"
-              >
-                <wdio-devtools-compare></wdio-devtools-compare>
-              </wdio-devtools-tab>
-            `
-          : nothing}
+        ${this.#renderCompareTabIfAvailable()}
         <nav class="ml-auto" slot="actions">
           <button
             @click="${() => this.#toggle('toolbar')}"
@@ -243,19 +246,38 @@ export class DevtoolsWorkbench extends Element {
           </button>
         </nav>
       </wdio-devtools-tabs>
-      ${this.#toolbarCollapsed
-        ? html`
-            <button
-              @click="${() => this.#toggle('toolbar')}"
-              class="fixed z-[9999] right-2 bottom-2 bg-sideBarBackground flex h-10 w-10 items-center justify-center cursor-pointer rounded-md shadow
-                   hover:bg-toolbarHoverBackground border border-panelBorder group"
-            >
-              <icon-mdi-arrow-collapse-up
-                class="group-hover:text-chartsBlue"
-              ></icon-mdi-arrow-collapse-up>
-            </button>
-          `
+      ${this.#renderToolbarCollapseButton()}
+    `
+  }
+
+  render() {
+    const heightWorkbench = this.#toolbarCollapsed ? 'h-full flex-1' : ''
+    return html`
+      <section
+        data-horizontal-resizer-window
+        class="flex relative w-full ${heightWorkbench} min-h-0 overflow-hidden"
+        style="${this.#computeWorkbenchPaneStyle()}"
+      >
+        <section
+          data-sidebar
+          class="flex-none"
+          style="${this.#computeSidebarStyle()}"
+        >
+          ${this.#renderActionsSidebar()}
+        </section>
+        ${!this.#workbenchSidebarCollapsed
+          ? this.#dragHorizontal.getSlider('z-30')
+          : nothing}
+        <section
+          class="basis-auto text-gray-500 flex items-center justify-center flex-grow"
+        >
+          <wdio-devtools-browser></wdio-devtools-browser>
+        </section>
+      </section>
+      ${!this.#toolbarCollapsed
+        ? this.#dragVertical.getSlider('z-[999] -mt-[5px] pointer-events-auto')
         : nothing}
+      ${this.#renderWorkbenchTabs()}
     `
   }
 }
diff --git a/packages/app/src/components/workbench/actionItems/command.ts b/packages/app/src/components/workbench/actionItems/command.ts
index 3b1de55e..9723c606 100644
--- a/packages/app/src/components/workbench/actionItems/command.ts
+++ b/packages/app/src/components/workbench/actionItems/command.ts
@@ -1,7 +1,7 @@
 import { html } from 'lit'
 import { customElement, property } from 'lit/decorators.js'
 
-import type { CommandLog } from '@wdio/devtools-service/types'
+import type { CommandLog } from '@wdio/devtools-shared'
 
 import { ActionItem, ICON_CLASS } from './item.js'
 import '~icons/mdi/arrow-right.js'
diff --git a/packages/app/src/components/workbench/actionItems/item.ts b/packages/app/src/components/workbench/actionItems/item.ts
index f778cb13..fb8628cd 100644
--- a/packages/app/src/components/workbench/actionItems/item.ts
+++ b/packages/app/src/components/workbench/actionItems/item.ts
@@ -1,7 +1,7 @@
 import { Element } from '@core/element'
 import { html, css } from 'lit'
 import { property } from 'lit/decorators.js'
-import type { CommandLog } from '@wdio/devtools-service/types'
+import type { CommandLog } from '@wdio/devtools-shared'
 
 export type ActionEntry = TraceMutation | CommandLog
 
diff --git a/packages/app/src/components/workbench/actions.ts b/packages/app/src/components/workbench/actions.ts
index 7af6ca89..dc55c016 100644
--- a/packages/app/src/components/workbench/actions.ts
+++ b/packages/app/src/components/workbench/actions.ts
@@ -3,7 +3,7 @@ import { html, css } from 'lit'
 import { customElement } from 'lit/decorators.js'
 import { consume } from '@lit/context'
 
-import type { CommandLog } from '@wdio/devtools-service/types'
+import type { CommandLog } from '@wdio/devtools-shared'
 import { mutationContext, commandContext } from '../../controller/context.js'
 
 import '../placeholder.js'
diff --git a/packages/app/src/components/workbench/compare.ts b/packages/app/src/components/workbench/compare.ts
index ea5c877e..84e4c91e 100644
--- a/packages/app/src/components/workbench/compare.ts
+++ b/packages/app/src/components/workbench/compare.ts
@@ -1,5 +1,5 @@
 import { Element } from '@core/element'
-import { html, css, nothing } from 'lit'
+import { html, nothing } from 'lit'
 import { customElement, state } from 'lit/decorators.js'
 import { consume } from '@lit/context'
 
@@ -9,7 +9,7 @@ import type {
   CommandLog,
   PreservedAttempt,
   PreservedStep
-} from '@wdio/devtools-service/types'
+} from '@wdio/devtools-shared'
 import {
   baselineContext,
   selectedTestUidContext,
@@ -23,225 +23,34 @@ import {
   pairSteps,
   classifyDivergence,
   cleanErrorMessage,
-  extractExpectedFromStepText,
-  safeJson,
   type ComparePairedStep,
   type DivergenceKind
 } from './compare/compareUtils.js'
+
+interface RenderPairCtx {
+  pair: ComparePairedStep
+  kind: DivergenceKind
+  isTruncation: boolean
+  oneSideEntirelyEmpty: boolean
+  expanded: boolean
+  isFirstDivergent: boolean
+}
+import { BASELINE_API, type BaselineClearRequest } from '@wdio/devtools-shared'
+import { POPOUT_QUERY, buildPopoutFeatures } from './compare/constants.js'
+import { renderMarker } from './compare/markers.js'
+import { compareStyles } from './compare/styles.js'
 import {
-  BASELINE_API,
-  POPOUT_QUERY,
-  buildPopoutFeatures
-} from './compare/constants.js'
+  liveStepsForUid,
+  findStepFor,
+  isFailureSite
+} from './compare/stepResolution.js'
+import { renderDetailBlock } from './compare/renderDetailBlock.js'
 
 const COMPONENT = 'wdio-devtools-compare'
 
 @customElement(COMPONENT)
 export class DevtoolsCompare extends Element {
-  static styles = [
-    ...Element.styles,
-    css`
-      :host {
-        display: flex;
-        flex-direction: column;
-        width: 100%;
-        height: 100%;
-        min-height: 0;
-        overflow: hidden;
-        /* Needed so popout mode (where Compare sits directly under body) is themed. */
-        background-color: var(--vscode-editor-background, #1e1e1e);
-        color: var(--vscode-foreground, #cccccc);
-      }
-      .compare-grid {
-        display: grid;
-        grid-template-columns: 1fr 1fr;
-        gap: 0;
-        flex: 1 1 auto;
-        min-height: 0;
-        overflow: auto;
-        /* Stack rows from the top so they don't stretch to fill the grid. */
-        align-content: start;
-        grid-auto-rows: min-content;
-      }
-      .step-row {
-        display: contents;
-      }
-      .step-cell {
-        padding: 0.25rem 0.5rem;
-        border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
-        font-family: var(--vscode-editor-font-family, monospace);
-        font-size: 0.85em;
-        cursor: pointer;
-      }
-      .step-cell.divergent {
-        background: rgba(255, 90, 90, 0.08);
-      }
-      .step-cell.divergent.first {
-        background: rgba(255, 90, 90, 0.18);
-        border-left: 3px solid var(--vscode-charts-red, #f48771);
-      }
-      .marker {
-        margin-left: 0.35rem;
-        font-size: 0.85em;
-      }
-      .marker.result {
-        color: var(--vscode-charts-orange, #d19a66);
-      }
-      .marker.error {
-        color: var(--vscode-charts-red, #f48771);
-      }
-      .marker.command {
-        color: var(--vscode-charts-red, #f48771);
-      }
-      .marker.ok {
-        color: var(--vscode-charts-green, #73c373);
-      }
-      .marker.info {
-        color: var(--vscode-descriptionForeground, #999);
-        opacity: 0.7;
-      }
-      .error-banner {
-        margin: 0.5rem 0.75rem;
-        padding: 0.5rem 0.75rem;
-        background: rgba(244, 135, 113, 0.12);
-        border-left: 3px solid var(--vscode-charts-red, #f48771);
-        border-radius: 3px;
-        font-size: 0.85em;
-      }
-      .error-banner-title {
-        font-weight: 600;
-        margin-bottom: 0.25rem;
-        opacity: 0.85;
-        font-family: inherit;
-      }
-      /* Pre-wrap only on the message body so template indentation doesn't render. */
-      .error-banner-message {
-        font-family: var(--vscode-editor-font-family, monospace);
-        white-space: pre-wrap;
-        word-break: break-word;
-        margin: 0;
-      }
-      .step-cell.missing {
-        opacity: 0.35;
-        font-style: italic;
-      }
-      .step-cell:hover {
-        background: var(
-          --vscode-toolbar-hoverBackground,
-          rgba(255, 255, 255, 0.06)
-        );
-      }
-      .step-cell.expanded {
-        background: rgba(80, 160, 255, 0.06);
-      }
-      .pill {
-        display: inline-flex;
-        align-items: center;
-        gap: 0.25rem;
-        padding: 0.1rem 0.5rem;
-        border-radius: 4px;
-        font-size: 0.85em;
-        background: var(--vscode-badge-background, #2a2a2a);
-      }
-      .pill.failed {
-        background: rgba(244, 135, 113, 0.2);
-        color: var(--vscode-charts-red, #f48771);
-      }
-      .pill.passed {
-        background: rgba(115, 195, 115, 0.2);
-        color: var(--vscode-charts-green, #73c373);
-      }
-      .topbar {
-        display: flex;
-        align-items: center;
-        gap: 0.5rem;
-        padding: 0.5rem 0.75rem;
-        border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
-        flex: 0 0 auto;
-      }
-      .col-header {
-        position: sticky;
-        top: 0;
-        background: var(--vscode-editor-background, #1e1e1e);
-        z-index: 1;
-        padding: 0.5rem;
-        font-weight: 600;
-        font-size: 0.85em;
-        border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
-      }
-      .detail-panel {
-        grid-column: span 2;
-        background: var(--vscode-editor-background, #1e1e1e);
-        border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
-        padding: 0.5rem;
-      }
-      .detail-grid {
-        display: grid;
-        grid-template-columns: 1fr 1fr;
-        gap: 0.75rem;
-      }
-      .detail-block {
-        font-size: 0.85em;
-      }
-      .detail-block h4 {
-        font-size: 0.85em;
-        margin: 0 0 0.25rem;
-        opacity: 0.7;
-        font-weight: 600;
-      }
-      .detail-block pre {
-        margin: 0;
-        white-space: pre-wrap;
-        word-break: break-word;
-        font-size: 0.85em;
-        background: rgba(255, 255, 255, 0.03);
-        padding: 0.25rem 0.4rem;
-        border-radius: 3px;
-      }
-      .empty-state {
-        flex: 1;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        color: var(--vscode-descriptionForeground, #888);
-        font-size: 0.9em;
-        text-align: center;
-        padding: 1rem;
-      }
-      .toggle-label {
-        display: inline-flex;
-        align-items: center;
-        gap: 0.35rem;
-        cursor: pointer;
-        font-size: 0.85em;
-      }
-      button.action {
-        background: transparent;
-        border: 1px solid var(--vscode-panel-border, #2a2a2a);
-        color: inherit;
-        padding: 0.2rem 0.5rem;
-        border-radius: 3px;
-        cursor: pointer;
-        font-size: 0.85em;
-      }
-      button.action:hover {
-        background: var(
-          --vscode-toolbar-hoverBackground,
-          rgba(255, 255, 255, 0.06)
-        );
-      }
-      button.action.icon-only {
-        display: inline-flex;
-        align-items: center;
-        justify-content: center;
-        padding: 0.25rem 0.4rem;
-      }
-      button.action.icon-only svg {
-        width: 1em;
-        height: 1em;
-      }
-    `
-  ]
+  static styles = [...Element.styles, compareStyles]
 
   @consume({ context: baselineContext, subscribe: true })
   @state()
@@ -309,125 +118,21 @@ export class DevtoolsCompare extends Element {
   /** Walk live suiteContext under selectedTestUid and collect leaf tests
    *  so live commands can be attributed to their parent step. */
   #liveStepsForSelectedUid(): PreservedStep[] {
-    const target = this.selectedTestUid
-    if (!target || !this.liveSuites) {
-      return []
-    }
-    const out: PreservedStep[] = []
-    let foundRoot: SuiteStatsFragment | undefined
-    const findRoot = (
-      s: SuiteStatsFragment | undefined
-    ): SuiteStatsFragment | undefined => {
-      if (!s) {
-        return undefined
-      }
-      if (s.uid === target) {
-        return s
-      }
-      for (const child of s.suites ?? []) {
-        const hit = findRoot(child)
-        if (hit) {
-          return hit
-        }
-      }
-      return undefined
-    }
-    for (const chunk of this.liveSuites) {
-      for (const root of Object.values(chunk)) {
-        foundRoot = findRoot(root)
-        if (foundRoot) {
-          break
-        }
-      }
-      if (foundRoot) {
-        break
-      }
-    }
-    if (!foundRoot) {
-      return []
-    }
-    const visit = (s: SuiteStatsFragment) => {
-      for (const t of s.tests ?? []) {
-        out.push({
-          uid: t.uid,
-          title: t.title,
-          fullTitle: t.fullTitle,
-          start: t.start ? new Date(t.start).getTime() : undefined,
-          end: t.end ? new Date(t.end).getTime() : undefined,
-          state:
-            t.state === 'pending' || t.state === 'running' ? t.state : t.state,
-          error: t.error
-            ? {
-                message: t.error.message,
-                name: t.error.name,
-                stack: t.error.stack
-              }
-            : undefined
-        })
-      }
-      for (const child of s.suites ?? []) {
-        visit(child)
-      }
-    }
-    visit(foundRoot)
-    return out
+    return liveStepsForUid(this.selectedTestUid, this.liveSuites)
   }
 
   #findStepFor(
     cmd: CommandLog | undefined,
     side: 'baseline' | 'latest'
   ): PreservedStep | undefined {
-    if (!cmd?.timestamp) {
-      return undefined
-    }
-    const steps =
-      side === 'baseline'
-        ? (this.#getBaseline()?.steps ?? [])
-        : this.#liveStepsForSelectedUid()
-    const ts = cmd.timestamp
-    return steps.find(
-      (s) =>
-        s.start !== null &&
-        s.start !== undefined &&
-        s.end !== null &&
-        s.end !== undefined &&
-        ts >= s.start &&
-        ts <= s.end
+    return findStepFor(
+      cmd,
+      side,
+      this.#getBaseline(),
+      this.#liveStepsForSelectedUid()
     )
   }
 
-  /** The failure site is either the command that errored at the WebDriver
-   *  level OR the last command in a failed step (assertion site). */
-  #isFailureSite(
-    cmd: CommandLog,
-    step: PreservedStep | undefined,
-    allCommandsOnSide: CommandLog[]
-  ): boolean {
-    if (!step || step.state !== 'failed') {
-      return false
-    }
-    if (cmd.error?.message) {
-      return true
-    }
-    if (step.start === null || step.end === null) {
-      return false
-    }
-    let lastTs = 0
-    for (const c of allCommandsOnSide) {
-      if (
-        c.timestamp !== null &&
-        step.start !== undefined &&
-        step.end !== undefined &&
-        c.timestamp >= step.start &&
-        c.timestamp <= step.end &&
-        c.timestamp > lastTs
-      ) {
-        lastTs = c.timestamp
-      }
-    }
-    return cmd.timestamp === lastTs
-  }
-
   /** Scope the global live command stream to commands within the selected
    *  test's step time windows (mirrors the backend's snapshot filter). */
   #liveCommandsForSelectedUid(): CommandLog[] {
@@ -460,10 +165,11 @@ export class DevtoolsCompare extends Element {
       return
     }
     try {
+      const body: BaselineClearRequest = { testUid: this.selectedTestUid }
       await fetch(BASELINE_API.clear, {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ testUid: this.selectedTestUid })
+        body: JSON.stringify(body)
       })
     } catch {
       // best-effort; the server broadcast updates the context.
@@ -482,49 +188,47 @@ export class DevtoolsCompare extends Element {
     window.open(url, `compare-${this.selectedTestUid}`, buildPopoutFeatures())
   }
 
-  render() {
-    const baseline = this.#getBaseline()
-    if (!baseline) {
-      return html`
-        <div class="empty-state">
-          <div>
-            <p>No baseline preserved.</p>
-            <p>
-              Click the
-              <strong>📌 Preserve &amp; Rerun</strong> button on a failed test
-              to compare the failing run against the rerun.
-            </p>
-          </div>
+  #renderEmptyState() {
+    return html`
+      <div class="empty-state">
+        <div>
+          <p>No baseline preserved.</p>
+          <p>
+            Click the
+            <strong>📌 Preserve &amp; Rerun</strong> button on a failed test to
+            compare the failing run against the rerun.
+          </p>
         </div>
-      `
-    }
-
-    const baselineCommands = baseline.commands as CommandLog[]
-    const latestCommands = this.#liveCommandsForSelectedUid()
-
-    // Naming follows physical sides (left/right) after swap.
-    const leftAttempt = this.swapped ? null : baseline
-    const rightAttempt = this.swapped ? baseline : null
-    const leftCommands = this.swapped ? latestCommands : baselineCommands
-    const rightCommands = this.swapped ? baselineCommands : latestCommands
+      </div>
+    `
+  }
 
-    const pairs = pairSteps(baselineCommands, latestCommands)
-    const visiblePairs = this.differencesOnly
-      ? pairs.filter((p) => p.divergent || !p.baseline || !p.latest)
-      : pairs
-    const firstDivergent = pairs.findIndex((p) => p.divergent)
+  #renderPopoutButton() {
+    if (this.#isPopout) {
+      return nothing
+    }
+    return html`
+      <button
+        class="action icon-only"
+        @click="${() => this.#popOut()}"
+        title="Open this comparison in a separate window"
+        aria-label="Open in a separate window"
+      >
+        <icon-mdi-open-in-new></icon-mdi-open-in-new>
+      </button>
+    `
+  }
 
-    const errorMessage = baseline.test.error?.message
-      ? cleanErrorMessage(baseline.test.error.message)
-      : undefined
+  #renderTopbar(baseline: PreservedAttempt, latestCount: number) {
+    const baselineCount = (baseline.commands as CommandLog[]).length
     return html`
       <div class="topbar">
         <span class="pill ${baseline.test.state || ''}">
-          Baseline · ${baseline.test.state || 'unknown'} ·
-          ${baselineCommands.length} commands
+          Baseline · ${baseline.test.state || 'unknown'} · ${baselineCount}
+          commands
         </span>
         <span>⇄</span>
-        <span class="pill"> Latest · ${latestCommands.length} commands </span>
+        <span class="pill"> Latest · ${latestCount} commands </span>
         <span style="opacity:0.6; font-size:0.85em;">
           ${baseline.scope === 'suite' ? 'suite scope' : 'test scope'}
         </span>
@@ -551,19 +255,31 @@ export class DevtoolsCompare extends Element {
         >
           Clear
         </button>
-        ${this.#isPopout
-          ? nothing
-          : html`
-              <button
-                class="action icon-only"
-                @click="${() => this.#popOut()}"
-                title="Open this comparison in a separate window"
-                aria-label="Open in a separate window"
-              >
-                <icon-mdi-open-in-new></icon-mdi-open-in-new>
-              </button>
-            `}
+        ${this.#renderPopoutButton()}
       </div>
+    `
+  }
+
+  render() {
+    const baseline = this.#getBaseline()
+    if (!baseline) {
+      return this.#renderEmptyState()
+    }
+    const baselineCommands = baseline.commands as CommandLog[]
+    const latestCommands = this.#liveCommandsForSelectedUid()
+    // Naming follows physical sides (left/right) after swap.
+    const leftCommands = this.swapped ? latestCommands : baselineCommands
+    const rightCommands = this.swapped ? baselineCommands : latestCommands
+    const pairs = pairSteps(baselineCommands, latestCommands)
+    const visiblePairs = this.differencesOnly
+      ? pairs.filter((p) => p.divergent || !p.baseline || !p.latest)
+      : pairs
+    const firstDivergent = pairs.findIndex((p) => p.divergent)
+    const errorMessage = baseline.test.error?.message
+      ? cleanErrorMessage(baseline.test.error.message)
+      : undefined
+    return html`
+      ${this.#renderTopbar(baseline, latestCommands.length)}
       ${errorMessage
         ? html`<div class="error-banner">
             <div class="error-banner-title">Why the baseline failed</div>
@@ -577,7 +293,6 @@ export class DevtoolsCompare extends Element {
           this.#renderPair(pair, leftCommands, rightCommands, firstDivergent)
         )}
       </div>
-      ${leftAttempt || rightAttempt ? nothing : nothing}
     `
   }
 
@@ -591,168 +306,28 @@ export class DevtoolsCompare extends Element {
     const expanded = this.expandedIndex === pair.index
     const left = leftCommands[pair.index]
     const right = rightCommands[pair.index]
-
     // Classify divergence ONCE so left and right rows share the same label.
     const kind: DivergenceKind = classifyDivergence(left, right)
-    const stepFor = (
-      cmd: CommandLog | undefined,
-      side: 'baseline' | 'latest'
-    ) => this.#findStepFor(cmd, side)
     // Skip "missing" markers when one side is entirely empty (e.g. the rerun
     // hasn't produced commands yet). The populated side should display its
     // own status, not be falsely flagged as "missing".
-    const leftEmpty = leftCommands.length === 0
-    const rightEmpty = rightCommands.length === 0
-    const oneSideEntirelyEmpty = leftEmpty || rightEmpty
-    const marker = (
-      cmd: CommandLog | undefined,
-      side: 'baseline' | 'latest'
-    ) => {
-      if (!cmd) {
-        return nothing
-      }
-      // Row-level divergence wins over the per-command status marker.
-      switch (kind) {
-        case 'commandName':
-          return html`<span
-            class="marker command"
-            title="Different WebDriver command — execution diverged at this step"
-            >different command</span
-          >`
-        case 'args':
-          return html`<span
-            class="marker command"
-            title="Same command, different arguments (compare args in the expanded view)"
-            >args differ</span
-          >`
-        case 'error':
-          if (cmd.error?.message) {
-            return html`<span
-              class="marker error"
-              title="WebDriver error: ${cmd.error.message}"
-              >⚠ error</span
-            >`
-          }
-          break
-      }
-      const step = stepFor(cmd, side)
-      const allCmdsThisSide =
-        side === 'baseline'
-          ? ((this.#getBaseline()?.commands ?? []) as CommandLog[])
-          : this.#liveCommandsForSelectedUid()
-      const statusMarker =
-        step?.state === 'failed' &&
-        this.#isFailureSite(cmd, step, allCmdsThisSide)
-          ? html`<span
-              class="marker error"
-              title="${step.error?.message
-                ? `Failed step: ${step.fullTitle || step.title || step.uid}\n${step.error.message}`
-                : `Failed step: ${step.fullTitle || step.title || step.uid}`}"
-              >✗ in failed step</span
-            >`
-          : step?.state === 'passed'
-            ? html`<span
-                class="marker ok"
-                title="Step passed: ${step.fullTitle || step.title || step.uid}"
-                >✓</span
-              >`
-            : html`<span class="marker ok" title="Identical">✓</span>`
-      // Truncation: status + a muted "only here" pill.
-      if (kind === 'missing' && !oneSideEntirelyEmpty) {
-        return html`${statusMarker}<span
-            class="marker info"
-            title="Only present on this side — the other run ended before this step"
-            >only here</span
-          >`
-      }
-      return statusMarker
-    }
-
-    // Truncation = one side has the command, the other doesn't.
-    const isTruncation = !left || !right
-    /** Per-cell divergence so the passing side stays neutral when only the
-     *  other side has the actual problem. */
-    const cellIsDivergent = (
-      cmd: CommandLog | undefined,
-      side: 'baseline' | 'latest'
-    ) => {
-      if (!pair.divergent || isTruncation || !cmd) {
-        return false
-      }
-      switch (kind) {
-        case 'commandName':
-        case 'args':
-          // Both sides genuinely differ — both cells are divergent.
-          return true
-        case 'error':
-          // Only the side with the actual error is divergent.
-          return !!cmd.error?.message
-        case 'missing':
-          return false
-        case 'none':
-        default: {
-          // Step-level failure site: only the failure site is divergent.
-          const step = this.#findStepFor(cmd, side)
-          if (step?.state !== 'failed') {
-            return false
-          }
-          const allCmds =
-            side === 'baseline'
-              ? ((this.#getBaseline()?.commands ?? []) as CommandLog[])
-              : this.#liveCommandsForSelectedUid()
-          return this.#isFailureSite(cmd, step, allCmds)
-        }
-      }
+    const oneSideEntirelyEmpty =
+      leftCommands.length === 0 || rightCommands.length === 0
+    const ctx: RenderPairCtx = {
+      pair,
+      kind,
+      isTruncation: !left || !right,
+      oneSideEntirelyEmpty,
+      expanded,
+      isFirstDivergent
     }
-    const cellClass = (
-      cmd: CommandLog | undefined,
-      side: 'baseline' | 'latest'
-    ) => {
-      const cls = ['step-cell']
-      if (!cmd) {
-        cls.push('missing')
-      }
-      const divergent = cellIsDivergent(cmd, side)
-      if (divergent) {
-        cls.push('divergent')
-      }
-      if (isFirstDivergent && divergent) {
-        cls.push('first')
-      }
-      if (expanded) {
-        cls.push('expanded')
-      }
-      return cls.join(' ')
-    }
-
     type Side = 'baseline' | 'latest'
     const leftSide: Side = this.swapped ? 'latest' : 'baseline'
     const rightSide: Side = this.swapped ? 'baseline' : 'latest'
     return html`
       <div class="step-row">
-        <div
-          class="${cellClass(left, leftSide)}"
-          data-first-divergent="${isFirstDivergent ? 'true' : 'false'}"
-          @click="${() => this.#toggleExpand(pair.index)}"
-        >
-          ${left
-            ? html`${pair.index + 1}. <code>${left.command}</code>${marker(
-                  left,
-                  leftSide
-                )}`
-            : html`—`}
-        </div>
-        <div
-          class="${cellClass(right, rightSide)}"
-          @click="${() => this.#toggleExpand(pair.index)}"
-        >
-          ${right
-            ? html`${pair.index + 1}. <code>${right.command}</code>${marker(
-                  right,
-                  rightSide
-                )}`
-            : html`—`}
-        </div>
+        ${this.#renderPairCell(left, leftSide, ctx)}
+        ${this.#renderPairCell(right, rightSide, ctx)}
         ${expanded
           ? html`
               <div class="detail-panel">
@@ -775,110 +350,92 @@ export class DevtoolsCompare extends Element {
     `
   }
 
-  #renderDetailBlock(
-    label: string,
+  #cellIsDivergent(
     cmd: CommandLog | undefined,
-    side: 'baseline' | 'latest'
+    side: 'baseline' | 'latest',
+    ctx: RenderPairCtx
+  ): boolean {
+    if (!ctx.pair.divergent || ctx.isTruncation || !cmd) {
+      return false
+    }
+    switch (ctx.kind) {
+      case 'commandName':
+      case 'args':
+        return true
+      case 'error':
+        return !!cmd.error?.message
+      case 'missing':
+        return false
+      case 'none':
+      default: {
+        const step = this.#findStepFor(cmd, side)
+        if (step?.state !== 'failed') {
+          return false
+        }
+        const allCmds =
+          side === 'baseline'
+            ? ((this.#getBaseline()?.commands ?? []) as CommandLog[])
+            : this.#liveCommandsForSelectedUid()
+        return isFailureSite(cmd, step, allCmds)
+      }
+    }
+  }
+
+  #renderPairCell(
+    cmd: CommandLog | undefined,
+    side: 'baseline' | 'latest',
+    ctx: RenderPairCtx
   ) {
+    const cls = ['step-cell']
     if (!cmd) {
-      return html`<div class="detail-block">
-        <h4>${label}</h4>
-        <em style="opacity:0.6;">No command at this step</em>
-      </div>`
+      cls.push('missing')
+    }
+    const divergent = this.#cellIsDivergent(cmd, side, ctx)
+    if (divergent) {
+      cls.push('divergent')
+    }
+    if (ctx.isFirstDivergent && divergent) {
+      cls.push('first')
+    }
+    if (ctx.expanded) {
+      cls.push('expanded')
     }
-    const argsStr = safeJson(cmd.args)
-    const resultStr = safeJson(cmd.result)
-    const step = this.#findStepFor(cmd, side)
-    // Only the failure-site command shows step-level expected/actual/assertion;
-    // other commands in the failed step succeeded individually.
-    const allCmdsThisSide =
+    const allCmds =
       side === 'baseline'
         ? ((this.#getBaseline()?.commands ?? []) as CommandLog[])
         : this.#liveCommandsForSelectedUid()
-    const isFailureSite = this.#isFailureSite(cmd, step, allCmdsThisSide)
-    const expected =
-      isFailureSite && step?.error?.expected !== undefined
-        ? step.error.expected
-        : isFailureSite
-          ? step?.error?.matcherResult?.expected
-          : undefined
-    const actual =
-      isFailureSite && step?.error?.actual !== undefined
-        ? step.error.actual
-        : isFailureSite
-          ? step?.error?.matcherResult?.actual
-          : undefined
-    const rawAssertion = isFailureSite
-      ? step?.error?.matcherResult?.message || step?.error?.message
-      : undefined
-    const assertionMessage = rawAssertion
-      ? cleanErrorMessage(rawAssertion)
-      : undefined
-    // Fallback: extract the expected from the Cucumber step text.
-    const stepText = step?.fullTitle || step?.title || ''
-    const fallbackExpected =
-      isFailureSite && expected === undefined && step?.state === 'failed'
-        ? extractExpectedFromStepText(stepText)
-        : undefined
+    const marker = renderMarker({
+      cmd,
+      kind: ctx.kind,
+      step: this.#findStepFor(cmd, side),
+      allCmdsThisSide: allCmds,
+      oneSideEntirelyEmpty: ctx.oneSideEntirelyEmpty
+    })
     return html`
-      <div class="detail-block">
-        <h4>${label} · ${cmd.command}</h4>
-        ${step
-          ? html`<pre
-              style="opacity:0.85; border-left:2px solid ${step.state ===
-              'failed'
-                ? 'var(--vscode-charts-red,#f48771)'
-                : 'var(--vscode-charts-green,#73c373)'}; padding-left:0.5rem;"
-            >
-step: ${stepText || step.uid}</pre
-            >`
-          : nothing}
-        <pre>args: ${argsStr}</pre>
-        ${cmd.error
-          ? html`<pre style="color:var(--vscode-charts-red,#f48771);">
-error: ${cmd.error.message || String(cmd.error)}</pre
-            >`
-          : html`<pre>result: ${resultStr}</pre>`}
-        ${expected !== undefined
-          ? html`<pre
-              style="color:var(--vscode-charts-green,#73c373); white-space:pre-wrap; word-break:break-word;"
-            >
-expected: ${safeJson(expected)}</pre
-            >`
-          : fallbackExpected
-            ? html`<pre
-                style="color:var(--vscode-charts-green,#73c373); white-space:pre-wrap; word-break:break-word;"
-                title="Derived from the step text (the assertion library didn't surface a structured expected value)"
-              >
-expected (from step): ${fallbackExpected}</pre
-              >`
-            : nothing}
-        ${actual !== undefined
-          ? html`<pre
-              style="color:var(--vscode-charts-orange,#d19a66); white-space:pre-wrap; word-break:break-word;"
-            >
-actual:   ${safeJson(actual)}</pre
-            >`
-          : nothing}
-        ${assertionMessage
-          ? html`<pre
-              style="color:var(--vscode-charts-red,#f48771); white-space:pre-wrap; word-break:break-word; max-height:200px; overflow:auto;"
-            >
-assertion: ${assertionMessage}</pre
-            >`
-          : nothing}
-        ${cmd.screenshot
-          ? html`<img
-              src="${cmd.screenshot.startsWith('data:')
-                ? cmd.screenshot
-                : `data:image/png;base64,${cmd.screenshot}`}"
-              style="max-width:100%; margin-top:0.25rem; border:1px solid var(--vscode-panel-border,#2a2a2a);"
-            />`
-          : nothing}
+      <div
+        class="${cls.join(' ')}"
+        data-first-divergent="${ctx.isFirstDivergent ? 'true' : 'false'}"
+        @click="${() => this.#toggleExpand(ctx.pair.index)}"
+      >
+        ${cmd
+          ? html`${ctx.pair.index + 1}. <code>${cmd.command}</code>${marker}`
+          : html`—`}
       </div>
     `
   }
 
+  #renderDetailBlock(
+    label: string,
+    cmd: CommandLog | undefined,
+    side: 'baseline' | 'latest'
+  ) {
+    return renderDetailBlock(label, cmd, side, {
+      baseline: this.#getBaseline(),
+      liveCommandsForSelectedUid: () => this.#liveCommandsForSelectedUid(),
+      findStepFor: (c, s) => this.#findStepFor(c, s)
+    })
+  }
+
   #toggleExpand(index: number) {
     this.expandedIndex = this.expandedIndex === index ? null : index
   }
diff --git a/packages/app/src/components/workbench/compare/compareUtils.ts b/packages/app/src/components/workbench/compare/compareUtils.ts
index a4d3d1b2..a1dc34fd 100644
--- a/packages/app/src/components/workbench/compare/compareUtils.ts
+++ b/packages/app/src/components/workbench/compare/compareUtils.ts
@@ -1,4 +1,4 @@
-import type { CommandLog } from '@wdio/devtools-service/types'
+import type { CommandLog } from '@wdio/devtools-shared'
 
 export interface ComparePairedStep {
   index: number
diff --git a/packages/app/src/components/workbench/compare/constants.ts b/packages/app/src/components/workbench/compare/constants.ts
index 7594824b..b6dbb6b2 100644
--- a/packages/app/src/components/workbench/compare/constants.ts
+++ b/packages/app/src/components/workbench/compare/constants.ts
@@ -1,13 +1,3 @@
-export const BASELINE_API = {
-  preserve: '/api/baseline/preserve',
-  clear: '/api/baseline/clear'
-} as const
-
-export const BASELINE_WS_SCOPE = {
-  saved: 'baseline:saved',
-  cleared: 'baseline:cleared'
-} as const
-
 export const POPOUT_QUERY = {
   viewKey: 'view',
   viewValue: 'compare',
diff --git a/packages/app/src/components/workbench/compare/markers.ts b/packages/app/src/components/workbench/compare/markers.ts
new file mode 100644
index 00000000..ed87c5a9
--- /dev/null
+++ b/packages/app/src/components/workbench/compare/markers.ts
@@ -0,0 +1,108 @@
+import { html, nothing, type TemplateResult } from 'lit'
+import type { CommandLog, PreservedStep } from '@wdio/devtools-shared'
+import { type DivergenceKind } from './compareUtils.js'
+import { isFailureSite } from './stepResolution.js'
+
+export interface MarkerContext {
+  cmd: CommandLog | undefined
+  /** Pre-classified divergence kind for the row (shared across left/right cells). */
+  kind: DivergenceKind
+  /** Already-resolved step for this command + side (resolved by the parent). */
+  step: PreservedStep | undefined
+  /**
+   * All commands on this side, used by `isFailureSite` to decide whether this
+   * specific command is the failure-site (vs another command in the same
+   * failed step). The parent computes it once per side and passes it in to
+   * avoid redundant resolver calls.
+   */
+  allCmdsThisSide: CommandLog[]
+  /**
+   * True when one of the two compared runs has zero commands. Suppresses the
+   * "only here" pill on truncated rows — the populated side should display
+   * its own status, not be falsely flagged.
+   */
+  oneSideEntirelyEmpty: boolean
+}
+
+/**
+ * Render the per-cell status marker for the Compare view. Extracted from
+ * `<wdio-devtools-compare>#renderPair` — pure function of `MarkerContext`,
+ * no component-state coupling. Returns a Lit template, an `html` fragment
+ * (for the truncation "only here" case), or `nothing` when there's no
+ * command to mark.
+ */
+function renderRowDivergenceMarker(
+  kind: MarkerContext['kind'],
+  cmd: NonNullable<MarkerContext['cmd']>
+): TemplateResult | undefined {
+  switch (kind) {
+    case 'commandName':
+      return html`<span
+        class="marker command"
+        title="Different WebDriver command — execution diverged at this step"
+        >different command</span
+      >`
+    case 'args':
+      return html`<span
+        class="marker command"
+        title="Same command, different arguments (compare args in the expanded view)"
+        >args differ</span
+      >`
+    case 'error':
+      if (cmd.error?.message) {
+        return html`<span
+          class="marker error"
+          title="WebDriver error: ${cmd.error.message}"
+          >⚠ error</span
+        >`
+      }
+      return undefined
+  }
+  return undefined
+}
+
+function renderStatusMarker(
+  cmd: NonNullable<MarkerContext['cmd']>,
+  step: MarkerContext['step'],
+  allCmdsThisSide: MarkerContext['allCmdsThisSide']
+): TemplateResult {
+  if (step?.state === 'failed' && isFailureSite(cmd, step, allCmdsThisSide)) {
+    const id = step.fullTitle || step.title || step.uid
+    const titleText = step.error?.message
+      ? `Failed step: ${id}\n${step.error.message}`
+      : `Failed step: ${id}`
+    return html`<span class="marker error" title="${titleText}"
+      >✗ in failed step</span
+    >`
+  }
+  if (step?.state === 'passed') {
+    return html`<span
+      class="marker ok"
+      title="Step passed: ${step.fullTitle || step.title || step.uid}"
+      >✓</span
+    >`
+  }
+  return html`<span class="marker ok" title="Identical">✓</span>`
+}
+
+export function renderMarker(
+  opts: MarkerContext
+): TemplateResult | typeof nothing {
+  const { cmd, kind, step, allCmdsThisSide, oneSideEntirelyEmpty } = opts
+  if (!cmd) {
+    return nothing
+  }
+  const divergence = renderRowDivergenceMarker(kind, cmd)
+  if (divergence) {
+    return divergence
+  }
+  const statusMarker = renderStatusMarker(cmd, step, allCmdsThisSide)
+  if (kind === 'missing' && !oneSideEntirelyEmpty) {
+    return html`${statusMarker}<span
+        class="marker info"
+        title="Only present on this side — the other run ended before this step"
+        >only here</span
+      >`
+  }
+  return statusMarker
+}
diff --git a/packages/app/src/components/workbench/compare/renderDetailBlock.ts b/packages/app/src/components/workbench/compare/renderDetailBlock.ts
new file mode 100644
index 00000000..1c4c03ed
--- /dev/null
+++ b/packages/app/src/components/workbench/compare/renderDetailBlock.ts
@@ -0,0 +1,131 @@
+/**
+ * Detail-block rendering for the compare view. Extracted from the host
+ * component so the Lit class stays under the file-size cap; everything
+ * the renderers need is passed in through the {@link DetailBlockCtx} bag.
+ */
+
+import { html, nothing, type TemplateResult } from 'lit'
+import type {
+  CommandLog,
+  PreservedAttempt,
+  PreservedStep
+} from '@wdio/devtools-shared'
+import { safeJson } from './compareUtils.js'
+import { computeDetailBlockData } from './stepResolution.js'
+
+/** Hooks the detail-block renderers need to reach component state. */
+export interface DetailBlockCtx {
+  baseline: PreservedAttempt | undefined
+  liveCommandsForSelectedUid(): CommandLog[]
+  findStepFor(
+    cmd: CommandLog | undefined,
+    side: 'baseline' | 'latest'
+  ): PreservedStep | undefined
+}
+
+export function renderDetailStepBanner(
+  step: PreservedStep | undefined,
+  stepText: string
+): TemplateResult | typeof nothing {
+  if (!step) {
+    return nothing
+  }
+  const color =
+    step.state === 'failed'
+      ? 'var(--vscode-charts-red,#f48771)'
+      : 'var(--vscode-charts-green,#73c373)'
+  return html`<pre
+    style="opacity:0.85; border-left:2px solid ${color}; padding-left:0.5rem;"
+  >
+step: ${stepText || step.uid}</pre
+  >`
+}
+
+export function renderExpectedActualAssertion(
+  expected: unknown,
+  actual: unknown,
+  assertionMessage: string | undefined,
+  fallbackExpected: string | undefined
+): TemplateResult {
+  return html`
+    ${expected !== undefined
+      ? html`<pre
+          style="color:var(--vscode-charts-green,#73c373); white-space:pre-wrap; word-break:break-word;"
+        >
+expected: ${safeJson(expected)}</pre
+        >`
+      : fallbackExpected
+        ? html`<pre
+            style="color:var(--vscode-charts-green,#73c373); white-space:pre-wrap; word-break:break-word;"
+            title="Derived from the step text (the assertion library didn't surface a structured expected value)"
+          >
+expected (from step): ${fallbackExpected}</pre
+          >`
+        : nothing}
+    ${actual !== undefined
+      ? html`<pre
+          style="color:var(--vscode-charts-orange,#d19a66); white-space:pre-wrap; word-break:break-word;"
+        >
+actual:   ${safeJson(actual)}</pre
+        >`
+      : nothing}
+    ${assertionMessage
+      ? html`<pre
+          style="color:var(--vscode-charts-red,#f48771); white-space:pre-wrap; word-break:break-word; max-height:200px; overflow:auto;"
+        >
+assertion: ${assertionMessage}</pre
+        >`
+      : nothing}
+  `
+}
+
+export function renderDetailBlock(
+  label: string,
+  cmd: CommandLog | undefined,
+  side: 'baseline' | 'latest',
+  ctx: DetailBlockCtx
+): TemplateResult {
+  if (!cmd) {
+    return html`<div class="detail-block">
+      <h4>${label}</h4>
+      <em style="opacity:0.6;">No command at this step</em>
+    </div>`
+  }
+  // Only the failure-site command shows step-level expected/actual/assertion;
+  // other commands in the failed step succeeded individually.
+  const allCmdsThisSide =
+    side === 'baseline'
+      ? ((ctx.baseline?.commands ?? []) as CommandLog[])
+      : ctx.liveCommandsForSelectedUid()
+  const data = computeDetailBlockData(
+    cmd,
+    ctx.findStepFor(cmd, side),
+    allCmdsThisSide
+  )
+  return html`
+    <div class="detail-block">
+      <h4>${label} · ${cmd.command}</h4>
+      ${renderDetailStepBanner(data.step, data.stepText)}
+      <pre>args: ${data.argsStr}</pre>
+      ${cmd.error
+        ? html`<pre style="color:var(--vscode-charts-red,#f48771);">
+error: ${cmd.error.message || String(cmd.error)}</pre
+          >`
+        : html`<pre>result: ${data.resultStr}</pre>`}
+      ${renderExpectedActualAssertion(
+        data.expected,
+        data.actual,
+        data.assertionMessage,
+        data.fallbackExpected
+      )}
+      ${cmd.screenshot
+        ? html`<img
+            src="${cmd.screenshot.startsWith('data:')
+              ? cmd.screenshot
+              : `data:image/png;base64,${cmd.screenshot}`}"
+            style="max-width:100%; margin-top:0.25rem; border:1px solid var(--vscode-panel-border,#2a2a2a);"
+          />`
+        : nothing}
+    </div>
+  `
+}
diff --git a/packages/app/src/components/workbench/compare/stepResolution.ts b/packages/app/src/components/workbench/compare/stepResolution.ts
new file mode 100644
index 00000000..54c36469
--- /dev/null
+++ b/packages/app/src/components/workbench/compare/stepResolution.ts
@@ -0,0 +1,212 @@
+import type {
+  CommandLog,
+  PreservedAttempt,
+  PreservedStep
+} from '@wdio/devtools-shared'
+import type { SuiteStatsFragment } from '../../../controller/types.js'
+import {
+  cleanErrorMessage,
+  extractExpectedFromStepText,
+  safeJson
+} from './compareUtils.js'
+
+/**
+ * Walk the live suite tree to find the subtree rooted at `selectedTestUid`
+ * and flatten its test entries into `PreservedStep[]` so the compare panel
+ * can treat live and baseline data uniformly.
+ *
+ * Returns `[]` when the selected UID isn't found in any chunk (e.g. when the
+ * user navigated to a stale UID that's no longer in the dashboard tree).
+ */
+function findSuiteByUid(
+  s: SuiteStatsFragment | undefined,
+  uid: string
+): SuiteStatsFragment | undefined {
+  if (!s) {
+    return undefined
+  }
+  if (s.uid === uid) {
+    return s
+  }
+  for (const child of s.suites ?? []) {
+    const hit = findSuiteByUid(child, uid)
+    if (hit) {
+      return hit
+    }
+  }
+  return undefined
+}
+
+function flattenSuiteTests(s: SuiteStatsFragment, out: PreservedStep[]): void {
+  for (const t of s.tests ?? []) {
+    out.push({
+      uid: t.uid,
+      title: t.title,
+      fullTitle: t.fullTitle,
+      start: t.start ? new Date(t.start).getTime() : undefined,
+      end: t.end ? new Date(t.end).getTime() : undefined,
+      state: t.state === 'pending' || t.state === 'running' ? t.state : t.state,
+      error: t.error
+        ? {
+            message: t.error.message,
+            name: t.error.name,
+            stack: t.error.stack
+          }
+        : undefined
+    })
+  }
+  for (const child of s.suites ?? []) {
+    flattenSuiteTests(child, out)
+  }
+}
+
+export function liveStepsForUid(
+  selectedTestUid: string | undefined,
+  liveSuites: Array<Record<string, SuiteStatsFragment | undefined>> | undefined
+): PreservedStep[] {
+  if (!selectedTestUid || !liveSuites) {
+    return []
+  }
+  let foundRoot: SuiteStatsFragment | undefined
+  for (const chunk of liveSuites) {
+    for (const root of Object.values(chunk)) {
+      foundRoot = findSuiteByUid(root, selectedTestUid)
+      if (foundRoot) {
+        break
+      }
+    }
+    if (foundRoot) {
+      break
+    }
+  }
+  if (!foundRoot) {
+    return []
+  }
+  const out: PreservedStep[] = []
+  flattenSuiteTests(foundRoot, out)
+  return out
+}
+
+/**
+ * Find which preserved step a command belongs to, by timestamp containment.
+ * The `side` selects whether to search the baseline's preserved steps or the
+ * live (selected-uid) steps.
+ */
+export function findStepFor(
+  cmd: CommandLog | undefined,
+  side: 'baseline' | 'latest',
+  baseline: PreservedAttempt | undefined,
+  liveSteps: PreservedStep[]
+): PreservedStep | undefined {
+  if (!cmd?.timestamp) {
+    return undefined
+  }
+  const steps = side === 'baseline' ? (baseline?.steps ?? []) : liveSteps
+  const ts = cmd.timestamp
+  return steps.find(
+    (s) =>
+      s.start !== null &&
+      s.start !== undefined &&
+      s.end !== null &&
+      s.end !== undefined &&
+      ts >= s.start &&
+      ts <= s.end
+  )
+}
+
+/**
+ * Pre-computed data for one side of a detail-block render. Pulling this out
+ * of compare.ts's `#renderDetailBlock` lets the template stay focused on
+ * markup and lets the computation be tested in isolation.
+ */
+export interface DetailBlockData {
+  argsStr: string
+  resultStr: string
+  step: PreservedStep | undefined
+  atFailureSite: boolean
+  expected: unknown
+  actual: unknown
+  assertionMessage: string | undefined
+  fallbackExpected: string | undefined
+  stepText: string
+}
+
+export function computeDetailBlockData(
+  cmd: CommandLog,
+  step: PreservedStep | undefined,
+  allCommandsOnSide: CommandLog[]
+): DetailBlockData {
+  const atFailureSite = isFailureSite(cmd, step, allCommandsOnSide)
+  const expected =
+    atFailureSite && step?.error?.expected !== undefined
+      ? step.error.expected
+      : atFailureSite
+        ? step?.error?.matcherResult?.expected
+        : undefined
+  const actual =
+    atFailureSite && step?.error?.actual !== undefined
+      ? step.error.actual
+      : atFailureSite
+        ? step?.error?.matcherResult?.actual
+        : undefined
+  const rawAssertion = atFailureSite
+    ? step?.error?.matcherResult?.message || step?.error?.message
+    : undefined
+  const assertionMessage = rawAssertion
+    ? cleanErrorMessage(rawAssertion)
+    : undefined
+  const stepText = step?.fullTitle || step?.title || ''
+  // Fallback: extract the expected from the Cucumber step text when the
+  // assertion library didn't surface a structured expected value.
+  const fallbackExpected =
+    atFailureSite && expected === undefined && step?.state === 'failed'
+      ? extractExpectedFromStepText(stepText)
+      : undefined
+
+  return {
+    argsStr: safeJson(cmd.args),
+    resultStr: safeJson(cmd.result),
+    step,
+    atFailureSite,
+    expected,
+    actual,
+    assertionMessage,
+    fallbackExpected,
+    stepText
+  }
+}
+
+/**
+ * Identify the "failure site" of a failed step — either the command whose own
+ * `error` is set (the WebDriver-level failure) OR the last command before the
+ * step's end time (the assertion site, where the matcher threw).
+ */
+export function isFailureSite(
+  cmd: CommandLog,
+  step: PreservedStep | undefined,
+  allCommandsOnSide: CommandLog[]
+): boolean {
+  if (!step || step.state !== 'failed') {
+    return false
+  }
+  if (cmd.error?.message) {
+    return true
+  }
+  if (step.start === null || step.end === null) {
+    return false
+  }
+  let lastTs = 0
+  for (const c of allCommandsOnSide) {
+    if (
+      c.timestamp !== null &&
+      step.start !== undefined &&
+      step.end !== undefined &&
+      c.timestamp >= step.start &&
+      c.timestamp <= step.end &&
+      c.timestamp > lastTs
+    ) {
+      lastTs = c.timestamp
+    }
+  }
+  return cmd.timestamp === lastTs
+}
diff --git a/packages/app/src/components/workbench/compare/styles.ts b/packages/app/src/components/workbench/compare/styles.ts
new file mode 100644
index 00000000..3b8cadc8
--- /dev/null
+++ b/packages/app/src/components/workbench/compare/styles.ts
@@ -0,0 +1,205 @@
+import { css } from 'lit'
+
+/** Component styles for `<wdio-devtools-compare>`. Pulled out of compare.ts
+ *  so the main component file stays focused on data and render logic. */
+export const compareStyles = css`
+  :host {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    height: 100%;
+    min-height: 0;
+    overflow: hidden;
+    /* Needed so popout mode (where Compare sits directly under body) is themed. */
+    background-color: var(--vscode-editor-background, #1e1e1e);
+    color: var(--vscode-foreground, #cccccc);
+  }
+  .compare-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0;
+    flex: 1 1 auto;
+    min-height: 0;
+    overflow: auto;
+    /* Stack rows from the top so they don't stretch to fill the grid. */
+    align-content: start;
+    grid-auto-rows: min-content;
+  }
+  .step-row {
+    display: contents;
+  }
+  .step-cell {
+    padding: 0.25rem 0.5rem;
+    border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
+    font-family: var(--vscode-editor-font-family, monospace);
+    font-size: 0.85em;
+    cursor: pointer;
+  }
+  .step-cell.divergent {
+    background: rgba(255, 90, 90, 0.08);
+  }
+  .step-cell.divergent.first {
+    background: rgba(255, 90, 90, 0.18);
+    border-left: 3px solid var(--vscode-charts-red, #f48771);
+  }
+  .marker {
+    margin-left: 0.35rem;
+    font-size: 0.85em;
+  }
+  .marker.result {
+    color: var(--vscode-charts-orange, #d19a66);
+  }
+  .marker.error {
+    color: var(--vscode-charts-red, #f48771);
+  }
+  .marker.command {
+    color: var(--vscode-charts-red, #f48771);
+  }
+  .marker.ok {
+    color: var(--vscode-charts-green, #73c373);
+  }
+  .marker.info {
+    color: var(--vscode-descriptionForeground, #999);
+    opacity: 0.7;
+  }
+  .error-banner {
+    margin: 0.5rem 0.75rem;
+    padding: 0.5rem 0.75rem;
+    background: rgba(244, 135, 113, 0.12);
+    border-left: 3px solid var(--vscode-charts-red, #f48771);
+    border-radius: 3px;
+    font-size: 0.85em;
+  }
+  .error-banner-title {
+    font-weight: 600;
+    margin-bottom: 0.25rem;
+    opacity: 0.85;
+    font-family: inherit;
+  }
+  /* Pre-wrap only on the message body so template indentation doesn't render. */
+  .error-banner-message {
+    font-family: var(--vscode-editor-font-family, monospace);
+    white-space: pre-wrap;
+    word-break: break-word;
+    margin: 0;
+  }
+  .step-cell.missing {
+    opacity: 0.35;
+    font-style: italic;
+  }
+  .step-cell:hover {
+    background: var(
+      --vscode-toolbar-hoverBackground,
+      rgba(255, 255, 255, 0.06)
+    );
+  }
+  .step-cell.expanded {
+    background: rgba(80, 160, 255, 0.06);
+  }
+  .pill {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.1rem 0.5rem;
+    border-radius: 4px;
+    font-size: 0.85em;
+    background: var(--vscode-badge-background, #2a2a2a);
+  }
+  .pill.failed {
+    background: rgba(244, 135, 113, 0.2);
+    color: var(--vscode-charts-red, #f48771);
+  }
+  .pill.passed {
+    background: rgba(115, 195, 115, 0.2);
+    color: var(--vscode-charts-green, #73c373);
+  }
+  .topbar {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
+    flex: 0 0 auto;
+  }
+  .col-header {
+    position: sticky;
+    top: 0;
+    background: var(--vscode-editor-background, #1e1e1e);
+    z-index: 1;
+    padding: 0.5rem;
+    font-weight: 600;
+    font-size: 0.85em;
+    border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
+  }
+  .detail-panel {
+    grid-column: span 2;
+    background: var(--vscode-editor-background, #1e1e1e);
+    border-bottom: 1px solid var(--vscode-panel-border, #2a2a2a);
+    padding: 0.5rem;
+  }
+  .detail-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0.75rem;
+  }
+  .detail-block {
+    font-size: 0.85em;
+  }
+  .detail-block h4 {
+    font-size: 0.85em;
+    margin: 0 0 0.25rem;
+    opacity: 0.7;
+    font-weight: 600;
+  }
+  .detail-block pre {
+    margin: 0;
+    white-space: pre-wrap;
+    word-break: break-word;
+    font-size: 0.85em;
+    background: rgba(255, 255, 255, 0.03);
+    padding: 0.25rem 0.4rem;
+    border-radius: 3px;
+  }
+  .empty-state {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--vscode-descriptionForeground, #888);
+    font-size: 0.9em;
+    text-align: center;
+    padding: 1rem;
+  }
+  .toggle-label {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35rem;
+    cursor: pointer;
+    font-size: 0.85em;
+  }
+  button.action {
+    background: transparent;
+    border: 1px solid var(--vscode-panel-border, #2a2a2a);
+    color: inherit;
+    padding: 0.2rem 0.5rem;
+    border-radius: 3px;
+    cursor: pointer;
+    font-size: 0.85em;
+  }
+  button.action:hover {
+    background: var(
+      --vscode-toolbar-hoverBackground,
+      rgba(255, 255, 255, 0.06)
+    );
+  }
+  button.action.icon-only {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0.25rem 0.4rem;
+  }
+  button.action.icon-only svg {
+    width: 1em;
+    height: 1em;
+  }
+`
diff --git a/packages/app/src/components/workbench/console.ts b/packages/app/src/components/workbench/console.ts
index 3494f387..09d451a6 100644
--- a/packages/app/src/components/workbench/console.ts
+++ b/packages/app/src/components/workbench/console.ts
@@ -164,7 +164,7 @@ export class DevtoolsConsoleLogs extends Element {
     return `${elapsed.toFixed(1)}s`
   }
 
-  #formatArgs(args: any[]): string {
+  #formatArgs(args: unknown): string {
     if (Array.isArray(args)) {
       return args
         .map((arg) => {
@@ -182,58 +182,53 @@ export class DevtoolsConsoleLogs extends Element {
     return String(args)
   }
 
-  render() {
-    if (!this.logs || this.logs.length === 0) {
-      return html`
-        <div class="empty-state">
-          <div class="empty-state-icon">📋</div>
-          <div class="empty-state-text">No console logs captured yet</div>
-        </div>
-      `
-    }
+  #renderEmptyState() {
+    return html`
+      <div class="empty-state">
+        <div class="empty-state-icon">📋</div>
+        <div class="empty-state-text">No console logs captured yet</div>
+      </div>
+    `
+  }
 
-    if (this.logs.length === 0) {
-      return html`
-        <div class="empty-state">
-          <div class="empty-state-icon">📋</div>
-          <div class="empty-state-text">No console logs captured yet</div>
+  #renderLogEntry(log: ConsoleLogs) {
+    const icon = LOG_ICONS[log.type] || LOG_ICONS.log
+    const sourceLabel =
+      log.source === 'test'
+        ? '[TEST]'
+        : log.source === 'terminal'
+          ? '[WDIO]'
+          : log.source === 'browser'
+            ? '[BROWSER]'
+            : ''
+    const sourceClass = log.source ? `source-${log.source}` : ''
+    return html`
+      <div class="log-entry log-type-${log.type || 'log'}">
+        ${log.timestamp
+          ? html`<div class="log-time">
+              ${this.#formatElapsedTime(log.timestamp)}
+            </div>`
+          : nothing}
+        <div class="log-icon">${icon}</div>
+        <div class="log-content">
+          ${sourceLabel
+            ? html`<span class="log-prefix ${sourceClass}"
+                >${sourceLabel}</span
+              >`
+            : nothing}
+          <span class="log-message">${this.#formatArgs(log.args)}</span>
         </div>
-      `
-    }
+      </div>
+    `
+  }
 
+  render() {
+    if (!this.logs || this.logs.length === 0) {
+      return this.#renderEmptyState()
+    }
     return html`
       <div class="console-container">
-        ${this.logs.map((log: any) => {
-          const icon = LOG_ICONS[log.type] || LOG_ICONS.log
-          const sourceLabel =
-            log.source === 'test'
-              ? '[TEST]'
-              : log.source === 'terminal'
-                ? '[WDIO]'
-                : log.source === 'browser'
-                  ? '[BROWSER]'
-                  : ''
-          const sourceClass = log.source ? `source-${log.source}` : ''
-
-          return html`
-            <div class="log-entry log-type-${log.type || 'log'}">
-              ${log.timestamp
-                ? html`<div class="log-time">
-                    ${this.#formatElapsedTime(log.timestamp)}
-                  </div>`
-                : nothing}
-              <div class="log-icon">${icon}</div>
-              <div class="log-content">
-                ${sourceLabel
-                  ? html`<span class="log-prefix ${sourceClass}"
-                      >${sourceLabel}</span
-                    >`
-                  : nothing}
-                <span class="log-message">${this.#formatArgs(log.args)}</span>
-              </div>
-            </div>
-          `
-        })}
+        ${this.logs.map((log) => this.#renderLogEntry(log))}
       </div>
     `
   }
diff --git a/packages/app/src/components/workbench/list.ts b/packages/app/src/components/workbench/list.ts
index 54825f95..5fc0b995 100644
--- a/packages/app/src/components/workbench/list.ts
+++ b/packages/app/src/components/workbench/list.ts
@@ -64,7 +64,7 @@ export class DevtoolsList extends Element {
     `
   ]
 
-  #renderMetadataProp(prop: any) {
+  #renderMetadataProp(prop: unknown) {
     if (typeof prop === 'object' && prop !== null) {
       return html`<pre>${JSON.stringify(prop, null, 2)}</pre>`
     }
@@ -94,10 +94,53 @@ export class DevtoolsList extends Element {
     `
   }
 
+  #unpackEntry(
+    entry: unknown,
+    isArrayList: boolean
+  ): { key: string | undefined; val: unknown } {
+    const isKeyValueTuple = (v: unknown): v is [string, unknown] =>
+      Array.isArray(v) && v.length === 2 && typeof v[0] === 'string'
+    if (isArrayList) {
+      if (isKeyValueTuple(entry)) {
+        return { key: entry[0], val: entry[1] }
+      }
+      return { key: undefined, val: entry }
+    }
+    const tuple = entry as [string, unknown]
+    return { key: tuple[0], val: tuple[1] }
+  }
+
+  #renderRow(entry: unknown, isArrayList: boolean) {
+    const { key, val } = this.#unpackEntry(entry, isArrayList)
+    const stringForMeasure =
+      val && typeof val === 'object'
+        ? JSON.stringify(val, null, 2)
+        : String(val)
+    const isMultiline =
+      /\n/.test(stringForMeasure) ||
+      stringForMeasure.length > 40 ||
+      (val && typeof val === 'object')
+    const baseCls = 'row px-2 py-1 border-b-[1px] border-b-panelBorder'
+    const colCls = isMultiline ? 'basis-full w-full' : 'basis-1/2'
+    const collapsedCls = this.isCollapsed ? 'collapse' : 'max-h-[500px]'
+    if (key === undefined) {
+      return html`
+        <dd class="${baseCls} ${colCls} ${collapsedCls}">
+          ${this.#renderMetadataProp(val)}
+        </dd>
+      `
+    }
+    return html`
+      <dt class="${baseCls} ${colCls} ${collapsedCls}">${key}</dt>
+      <dd class="${baseCls} ${colCls} ${collapsedCls}">
+        ${this.#renderMetadataProp(val)}
+      </dd>
+    `
+  }
+
   render() {
     const list = this.list ?? {}
     const isArrayList = Array.isArray(list)
-
     if (list === null) {
       return null
     }
@@ -110,63 +153,14 @@ export class DevtoolsList extends Element {
     ) {
       return null
     }
-
-    const entries: unknown[] | [string, unknown][] = isArrayList
+    const entries: unknown[] = isArrayList
       ? (this.list as unknown[])
       : Object.entries(this.list as Record<string, unknown>)
-
-    const isKeyValueTuple = (val: unknown): val is [string, unknown] =>
-      Array.isArray(val) && val.length === 2 && typeof val[0] === 'string'
-
     return html`
       <section class="block">
         ${this.#renderSectionHeader(this.label)}
         <dl class="flex flex-wrap ${this.isCollapsed ? '' : 'mt-2'}">
-          ${(entries as any[]).map((entry) => {
-            let key: string | undefined
-            let val: unknown
-
-            if (isArrayList) {
-              if (isKeyValueTuple(entry)) {
-                key = entry[0]
-                val = entry[1]
-              } else {
-                val = entry
-              }
-            } else {
-              key = (entry as [string, unknown])[0]
-              val = (entry as [string, unknown])[1]
-            }
-
-            const stringForMeasure =
-              val && typeof val === 'object'
-                ? JSON.stringify(val, null, 2)
-                : String(val)
-
-            const isMultiline =
-              /\n/.test(stringForMeasure) ||
-              stringForMeasure.length > 40 ||
-              (val && typeof val === 'object')
-
-            const baseCls = 'row px-2 py-1 border-b-[1px] border-b-panelBorder'
-            const colCls = isMultiline ? 'basis-full w-full' : 'basis-1/2'
-            const collapsedCls = this.isCollapsed ? 'collapse' : 'max-h-[500px]'
-
-            if (key === undefined) {
-              return html`
-                <dd class="${baseCls} ${colCls} ${collapsedCls}">
-                  ${this.#renderMetadataProp(val)}
-                </dd>
-              `
-            }
-
-            return html`
-              <dt class="${baseCls} ${colCls} ${collapsedCls}">${key}</dt>
-              <dd class="${baseCls} ${colCls} ${collapsedCls}">
-                ${this.#renderMetadataProp(val)}
-              </dd>
-            `
-          })}
+          ${entries.map((entry) => this.#renderRow(entry, isArrayList))}
         </dl>
       </section>
     `
diff --git a/packages/app/src/components/workbench/logs.ts b/packages/app/src/components/workbench/logs.ts
index 0000450a..674082ce 100644
--- a/packages/app/src/components/workbench/logs.ts
+++ b/packages/app/src/components/workbench/logs.ts
@@ -2,7 +2,7 @@ import { Element } from '@core/element'
 import { html, css } from 'lit'
 import { customElement, property } from 'lit/decorators.js'
 
-import type { CommandLog } from '@wdio/devtools-service/types'
+import type { CommandLog } from '@wdio/devtools-shared'
 import type { CommandEndpoint } from '@wdio/protocols'
 
 import './list.js'
@@ -76,6 +76,35 @@ export class DevtoolsCommandLogs extends Element {
     })
   }
 
+  #renderParameters() {
+    const args = this.command!.args || []
+    const params = args.reduce(
+      (acc: Record<string, unknown>, val: unknown, i: number) => {
+        const paramName = this.#commandDefinition?.parameters?.[i]?.name ?? i
+        acc[paramName] = val
+        return acc
+      },
+      {} as Record<string, unknown>
+    )
+    return html`<wdio-devtools-list
+      label="Parameters"
+      class="text-xs"
+      .list="${params}"
+    ></wdio-devtools-list>`
+  }
+
+  #renderResult() {
+    const result = this.command!.result
+    if (result === null || result === undefined) {
+      return ''
+    }
+    return html`<wdio-devtools-list
+      label="Result"
+      class="text-xs"
+      .list="${typeof result === 'object' ? result : [result]}"
+    ></wdio-devtools-list>`
+  }
+
   render() {
     if (!this.command) {
       return html`
@@ -84,7 +113,6 @@ export class DevtoolsCommandLogs extends Element {
         </section>
       `
     }
-
     return html`
       <section
         class="flex flex-column border-b-[1px] border-b-panelBorder px-2 py-1"
@@ -107,28 +135,7 @@ export class DevtoolsCommandLogs extends Element {
         >
         </wdio-devtools-list>
       `}
-      <wdio-devtools-list
-        label="Parameters"
-        class="text-xs"
-        .list="${(this.command.args || []).reduce(
-          (acc: Record<string, unknown>, val: unknown, i: number) => {
-            const def = this.#commandDefinition
-            const paramName = def?.parameters?.[i]?.name ?? i
-            acc[paramName] = val
-            return acc
-          },
-          {} as Record<string, unknown>
-        )}"
-      ></wdio-devtools-list>
-      ${this.command.result !== null && this.command.result !== undefined
-        ? html`<wdio-devtools-list
-            label="Result"
-            class="text-xs"
-            .list="${typeof this.command.result === 'object'
-              ? this.command.result
-              : [this.command.result]}"
-          ></wdio-devtools-list>`
-        : ''}
+      ${this.#renderParameters()} ${this.#renderResult()}
     `
   }
 }
diff --git a/packages/app/src/components/workbench/metadata.ts b/packages/app/src/components/workbench/metadata.ts
index bdf2c01a..75a0553f 100644
--- a/packages/app/src/components/workbench/metadata.ts
+++ b/packages/app/src/components/workbench/metadata.ts
@@ -3,7 +3,7 @@ import { html, css } from 'lit'
 import { customElement } from 'lit/decorators.js'
 import { consume } from '@lit/context'
 
-import type { Metadata } from '@wdio/devtools-service/types'
+import type { Metadata } from '@wdio/devtools-shared'
 import { metadataContext } from '../../controller/context.js'
 
 import './list.js'
@@ -29,12 +29,7 @@ export class DevtoolsMetadata extends Element {
     `
   ]
 
-  render() {
-    if (!this.metadata) {
-      return html`<wdio-devtools-placeholder></wdio-devtools-placeholder>`
-    }
-
-    const m = this.metadata as any
+  #buildSessionInfo(m: MetadataShape): Record<string, unknown> {
     const sessionInfo: Record<string, unknown> = {}
     if (m.sessionId) {
       sessionInfo['Session ID'] = m.sessionId
@@ -51,37 +46,49 @@ export class DevtoolsMetadata extends Element {
     if (m.url) {
       sessionInfo.URL = m.url
     }
+    return sessionInfo
+  }
 
-    const caps = m.capabilities || {}
-    const desiredCaps = m.desiredCapabilities || {}
+  #renderListIfNonEmpty(label: string, list: Record<string, unknown>) {
+    return Object.keys(list).length
+      ? html`<wdio-devtools-list
+          label="${label}"
+          .list="${list}"
+        ></wdio-devtools-list>`
+      : ''
+  }
 
+  render() {
+    if (!this.metadata) {
+      return html`<wdio-devtools-placeholder></wdio-devtools-placeholder>`
+    }
+    const m = this.metadata as MetadataShape
     return html`
-      ${Object.keys(sessionInfo).length
-        ? html`<wdio-devtools-list
-            label="Session"
-            .list="${sessionInfo}"
-          ></wdio-devtools-list>`
-        : ''}
+      ${this.#renderListIfNonEmpty('Session', this.#buildSessionInfo(m))}
       <wdio-devtools-list
         label="Capabilities"
-        .list="${caps}"
+        .list="${m.capabilities || {}}"
       ></wdio-devtools-list>
-      ${Object.keys(desiredCaps).length
-        ? html`<wdio-devtools-list
-            label="Desired Capabilities"
-            .list="${desiredCaps}"
-          ></wdio-devtools-list>`
-        : ''}
-      ${m.options && Object.keys(m.options).length
-        ? html`<wdio-devtools-list
-            label="Options"
-            .list="${m.options}"
-          ></wdio-devtools-list>`
-        : ''}
+      ${this.#renderListIfNonEmpty(
+        'Desired Capabilities',
+        m.desiredCapabilities || {}
+      )}
+      ${this.#renderListIfNonEmpty('Options', m.options || {})}
     `
   }
 }
 
+interface MetadataShape {
+  sessionId?: string
+  testEnv?: string
+  host?: string
+  modulePath?: string
+  url?: string
+  capabilities?: Record<string, unknown>
+  desiredCapabilities?: Record<string, unknown>
+  options?: Record<string, unknown>
+}
+
 declare global {
   interface HTMLElementTagNameMap {
     [SOURCE_COMPONENT]: DevtoolsMetadata
diff --git a/packages/app/src/components/workbench/network.ts b/packages/app/src/components/workbench/network.ts
index e58154cd..9fe9aa6b 100644
--- a/packages/app/src/components/workbench/network.ts
+++ b/packages/app/src/components/workbench/network.ts
@@ -1,5 +1,6 @@
 import { Element } from '@core/element'
-import { html, css, nothing } from 'lit'
+import { html, nothing } from 'lit'
+import { networkStyles } from './network/styles.js'
 import { customElement, state } from 'lit/decorators.js'
 import { consume } from '@lit/context'
 import { networkRequestContext } from '../../controller/context.js'
@@ -64,205 +65,7 @@ export class DevtoolsNetwork extends Element {
     }
   }
 
-  static styles = [
-    ...Element.styles,
-    css`
-      :host {
-        display: flex;
-        flex-direction: column;
-        height: 100%;
-        width: 100%;
-        overflow: hidden;
-        color: var(--vscode-foreground);
-        background-color: var(--vscode-editor-background);
-      }
-
-      .network-header {
-        padding: 0.5rem 1rem;
-        border-bottom: 1px solid var(--vscode-panel-border);
-        display: flex;
-        gap: 0.5rem;
-        align-items: center;
-        flex-shrink: 0;
-      }
-
-      .search-input {
-        padding: 0.375rem 0.75rem;
-        border: 1px solid var(--vscode-panel-border);
-        background: var(--vscode-input-background);
-        color: var(--vscode-input-foreground);
-        border-radius: 4px;
-        font-size: 0.875rem;
-        min-width: 200px;
-      }
-
-      .search-input:focus {
-        outline: none;
-        border-color: var(--vscode-focusBorder);
-      }
-
-      .filter-tabs {
-        display: flex;
-        gap: 0.25rem;
-        margin-left: 1rem;
-      }
-
-      .filter-tab {
-        padding: 0.375rem 0.75rem;
-        border: none;
-        background: transparent;
-        color: var(--vscode-foreground);
-        cursor: pointer;
-        font-size: 0.875rem;
-        transition: all 0.15s;
-        border-bottom: 2px solid transparent;
-      }
-
-      .filter-tab:hover {
-        background: var(--vscode-toolbar-hoverBackground);
-      }
-
-      .filter-tab.active {
-        color: var(--vscode-textLink-activeForeground);
-        border-bottom-color: var(--vscode-textLink-activeForeground);
-      }
-
-      .network-content {
-        display: flex;
-        flex: 1;
-        overflow: hidden;
-      }
-
-      .requests-list {
-        flex: 1;
-        overflow-y: auto;
-        overflow-x: auto;
-        border-right: 1px solid var(--vscode-panel-border);
-        min-width: 0;
-      }
-
-      .requests-header {
-        display: grid;
-        grid-template-columns: 200px 80px 70px 180px 90px 80px 90px;
-        min-width: 790px;
-        border-bottom: 1px solid var(--vscode-panel-border);
-        font-size: 0.75rem;
-        font-weight: 600;
-        color: var(--vscode-descriptionForeground);
-        position: sticky;
-        top: 0;
-        background: var(--vscode-editor-background);
-        z-index: 1;
-      }
-
-      .requests-header > div {
-        padding: 0.5rem;
-        border-right: 1px solid var(--vscode-panel-border);
-        overflow: hidden;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-      }
-
-      .requests-header > div:last-child {
-        border-right: none;
-      }
-
-      .request-row {
-        display: grid;
-        grid-template-columns: 200px 80px 70px 180px 90px 80px 90px;
-        min-width: 790px;
-        border-bottom: 1px solid var(--vscode-panel-border);
-        cursor: pointer;
-        font-size: 0.875rem;
-        transition: background 0.15s;
-        align-items: center;
-      }
-
-      .request-row > span {
-        padding: 0.5rem;
-        border-right: 1px solid var(--vscode-panel-border);
-        overflow: hidden;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-      }
-
-      .request-row > span:last-child {
-        border-right: none;
-      }
-
-      .request-row:hover {
-        background: var(--vscode-list-hoverBackground);
-      }
-
-      .request-row.selected {
-        background: var(--vscode-list-activeSelectionBackground);
-        color: var(--vscode-list-activeSelectionForeground);
-      }
-
-      .request-row.error {
-        color: var(--vscode-errorForeground);
-      }
-
-      .request-detail {
-        flex: 1;
-        overflow-y: auto;
-        padding: 1rem;
-        min-width: 400px;
-      }
-
-      .detail-section {
-        margin-bottom: 1.5rem;
-      }
-
-      .detail-title {
-        font-size: 0.875rem;
-        font-weight: 600;
-        margin-bottom: 0.5rem;
-        color: var(--vscode-foreground);
-      }
-
-      .detail-content {
-        background: var(--vscode-editor-background);
-        padding: 0.75rem;
-        border-radius: 4px;
-        border: 1px solid var(--vscode-panel-border);
-        font-family: monospace;
-        font-size: 0.75rem;
-        overflow-x: auto;
-      }
-
-      .header-row {
-        display: flex;
-        gap: 1rem;
-        padding: 0.25rem 0;
-        border-bottom: 1px solid var(--vscode-panel-border);
-      }
-
-      .header-key {
-        font-weight: 600;
-        color: var(--vscode-symbolIcon-keyForeground);
-        flex-shrink: 0;
-        min-width: 80px;
-      }
-
-      .header-value {
-        color: var(--vscode-symbolIcon-stringForeground);
-        word-break: break-word;
-        flex: 1;
-        text-align: right;
-      }
-
-      .truncate {
-        overflow: hidden;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-      }
-
-      .text-muted {
-        color: var(--vscode-descriptionForeground);
-      }
-    `
-  ]
+  static styles = [...Element.styles, networkStyles]
 
   #filterRequests(): NetworkRequest[] {
     let filtered = this.networkRequests
@@ -293,19 +96,7 @@ export class DevtoolsNetwork extends Element {
     this.selectedRequest = request
   }
 
-  render() {
-    const filteredRequests = this.#filterRequests()
-
-    if (!this.networkRequests || this.networkRequests.length === 0) {
-      return html`
-        <wdio-devtools-placeholder
-          icon="network"
-          title="No network requests captured"
-          description="Network requests will appear here as your tests run"
-        ></wdio-devtools-placeholder>
-      `
-    }
-
+  #renderNetworkHeader() {
     return html`
       <div class="network-header">
         <input
@@ -329,6 +120,50 @@ export class DevtoolsNetwork extends Element {
           )}
         </div>
       </div>
+    `
+  }
+
+  #renderRequestRow(request: NetworkRequest) {
+    return html`
+      <div
+        class="request-row ${this.selectedRequest?.id === request.id
+          ? 'selected'
+          : ''} ${request.error ? 'error' : ''}"
+        @click="${() => this.#selectRequest(request)}"
+      >
+        <span class="truncate" title="${request.url}"
+          >${getFileName(request.url)}</span
+        >
+        <span>${request.method}</span>
+        <span class="${getStatusClass(request.status)}"
+          >${request.status || (request.error ? 'ERR' : '-')}</span
+        >
+        <span class="truncate text-muted"
+          >${request.responseHeaders?.['content-type']?.split(';')[0] ||
+          '-'}</span
+        >
+        <span>${formatTime(request.time)}</span>
+        <span>${formatBytes(request.size)}</span>
+        <span class="text-muted"
+          >${request.startTime ? `${request.startTime.toFixed(1)}s` : '-'}</span
+        >
+      </div>
+    `
+  }
+
+  render() {
+    if (!this.networkRequests || this.networkRequests.length === 0) {
+      return html`
+        <wdio-devtools-placeholder
+          icon="network"
+          title="No network requests captured"
+          description="Network requests will appear here as your tests run"
+        ></wdio-devtools-placeholder>
+      `
+    }
+    const filteredRequests = this.#filterRequests()
+    return html`
+      ${this.#renderNetworkHeader()}
       <div class="network-content">
         <div class="requests-list">
           <div class="requests-header">
@@ -341,154 +176,94 @@ export class DevtoolsNetwork extends Element {
             <div>Start</div>
           </div>
           ${filteredRequests.length === 0
-            ? html`
-                <div class="p-4 text-center text-sm text-muted">
-                  No requests match your filter
-                </div>
-              `
-            : filteredRequests.map(
-                (request) => html`
-                  <div
-                    class="request-row ${this.selectedRequest?.id === request.id
-                      ? 'selected'
-                      : ''} ${request.error ? 'error' : ''}"
-                    @click="${() => this.#selectRequest(request)}"
-                  >
-                    <span class="truncate" title="${request.url}"
-                      >${getFileName(request.url)}</span
-                    >
-                    <span>${request.method}</span>
-                    <span class="${getStatusClass(request.status)}"
-                      >${request.status || (request.error ? 'ERR' : '-')}</span
-                    >
-                    <span class="truncate text-muted"
-                      >${request.responseHeaders?.['content-type']?.split(
-                        ';'
-                      )[0] || '-'}</span
-                    >
-                    <span>${formatTime(request.time)}</span>
-                    <span>${formatBytes(request.size)}</span>
-                    <span class="text-muted"
-                      >${request.startTime
-                        ? `${request.startTime.toFixed(1)}s`
-                        : '-'}</span
-                    >
-                  </div>
-                `
-              )}
+            ? html`<div class="p-4 text-center text-sm text-muted">
+                No requests match your filter
+              </div>`
+            : filteredRequests.map((r) => this.#renderRequestRow(r))}
         </div>
         ${this.selectedRequest ? this.#renderRequestDetail() : nothing}
       </div>
     `
   }
 
-  #renderRequestDetail() {
-    const req = this.selectedRequest!
+  #renderHeaderRow(key: string, value: unknown, valueClass = '') {
+    return html`
+      <div class="header-row">
+        <span class="header-key">${key}:</span>
+        <span class="header-value ${valueClass}">${value}</span>
+      </div>
+    `
+  }
 
+  #renderHeadersSection(
+    title: string,
+    headers: Record<string, string> | undefined
+  ) {
+    if (!headers || Object.keys(headers).length === 0) {
+      return nothing
+    }
     return html`
-      <div class="request-detail">
-        <div class="detail-section">
-          <div class="detail-title">General</div>
-          <div class="detail-content">
-            <div class="header-row">
-              <span class="header-key">URL:</span>
-              <span class="header-value">${req.url}</span>
-            </div>
-            <div class="header-row">
-              <span class="header-key">Method:</span>
-              <span class="header-value">${req.method}</span>
-            </div>
-            <div class="header-row">
-              <span class="header-key">Status:</span>
-              <span class="header-value ${getStatusClass(req.status)}"
-                >${req.status || '-'} ${req.statusText || ''}</span
-              >
-            </div>
-            <div class="header-row">
-              <span class="header-key">Type:</span>
-              <span class="header-value">${req.type}</span>
-            </div>
-            ${req.time
-              ? html`
-                  <div class="header-row">
-                    <span class="header-key">Time:</span>
-                    <span class="header-value">${formatTime(req.time)}</span>
-                  </div>
-                `
-              : nothing}
-            ${req.size
-              ? html`
-                  <div class="header-row">
-                    <span class="header-key">Size:</span>
-                    <span class="header-value">${formatBytes(req.size)}</span>
-                  </div>
-                `
-              : nothing}
-            ${req.error
-              ? html`
-                  <div class="header-row">
-                    <span class="header-key">Error:</span>
-                    <span class="header-value text-red-500">${req.error}</span>
-                  </div>
-                `
-              : nothing}
-          </div>
+      <div class="detail-section">
+        <div class="detail-title">${title}</div>
+        <div class="detail-content">
+          ${Object.entries(headers).map(([k, v]) =>
+            this.#renderHeaderRow(k, v)
+          )}
+        </div>
+      </div>
+    `
+  }
+
+  #renderBodySection(title: string, body: string | undefined) {
+    if (!body) {
+      return nothing
+    }
+    return html`
+      <div class="detail-section">
+        <div class="detail-title">${title}</div>
+        <div class="detail-content">
+          <pre>${this.#formatBody(body)}</pre>
         </div>
+      </div>
+    `
+  }
 
-        ${req.requestHeaders && Object.keys(req.requestHeaders).length > 0
-          ? html`
-              <div class="detail-section">
-                <div class="detail-title">Request Headers</div>
-                <div class="detail-content">
-                  ${Object.entries(req.requestHeaders).map(
-                    ([key, value]) => html`
-                      <div class="header-row">
-                        <span class="header-key">${key}:</span>
-                        <span class="header-value">${value}</span>
-                      </div>
-                    `
-                  )}
-                </div>
-              </div>
-            `
-          : nothing}
-        ${req.requestBody
-          ? html`
-              <div class="detail-section">
-                <div class="detail-title">Request Body</div>
-                <div class="detail-content">
-                  <pre>${this.#formatBody(req.requestBody)}</pre>
-                </div>
-              </div>
-            `
-          : nothing}
-        ${req.responseHeaders && Object.keys(req.responseHeaders).length > 0
-          ? html`
-              <div class="detail-section">
-                <div class="detail-title">Response Headers</div>
-                <div class="detail-content">
-                  ${Object.entries(req.responseHeaders).map(
-                    ([key, value]) => html`
-                      <div class="header-row">
-                        <span class="header-key">${key}:</span>
-                        <span class="header-value">${value}</span>
-                      </div>
-                    `
-                  )}
-                </div>
-              </div>
-            `
-          : nothing}
-        ${req.responseBody
-          ? html`
-              <div class="detail-section">
-                <div class="detail-title">Response Body</div>
-                <div class="detail-content">
-                  <pre>${this.#formatBody(req.responseBody)}</pre>
-                </div>
-              </div>
-            `
-          : nothing}
+  #renderGeneralSection(req: NetworkRequest) {
+    return html`
+      <div class="detail-section">
+        <div class="detail-title">General</div>
+        <div class="detail-content">
+          ${this.#renderHeaderRow('URL', req.url)}
+          ${this.#renderHeaderRow('Method', req.method)}
+          ${this.#renderHeaderRow(
+            'Status',
+            html`${req.status || '-'} ${req.statusText || ''}`,
+            getStatusClass(req.status)
+          )}
+          ${this.#renderHeaderRow('Type', req.type)}
+          ${req.time
+            ? this.#renderHeaderRow('Time', formatTime(req.time))
+            : nothing}
+          ${req.size
+            ? this.#renderHeaderRow('Size', formatBytes(req.size))
+            : nothing}
+          ${req.error
+            ? this.#renderHeaderRow('Error', req.error, 'text-red-500')
+            : nothing}
+        </div>
+      </div>
+    `
+  }
+
+  #renderRequestDetail() {
+    const req = this.selectedRequest!
+    return html`
+      <div class="request-detail">
+        ${this.#renderGeneralSection(req)}
+        ${this.#renderHeadersSection('Request Headers', req.requestHeaders)}
+        ${this.#renderBodySection('Request Body', req.requestBody)}
+        ${this.#renderHeadersSection('Response Headers', req.responseHeaders)}
+        ${this.#renderBodySection('Response Body', req.responseBody)}
       </div>
     `
   }
diff --git a/packages/app/src/components/workbench/network/styles.ts b/packages/app/src/components/workbench/network/styles.ts
new file mode 100644
index 00000000..17d039b5
--- /dev/null
+++ b/packages/app/src/components/workbench/network/styles.ts
@@ -0,0 +1,200 @@
+import { css } from 'lit'
+
+/** Component styles for `<wdio-devtools-network>`. Pulled out so the main
+ *  network component file stays focused on request filtering and rendering. */
+export const networkStyles = css`
+  :host {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    width: 100%;
+    overflow: hidden;
+    color: var(--vscode-foreground);
+    background-color: var(--vscode-editor-background);
+  }
+
+  .network-header {
+    padding: 0.5rem 1rem;
+    border-bottom: 1px solid var(--vscode-panel-border);
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+    flex-shrink: 0;
+  }
+
+  .search-input {
+    padding: 0.375rem 0.75rem;
+    border: 1px solid var(--vscode-panel-border);
+    background: var(--vscode-input-background);
+    color: var(--vscode-input-foreground);
+    border-radius: 4px;
+    font-size: 0.875rem;
+    min-width: 200px;
+  }
+
+  .search-input:focus {
+    outline: none;
+    border-color: var(--vscode-focusBorder);
+  }
+
+  .filter-tabs {
+    display: flex;
+    gap: 0.25rem;
+    margin-left: 1rem;
+  }
+
+  .filter-tab {
+    padding: 0.375rem 0.75rem;
+    border: none;
+    background: transparent;
+    color: var(--vscode-foreground);
+    cursor: pointer;
+    font-size: 0.875rem;
+    transition: all 0.15s;
+    border-bottom: 2px solid transparent;
+  }
+
+  .filter-tab:hover {
+    background: var(--vscode-toolbar-hoverBackground);
+  }
+
+  .filter-tab.active {
+    color: var(--vscode-textLink-activeForeground);
+    border-bottom-color: var(--vscode-textLink-activeForeground);
+  }
+
+  .network-content {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+  }
+
+  .requests-list {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: auto;
+    border-right: 1px solid var(--vscode-panel-border);
+    min-width: 0;
+  }
+
+  .requests-header {
+    display: grid;
+    grid-template-columns: 200px 80px 70px 180px 90px 80px 90px;
+    min-width: 790px;
+    border-bottom: 1px solid var(--vscode-panel-border);
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--vscode-descriptionForeground);
+    position: sticky;
+    top: 0;
+    background: var(--vscode-editor-background);
+    z-index: 1;
+  }
+
+  .requests-header > div {
+    padding: 0.5rem;
+    border-right: 1px solid var(--vscode-panel-border);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .requests-header > div:last-child {
+    border-right: none;
+  }
+
+  .request-row {
+    display: grid;
+    grid-template-columns: 200px 80px 70px 180px 90px 80px 90px;
+    min-width: 790px;
+    border-bottom: 1px solid var(--vscode-panel-border);
+    cursor: pointer;
+    font-size: 0.875rem;
+    transition: background 0.15s;
+    align-items: center;
+  }
+
+  .request-row > span {
+    padding: 0.5rem;
+    border-right: 1px solid var(--vscode-panel-border);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .request-row > span:last-child {
+    border-right: none;
+  }
+
+  .request-row:hover {
+    background: var(--vscode-list-hoverBackground);
+  }
+
+  .request-row.selected {
+    background: var(--vscode-list-activeSelectionBackground);
+    color: var(--vscode-list-activeSelectionForeground);
+  }
+
+  .request-row.error {
+    color: var(--vscode-errorForeground);
+  }
+
+  .request-detail {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem;
+    min-width: 400px;
+  }
+
+  .detail-section {
+    margin-bottom: 1.5rem;
+  }
+
+  .detail-title {
+    font-size: 0.875rem;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+    color: var(--vscode-foreground);
+  }
+
+  .detail-content {
+    background: var(--vscode-editor-background);
+    padding: 0.75rem;
+    border-radius: 4px;
+    border: 1px solid var(--vscode-panel-border);
+    font-family: monospace;
+    font-size: 0.75rem;
+    overflow-x: auto;
+  }
+
+  .header-row {
+    display: flex;
+    gap: 1rem;
+    padding: 0.25rem 0;
+    border-bottom: 1px solid var(--vscode-panel-border);
+  }
+
+  .header-key {
+    font-weight: 600;
+    color: var(--vscode-symbolIcon-keyForeground);
+    flex-shrink: 0;
+    min-width: 80px;
+  }
+
+  .header-value {
+    color: var(--vscode-symbolIcon-stringForeground);
+    word-break: break-word;
+    flex: 1;
+    text-align: right;
+  }
+
+  .truncate {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .text-muted {
+    color: var(--vscode-descriptionForeground);
+  }
+`
diff --git a/packages/app/src/controller/DataManager.ts b/packages/app/src/controller/DataManager.ts
index a147e9b4..4d59c0f6 100644
--- a/packages/app/src/controller/DataManager.ts
+++ b/packages/app/src/controller/DataManager.ts
@@ -5,7 +5,7 @@ import type {
   CommandLog,
   TraceLog,
   PreservedAttempt
-} from '@wdio/devtools-service/types'
+} from '@wdio/devtools-shared'
 
 import {
   mutationContext,
@@ -20,15 +20,18 @@ import {
   baselineContext,
   selectedTestUidContext
 } from './context.js'
-import { BASELINE_WS_SCOPE } from '../components/workbench/compare/constants.js'
+import { BASELINE_WS_SCOPE, WS_SCOPE } from '@wdio/devtools-shared'
 import { CACHE_ID } from './constants.js'
-import { getTimestamp } from '../utils/helpers.js'
 import { rerunState } from './rerunState.js'
-import type {
-  TestStatsFragment,
-  SuiteStatsFragment,
-  SocketMessage
-} from './types.js'
+import type { SuiteStatsFragment, SocketMessage } from './types.js'
+import { canonicalizeUids, mergeSuite } from './suite-merge.js'
+import {
+  markAllRunning,
+  markSpecificRunning,
+  markRunningAsStopped
+} from './mark-running.js'
+import { shouldResetForNewRun } from './run-detection.js'
+import { mergeNetworkRequests, replaceCommand } from './contextUpdates.js'
 
 export class DataManagerController implements ReactiveController {
   #ws?: WebSocket
@@ -163,133 +166,11 @@ export class DataManagerController implements ReactiveController {
 
   #markTestAsRunning(uid: string, entryType?: 'suite' | 'test') {
     const suites = this.suitesContextProvider.value || []
-
-    // If uid is '*', mark ALL tests/suites as running
-    if (uid === '*') {
-      const updatedSuites = suites.map((chunk) => {
-        const updatedChunk: Record<string, SuiteStatsFragment> = {}
-        Object.entries(chunk as Record<string, SuiteStatsFragment>).forEach(
-          ([suiteUid, suite]) => {
-            if (!suite) {
-              updatedChunk[suiteUid] = suite
-              return
-            }
-
-            const markAllAsRunning = (
-              s: SuiteStatsFragment
-            ): SuiteStatsFragment => {
-              return {
-                ...s,
-                state: 'running',
-                start: new Date(),
-                end: undefined,
-                // Clear leaf-level tests so stale step entries from a previous
-                // run don't linger when the feature file or test code changed
-                // between runs (e.g. Cucumber step text edited). The new run
-                // repopulates them. Child suites are preserved so the tree
-                // structure remains visible during the rerun.
-                tests: [] as TestStatsFragment[],
-                suites: s.suites?.map(markAllAsRunning) || []
-              }
-            }
-
-            updatedChunk[suiteUid] = markAllAsRunning(suite)
-          }
-        )
-        return updatedChunk
-      })
-      this.suitesContextProvider.setValue(updatedSuites)
-      this.#host.requestUpdate()
-      return
-    }
-
-    // Otherwise, mark specific test/suite as running
-    const updatedSuites = suites.map((chunk) => {
-      const updatedChunk: Record<string, SuiteStatsFragment> = {}
-      Object.entries(chunk as Record<string, SuiteStatsFragment>).forEach(
-        ([suiteUid, suite]) => {
-          if (!suite) {
-            updatedChunk[suiteUid] = suite
-            return
-          }
-
-          // Recursive helper to mark only the targeted branch as running
-          const markAsRunning = (
-            s: SuiteStatsFragment
-          ): { suite: SuiteStatsFragment; matched: boolean } => {
-            const runStart = new Date()
-
-            if (entryType !== 'test' && s.uid === uid) {
-              const markSuiteTreeAsRunning = (
-                suiteNode: SuiteStatsFragment
-              ): SuiteStatsFragment => ({
-                ...suiteNode,
-                state: 'running',
-                start: runStart,
-                end: undefined,
-                // Clear leaf-level tests on rerun so stale step entries from
-                // a previous run can't linger. See sibling markAllAsRunning.
-                tests: [] as TestStatsFragment[],
-                suites: suiteNode.suites?.map(markSuiteTreeAsRunning) || []
-              })
-
-              return {
-                matched: true,
-                suite: markSuiteTreeAsRunning(s)
-              }
-            }
-
-            let matched = false
-            const updatedTests = (s.tests?.map((test) => {
-              if (test.uid === uid) {
-                matched = true
-                return {
-                  ...test,
-                  state: 'pending',
-                  start: new Date(),
-                  end: undefined
-                }
-              }
-              return test
-            }) ?? []) as TestStatsFragment[]
-
-            const updatedNestedSuites =
-              s.suites?.map((nestedSuite) => {
-                const nestedResult = markAsRunning(nestedSuite)
-                if (nestedResult.matched) {
-                  matched = true
-                }
-                return nestedResult.suite
-              }) || []
-
-            return {
-              matched,
-              suite: {
-                ...s,
-                ...(matched
-                  ? {
-                      state: 'running' as const,
-                      // Don't reset the parent's start/end when it is already
-                      // running — subsequent child-scenario marks would otherwise
-                      // reset the feature's original run timestamp.
-                      ...(s.state !== 'running'
-                        ? { start: runStart, end: undefined }
-                        : {})
-                    }
-                  : {}),
-                tests: updatedTests || [],
-                suites: updatedNestedSuites
-              }
-            }
-          }
-
-          updatedChunk[suiteUid] = markAsRunning(suite).suite
-        }
-      )
-      return updatedChunk
-    })
-
-    this.suitesContextProvider.setValue(updatedSuites)
+    const updated =
+      uid === '*'
+        ? markAllRunning(suites)
+        : markSpecificRunning(suites, uid, entryType)
+    this.suitesContextProvider.setValue(updated)
     this.#host.requestUpdate()
   }
 
@@ -324,88 +205,93 @@ export class DataManagerController implements ReactiveController {
     }
   }
 
-  #handleSocketMessage(event: MessageEvent) {
-    try {
-      const { scope, data } = JSON.parse(event.data) as SocketMessage
-      if (!data) {
-        return
-      }
-
-      if (scope === 'testStopped') {
-        this.#handleTestStopped()
-        this.#host.requestUpdate()
-        return
-      }
-
-      if (scope === 'screencast') {
-        const { sessionId } = data as { sessionId: string }
-        window.dispatchEvent(
-          new CustomEvent('screencast-ready', { detail: { sessionId } })
-        )
-        return
-      }
+  #handleClearExecutionScope(data: unknown): void {
+    const { uid, entryType, clearSuiteTree } =
+      data as SocketMessage<'clearExecutionData'>['data']
+    this.clearExecutionData(uid, entryType)
+    if (clearSuiteTree) {
+      this.suitesContextProvider.setValue([])
+      this.#activeRerunTestUid = undefined
+      rerunState.activeRerunSuiteUid = undefined
+      this.#lastSeenRunTimestamp = 0
+    }
+  }
 
-      if (scope === 'clearExecutionData') {
-        const { uid, entryType, clearSuiteTree } =
-          data as SocketMessage<'clearExecutionData'>['data']
-        this.clearExecutionData(uid, entryType)
-        if (clearSuiteTree) {
-          this.suitesContextProvider.setValue([])
-          this.#activeRerunTestUid = undefined
-          rerunState.activeRerunSuiteUid = undefined
-          this.#lastSeenRunTimestamp = 0
-        }
-        this.#host.requestUpdate()
-        return
-      }
+  // Returns true if the control scope was fully handled and the regular
+  // dispatch should be skipped. Caller is responsible for requestUpdate().
+  #handleControlScope(scope: string, data: unknown): boolean {
+    if (scope === WS_SCOPE.testStopped) {
+      this.#handleTestStopped()
+      return true
+    }
+    if (scope === 'screencast') {
+      const { sessionId } = data as { sessionId: string }
+      window.dispatchEvent(
+        new CustomEvent('screencast-ready', { detail: { sessionId } })
+      )
+      return true
+    }
+    if (scope === WS_SCOPE.clearExecutionData) {
+      this.#handleClearExecutionScope(data)
+      return true
+    }
+    if (scope === WS_SCOPE.replaceCommand) {
+      const { oldTimestamp, command } =
+        data as SocketMessage<'replaceCommand'>['data']
+      this.#handleReplaceCommand(oldTimestamp, command)
+      return true
+    }
+    if (scope === BASELINE_WS_SCOPE.saved) {
+      const { testUid, attempt } = data as SocketMessage<
+        typeof BASELINE_WS_SCOPE.saved
+      >['data']
+      this.#handleBaselineSaved(testUid, attempt)
+      return true
+    }
+    if (scope === BASELINE_WS_SCOPE.cleared) {
+      const { testUid } = data as SocketMessage<
+        typeof BASELINE_WS_SCOPE.cleared
+      >['data']
+      this.#handleBaselineCleared(testUid)
+      return true
+    }
+    return false
+  }
 
-      if (scope === 'replaceCommand') {
-        const { oldTimestamp, command } =
-          data as SocketMessage<'replaceCommand'>['data']
-        this.#handleReplaceCommand(oldTimestamp, command)
-        this.#host.requestUpdate()
-        return
+  #dispatchDataScope(scope: string, data: unknown): void {
+    if (scope === 'mutations') {
+      this.#handleMutationsUpdate(data as TraceMutation[])
+    } else if (scope === 'logs') {
+      this.#handleLogsUpdate(data as string[])
+    } else if (scope === 'commands') {
+      this.#handleCommandsUpdate(data as CommandLog[])
+    } else if (scope === 'metadata') {
+      this.#handleMetadataUpdate(data as Metadata)
+    } else if (scope === 'consoleLogs') {
+      this.#handleConsoleLogsUpdate(data as string[])
+    } else if (scope === 'networkRequests') {
+      this.#handleNetworkRequestsUpdate(data as NetworkRequest[])
+    } else if (scope === 'sources') {
+      this.#handleSourcesUpdate(data as Record<string, string>)
+    } else if (scope === 'suites') {
+      if (this.#shouldResetForNewRun(data)) {
+        this.#resetExecutionData()
       }
+      this.#handleSuitesUpdate(data)
+    }
+  }
 
-      if (scope === BASELINE_WS_SCOPE.saved) {
-        const { testUid, attempt } = data as SocketMessage<
-          typeof BASELINE_WS_SCOPE.saved
-        >['data']
-        this.#handleBaselineSaved(testUid, attempt)
-        this.#host.requestUpdate()
+  #handleSocketMessage(event: MessageEvent) {
+    try {
+      const { scope, data } = JSON.parse(event.data) as SocketMessage
+      if (!data) {
         return
       }
-
-      if (scope === BASELINE_WS_SCOPE.cleared) {
-        const { testUid } = data as SocketMessage<
-          typeof BASELINE_WS_SCOPE.cleared
-        >['data']
-        this.#handleBaselineCleared(testUid)
+      if (this.#handleControlScope(scope, data)) {
         this.#host.requestUpdate()
         return
       }
-
-      if (scope === 'mutations') {
-        this.#handleMutationsUpdate(data as TraceMutation[])
-      } else if (scope === 'logs') {
-        this.#handleLogsUpdate(data as string[])
-      } else if (scope === 'commands') {
-        this.#handleCommandsUpdate(data as CommandLog[])
-      } else if (scope === 'metadata') {
-        this.#handleMetadataUpdate(data as Metadata)
-      } else if (scope === 'consoleLogs') {
-        this.#handleConsoleLogsUpdate(data as string[])
-      } else if (scope === 'networkRequests') {
-        this.#handleNetworkRequestsUpdate(data as NetworkRequest[])
-      } else if (scope === 'sources') {
-        this.#handleSourcesUpdate(data as Record<string, string>)
-      } else if (scope === 'suites') {
-        if (this.#shouldResetForNewRun(data)) {
-          this.#resetExecutionData()
-        }
-        this.#handleSuitesUpdate(data)
-      }
-
+      this.#dispatchDataScope(scope, data)
       this.#host.requestUpdate()
     } catch (e: unknown) {
       console.warn(`Failed to parse socket message: ${(e as Error).message}`)
@@ -413,84 +299,16 @@ export class DataManagerController implements ReactiveController {
   }
 
   #shouldResetForNewRun(data: unknown): boolean {
-    // During a UI-triggered rerun, suppress auto-detection so sibling-scenario
-    // updates don't wipe accumulated execution data.
-    // Still update #lastSeenRunTimestamp so that once activeRerunSuiteUid is
-    // cleared the final suite update isn't mistakenly treated as a new run.
-    if (rerunState.activeRerunSuiteUid) {
-      const payloads = Array.isArray(data)
-        ? (data as Record<string, SuiteStatsFragment>[])
-        : ([data] as Record<string, SuiteStatsFragment>[])
-      for (const chunk of payloads) {
-        if (!chunk) {
-          continue
-        }
-        for (const suite of Object.values(chunk)) {
-          if (!suite?.start) {
-            continue
-          }
-          const t = getTimestamp(
-            suite.start as Date | number | string | undefined
-          )
-          if (t > this.#lastSeenRunTimestamp) {
-            this.#lastSeenRunTimestamp = t
-          }
-        }
-      }
-      return false
-    }
-
-    const payloads = Array.isArray(data)
-      ? (data as Record<string, SuiteStatsFragment>[])
-      : ([data] as Record<string, SuiteStatsFragment>[])
-
-    for (const chunk of payloads) {
-      if (!chunk) {
-        continue
-      }
-
-      for (const suite of Object.values(chunk)) {
-        if (!suite?.start) {
-          continue
-        }
-
-        const suiteStartTime = getTimestamp(
-          suite.start as Date | number | string | undefined
-        )
-
-        if (suiteStartTime <= 0) {
-          continue
-        }
-
-        // New run detected if we see a newer start timestamp.
-        // Exception: if the existing suite for this uid has no end time, it is
-        // still an ongoing run (e.g. a Cucumber feature spanning multiple
-        // scenarios) — treat it as a continuation, not a new run.
-        if (suiteStartTime > this.#lastSeenRunTimestamp) {
-          const existingChunks = this.suitesContextProvider.value || []
-          let existingEnd: unknown = undefined
-          outer: for (const ec of existingChunks) {
-            for (const [uid, existing] of Object.entries(ec)) {
-              if (uid === Object.keys(chunk)[0]) {
-                existingEnd = existing?.end
-                break outer
-              }
-            }
-          }
-          // Only reset if the previous run was already finished (had an end time).
-          // An ongoing run (end == null / undefined) is just a continuation.
-          const previousRunFinished =
-            existingEnd !== null && existingEnd !== undefined
-          if (previousRunFinished) {
-            this.#lastSeenRunTimestamp = suiteStartTime
-            return true
-          }
-          // Continuation — update tracking timestamp but do NOT reset
-          this.#lastSeenRunTimestamp = suiteStartTime
-        }
-      }
-    }
-    return false
+    const { shouldReset, newLastSeenTimestamp } = shouldResetForNewRun(
+      data,
+      {
+        lastSeenRunTimestamp: this.#lastSeenRunTimestamp,
+        activeRerunSuiteUid: rerunState.activeRerunSuiteUid
+      },
+      this.suitesContextProvider.value || []
+    )
+    this.#lastSeenRunTimestamp = newLastSeenTimestamp
+    return shouldReset
   }
 
   #resetExecutionData() {
@@ -511,72 +329,8 @@ export class DataManagerController implements ReactiveController {
   #handleTestStopped() {
     this.#activeRerunTestUid = undefined
     rerunState.activeRerunSuiteUid = undefined
-
-    // Mark all running tests as failed when test execution is stopped
     const suites = this.suitesContextProvider.value || []
-    const updatedSuites = suites.map((chunk) => {
-      const updatedChunk: Record<string, SuiteStatsFragment> = {}
-      Object.entries(chunk as Record<string, SuiteStatsFragment>).forEach(
-        ([uid, suite]) => {
-          if (!suite) {
-            updatedChunk[uid] = suite
-            return
-          }
-
-          // Recursive helper to update tests and nested suites
-          const updateSuite = (s: SuiteStatsFragment): SuiteStatsFragment => {
-            const updatedTests = s.tests?.map((test): TestStatsFragment => {
-              // If test is running (no end time), mark it as failed
-              if (test && !test.end) {
-                return {
-                  ...test,
-                  end: new Date(),
-                  state: 'failed',
-                  error: {
-                    message: 'Test execution stopped',
-                    name: 'TestStoppedError'
-                  }
-                }
-              }
-              return test
-            })
-
-            // Recursively update nested suites (for Cucumber scenarios)
-            const updatedNestedSuites = s.suites?.map(updateSuite)
-
-            // Derive the suite's own state from its updated children so that
-            // STATE_MAP['running'] no longer produces a spinner after stop.
-            const allTests = [
-              ...(updatedTests || []),
-              ...(updatedNestedSuites || [])
-            ]
-            const hasFailed = allTests.some((t) => t?.state === 'failed')
-            const hasRunning = allTests.some((t) => !t?.end)
-            const derivedState: SuiteStatsFragment['state'] = hasRunning
-              ? s.state
-              : hasFailed
-                ? 'failed'
-                : s.state === 'running'
-                  ? 'failed'
-                  : s.state
-
-            return {
-              ...s,
-              state: derivedState,
-              ...(!hasRunning && !s.end ? { end: new Date() } : {}),
-
-              tests: updatedTests || [],
-              suites: updatedNestedSuites || []
-            }
-          }
-
-          updatedChunk[uid] = updateSuite(suite)
-        }
-      )
-      return updatedChunk
-    })
-
-    this.suitesContextProvider.setValue(updatedSuites)
+    this.suitesContextProvider.setValue(markRunningAsStopped(suites))
   }
 
   #handleMutationsUpdate(data: TraceMutation[]) {
@@ -594,25 +348,13 @@ export class DataManagerController implements ReactiveController {
   }
 
   #handleReplaceCommand(oldTimestamp: number, newCommand: CommandLog) {
-    const current = this.commandsContextProvider.value || []
-    // Prefer stable `id` — chained selenium calls share a millisecond.
-    let idx = -1
-    const newId = (newCommand as CommandLog & { id?: number }).id
-    if (typeof newId === 'number') {
-      idx = current.findIndex(
-        (c) => (c as CommandLog & { id?: number }).id === newId
+    this.commandsContextProvider.setValue(
+      replaceCommand(
+        this.commandsContextProvider.value || [],
+        oldTimestamp,
+        newCommand
       )
-    }
-    if (idx === -1) {
-      idx = current.map((c) => c.timestamp).lastIndexOf(oldTimestamp)
-    }
-    if (idx !== -1) {
-      const updated = [...current]
-      updated[idx] = newCommand
-      this.commandsContextProvider.setValue(updated)
-    } else {
-      this.commandsContextProvider.setValue([...current, newCommand])
-    }
+    )
   }
 
   #handleConsoleLogsUpdate(data: string[]) {
@@ -623,28 +365,12 @@ export class DataManagerController implements ReactiveController {
   }
 
   #handleNetworkRequestsUpdate(data: NetworkRequest[]) {
-    const current = this.networkRequestsContextProvider.value || []
-    const byId = new Map<string, number>()
-    current.forEach((r, i) => {
-      if (r?.id) {
-        byId.set(r.id, i)
-      }
-    })
-    const next = [...current]
-    for (const incoming of data) {
-      if (!incoming?.id) {
-        next.push(incoming)
-        continue
-      }
-      const existingIdx = byId.get(incoming.id)
-      if (existingIdx !== undefined) {
-        next[existingIdx] = incoming
-      } else {
-        byId.set(incoming.id, next.length)
-        next.push(incoming)
-      }
-    }
-    this.networkRequestsContextProvider.setValue(next)
+    this.networkRequestsContextProvider.setValue(
+      mergeNetworkRequests(
+        this.networkRequestsContextProvider.value || [],
+        data
+      )
+    )
   }
 
   #handleMetadataUpdate(data: Metadata) {
@@ -662,14 +388,8 @@ export class DataManagerController implements ReactiveController {
     this.sourcesContextProvider.setValue(merged)
   }
 
-  #handleSuitesUpdate(data: unknown) {
-    const payloads = Array.isArray(data)
-      ? (data as Record<string, SuiteStatsFragment>[])
-      : ([data] as Record<string, SuiteStatsFragment>[])
-
+  #seedSuiteMapFromContext(): Map<string, SuiteStatsFragment> {
     const suiteMap = new Map<string, SuiteStatsFragment>()
-
-    // Populate with existing suites (keeps test list visible)
     ;(this.suitesContextProvider.value || []).forEach((chunk) => {
       Object.entries(chunk as Record<string, SuiteStatsFragment>).forEach(
         ([uid, suite]) => {
@@ -679,35 +399,51 @@ export class DataManagerController implements ReactiveController {
         }
       )
     })
+    return suiteMap
+  }
 
-    // Canonicalize uids for root suites so a rerun whose reporter assigned a
-    // different uid still merges into the original row.
-    const existingRootSuites = Array.from(suiteMap.values())
-    const incomingRootSuites: SuiteStatsFragment[] = []
+  #collectIncomingRootSuites(
+    payloads: Record<string, SuiteStatsFragment>[]
+  ): SuiteStatsFragment[] {
+    const out: SuiteStatsFragment[] = []
     payloads.forEach((chunk) => {
       if (!chunk) {
         return
       }
       for (const suite of Object.values(chunk)) {
         if (suite?.uid) {
-          incomingRootSuites.push(suite)
+          out.push(suite)
         }
       }
     })
-    const canonicalizedRoots = this.#canonicalizeUids(
+    return out
+  }
+
+  #handleSuitesUpdate(data: unknown) {
+    const payloads = Array.isArray(data)
+      ? (data as Record<string, SuiteStatsFragment>[])
+      : ([data] as Record<string, SuiteStatsFragment>[])
+    const suiteMap = this.#seedSuiteMapFromContext()
+    // Canonicalize uids for root suites so a rerun whose reporter assigned a
+    // different uid still merges into the original row.
+    const existingRootSuites = Array.from(suiteMap.values())
+    const incomingRootSuites = this.#collectIncomingRootSuites(payloads)
+    const mergeCtx = {
+      activeRerunTestUid: this.#activeRerunTestUid,
+      activeRerunSuiteUid: rerunState.activeRerunSuiteUid
+    }
+    const canonicalizedRoots = canonicalizeUids(
       existingRootSuites,
       incomingRootSuites
     )
-
     canonicalizedRoots.forEach((suite) => {
       if (!suite?.uid) {
         return
       }
       const existing = suiteMap.get(suite.uid)
-      const merged = existing ? this.#mergeSuite(existing, suite) : suite
+      const merged = existing ? mergeSuite(existing, suite, mergeCtx) : suite
       suiteMap.set(suite.uid, merged)
     })
-
     this.suitesContextProvider.setValue(
       Array.from(suiteMap.entries()).map(([uid, suite]) => ({ [uid]: suite }))
     )
@@ -726,251 +462,11 @@ export class DataManagerController implements ReactiveController {
     this.logsContextProvider.setValue(data)
   }
 
-  #mergeSuite(existing: SuiteStatsFragment, incoming: SuiteStatsFragment) {
-    // First merge tests and suites properly
-    const mergedTests = this.#mergeTests(existing.tests, incoming.tests)
-    const mergedSuites = this.#mergeChildSuites(
-      existing.suites,
-      incoming.suites
-    )
-
-    // Then merge suite properties, ensuring merged tests/suites are preserved
-    const { tests, suites, ...incomingProps } = incoming
-
-    // Strip undefined state from incoming so it doesn't overwrite a valid existing state.
-    // The Nightwatch reporter may send suites without a state field when the JSON
-    // serialization omits properties that are undefined on the object.
-    if (incomingProps.state === undefined || incomingProps.state === null) {
-      delete (incomingProps as any).state
-    }
-
-    // Treat incoming state=undefined/null the same as pending — WDIO's SuiteStats
-    // doesn't set 'state' on suite end (unlike TestStats), so undefined means the
-    // backend hasn't assigned a terminal state. Null is the Nightwatch equivalent.
-    const incomingStateIsPendingOrUnset =
-      incoming.state === 'pending' ||
-      incoming.state === null ||
-      incoming.state === undefined
-
-    const allChildren = [...(mergedTests || []), ...(mergedSuites || [])]
-    // Treat children with undefined/null state as in-progress (not yet terminal).
-    // This prevents prematurely deriving 'passed' when children haven't reported yet.
-    const hasInProgressChildren = allChildren.some(
-      (child) =>
-        child?.state === 'running' ||
-        child?.state === 'pending' ||
-        child?.state === null
-    )
-    const hasFailedChildren = allChildren.some(
-      (child) => child?.state === 'failed'
-    )
-    const hasChildren = allChildren.length > 0
-
-    // Only derive 'passed' when ALL children have reached a terminal state.
-    const allChildrenTerminal =
-      hasChildren &&
-      allChildren.every(
-        (child) =>
-          child?.state === 'passed' ||
-          child?.state === 'failed' ||
-          child?.state === 'skipped'
-      )
-
-    // On rerun start we optimistically mark the suite as running in the UI.
-    // Keep (or set) running state whenever the incoming state is unset/pending
-    // AND children are still in-progress. This handles both:
-    //   • Nightwatch: suite was already 'running' → keep it running
-    //   • WDIO: suite was 'passed' from previous run but now has running children
-    //     (WDIO SuiteStats never carries an explicit state, so the previous
-    //     derivedCompletedState='passed' would otherwise be silently preserved)
-    const keepRunningState =
-      incomingStateIsPendingOrUnset && hasInProgressChildren
-
-    // Only derive 'passed'/'failed' from children when the backend hasn't
-    // assigned an explicit state (WDIO case: SuiteStats.state is never set on
-    // suite end). When state is explicitly 'pending' the backend is signalling
-    // a new run is starting — stale children from the previous run must not
-    // be used to derive a completed state.
-    const incomingStateIsUnset =
-      incoming.state === null || incoming.state === undefined
-
-    const derivedCompletedState: SuiteStatsFragment['state'] | undefined =
-      allChildrenTerminal && incomingStateIsUnset
-        ? hasFailedChildren
-          ? 'failed'
-          : 'passed'
-        : undefined
-
-    // When a new run starts the backend sends the feature suite with
-    // state: 'pending' before it has pushed any scenario children.
-    // #mergeChildSuites preserves stale child suites from the previous run,
-    // but they must not keep their terminal states — mark them 'pending' so
-    // they render as a spinner instead of a stale checkmark/cross.
-    // Exception: when only a specific child scenario is being rerun
-    // (activeRerunSuiteUid differs from the incoming feature suite's uid),
-    // sibling scenarios must keep their existing terminal states.
-    const isChildRerun =
-      !!rerunState.activeRerunSuiteUid &&
-      rerunState.activeRerunSuiteUid !== incoming.uid
-    const finalSuites =
-      incoming.state === 'pending' && mergedSuites && !isChildRerun
-        ? mergedSuites.map((s) =>
-            s.state === 'passed' || s.state === 'failed'
-              ? { ...s, state: 'pending' as const, end: undefined }
-              : s
-          )
-        : mergedSuites
-
-    return {
-      ...existing,
-      ...incomingProps,
-      ...(keepRunningState && hasInProgressChildren
-        ? { state: 'running' as const }
-        : incomingStateIsPendingOrUnset &&
-            !hasInProgressChildren &&
-            derivedCompletedState
-          ? { state: derivedCompletedState }
-          : {}),
-      tests: mergedTests,
-      suites: finalSuites
-    }
-  }
-
-  /**
-   * Build a stable identity key for a test/suite that survives reporter UID drift
-   * across reruns. The reporter's signature counter can reassign UIDs when a
-   * single scenario is rerun (e.g. Cucumber outline example 2 reruns alone and
-   * gets the UID example 1 originally had). Matching by (file + featureLine +
-   * fullTitle) lets the merge dedupe by stable identity instead of the unstable
-   * uid.
-   */
-  #canonicalKey(
-    item: TestStatsFragment | SuiteStatsFragment
-  ): string | undefined {
-    const file = item.file ?? ''
-    const featureFile = item.featureFile ?? ''
-    const featureLine = item.featureLine ?? ''
-    const fullTitle = item.fullTitle ?? item.title ?? ''
-    if (!file && !featureFile && !fullTitle) {
-      return undefined
-    }
-    return `${file}::${featureFile}:${featureLine}::${fullTitle}`
-  }
-
-  /**
-   * Map an incoming item's uid to an existing entry's uid when their canonical
-   * keys match. Lets rerun payloads merge into the original rows even if the
-   * reporter assigned a different uid this time around.
-   */
-  #canonicalizeUids<T extends TestStatsFragment | SuiteStatsFragment>(
-    prev: T[],
-    next: T[]
-  ): T[] {
-    if (!next.length || !prev.length) {
-      return next
-    }
-    const canonicalToUid = new Map<string, string>()
-    for (const item of prev) {
-      if (!item) {
-        continue
-      }
-      const key = this.#canonicalKey(item)
-      if (key && !canonicalToUid.has(key)) {
-        canonicalToUid.set(key, item.uid)
-      }
-    }
-    return next.map((item) => {
-      if (!item) {
-        return item
-      }
-      const key = this.#canonicalKey(item)
-      if (!key) {
-        return item
-      }
-      const stableUid = canonicalToUid.get(key)
-      if (stableUid && stableUid !== item.uid) {
-        return { ...item, uid: stableUid }
-      }
-      return item
-    })
-  }
-
-  #mergeChildSuites(
-    prev: SuiteStatsFragment[] = [],
-    next: SuiteStatsFragment[] = []
-  ) {
-    const map = new Map<string, SuiteStatsFragment>()
-    prev?.forEach((suite) => suite && map.set(suite.uid, suite))
-
-    const canonicalizedNext = this.#canonicalizeUids(prev || [], next || [])
-
-    canonicalizedNext.forEach((suite) => {
-      if (!suite) {
-        return
-      }
-      const existing = map.get(suite.uid)
-      map.set(suite.uid, existing ? this.#mergeSuite(existing, suite) : suite)
-    })
-
-    return Array.from(map.values())
-  }
-
-  #mergeTests(prev: TestStatsFragment[] = [], next: TestStatsFragment[] = []) {
-    const map = new Map<string, TestStatsFragment>()
-    prev?.forEach((test) => test && map.set(test.uid, test))
-
-    const canonicalizedNext = this.#canonicalizeUids(prev || [], next || [])
-
-    canonicalizedNext.forEach((test) => {
-      if (!test) {
-        return
-      }
-      const existing = map.get(test.uid)
-      const activeTargetUid = this.#activeRerunTestUid
-
-      // During a single-test rerun, keep all sibling tests frozen exactly as
-      // they were before the rerun started. The backend can still emit suite-
-      // wide updates for those siblings, but the UI should only change the
-      // targeted test and its parent suite state.
-      if (activeTargetUid && test.uid !== activeTargetUid && existing) {
-        map.set(test.uid, { ...existing })
-        return
-      }
-
-      // Check if this test is a rerun (different start time)
-      const isRerun =
-        existing &&
-        test.start &&
-        existing.start &&
-        getTimestamp(test.start) !== getTimestamp(existing.start)
-
-      if (activeTargetUid && isRerun && test.state === 'pending' && existing) {
-        // The incoming suite structure marks all tests as "pending" at start.
-        // Preserve the ENTIRE existing record (including its old start time) so
-        // that tests not part of the current rerun keep their previous results.
-        // Crucially, keeping `existing.start` (the old run's timestamp) means
-        // every subsequent update for this test during the new run still has a
-        // different start time and therefore continues to be detected as a
-        // rerun — preventing a later normal-merge from overwriting state/end.
-        // When the test actually starts executing its state changes to "running"
-        // (non-pending), which falls through to the replace branch below.
-        map.set(test.uid, { ...existing })
-        return
-      }
-
-      // Replace on rerun (non-pending incoming), merge on normal update
-      map.set(
-        test.uid,
-        isRerun ? test : existing ? { ...existing, ...test } : test
-      )
-    })
-
-    return Array.from(map.values())
-  }
-
   loadTraceFile(traceFile: TraceLog) {
     localStorage.setItem(CACHE_ID, JSON.stringify(traceFile))
-    this.mutationsContextProvider.setValue(traceFile.mutations)
+    this.mutationsContextProvider.setValue(
+      traceFile.mutations as TraceMutation[]
+    )
     this.logsContextProvider.setValue(traceFile.logs)
     this.consoleLogsContextProvider.setValue(traceFile.consoleLogs)
     this.networkRequestsContextProvider.setValue(
diff --git a/packages/app/src/controller/context.ts b/packages/app/src/controller/context.ts
index 27fe9373..58979892 100644
--- a/packages/app/src/controller/context.ts
+++ b/packages/app/src/controller/context.ts
@@ -3,7 +3,7 @@ import type {
   Metadata,
   CommandLog,
   PreservedAttempt
-} from '@wdio/devtools-service/types'
+} from '@wdio/devtools-shared'
 import type { SuiteStatsFragment } from './types.js'
 
 export const mutationContext = createContext<TraceMutation[]>(
diff --git a/packages/app/src/controller/contextUpdates.ts b/packages/app/src/controller/contextUpdates.ts
new file mode 100644
index 00000000..a9b338b7
--- /dev/null
+++ b/packages/app/src/controller/contextUpdates.ts
@@ -0,0 +1,69 @@
+/**
+ * Pure transforms for the live-context arrays managed by DataManager.
+ *
+ * Extracted from DataManager so the controller stays under the file-size
+ * cap and these merges can be unit-tested in isolation. Each function
+ * takes the current context value + an incoming payload and returns the
+ * new value the ContextProvider should publish.
+ */
+
+import type { CommandLog, NetworkRequest } from '@wdio/devtools-shared'
+
+/**
+ * Replace an existing command entry (matched first by stable `id`, then by
+ * `timestamp` as a fallback for runners that don't surface ids). When no
+ * match is found, the new entry is appended.
+ */
+export function replaceCommand(
+  current: CommandLog[],
+  oldTimestamp: number,
+  newCommand: CommandLog
+): CommandLog[] {
+  let idx = -1
+  const newId = (newCommand as CommandLog & { id?: number }).id
+  if (typeof newId === 'number') {
+    idx = current.findIndex(
+      (c) => (c as CommandLog & { id?: number }).id === newId
+    )
+  }
+  if (idx === -1) {
+    idx = current.map((c) => c.timestamp).lastIndexOf(oldTimestamp)
+  }
+  if (idx !== -1) {
+    const next = [...current]
+    next[idx] = newCommand
+    return next
+  }
+  return [...current, newCommand]
+}
+
+/**
+ * Merge incoming network requests into the current list, deduping by `id`.
+ * Requests without an id are always appended.
+ */
+export function mergeNetworkRequests(
+  current: NetworkRequest[],
+  incoming: NetworkRequest[]
+): NetworkRequest[] {
+  const byId = new Map<string, number>()
+  current.forEach((r, i) => {
+    if (r?.id) {
+      byId.set(r.id, i)
+    }
+  })
+  const next = [...current]
+  for (const req of incoming) {
+    if (!req?.id) {
+      next.push(req)
+      continue
+    }
+    const existing = byId.get(req.id)
+    if (existing !== undefined) {
+      next[existing] = req
+    } else {
+      byId.set(req.id, next.length)
+      next.push(req)
+    }
+  }
+  return next
+}
diff --git a/packages/app/src/controller/mark-running.ts b/packages/app/src/controller/mark-running.ts
new file mode 100644
index 00000000..346c365e
--- /dev/null
+++ b/packages/app/src/controller/mark-running.ts
@@ -0,0 +1,206 @@
+import type { SuiteStatsFragment, TestStatsFragment } from './types.js'
+
+/**
+ * Pure tree transforms that mark a suite/test as "running" on rerun start.
+ * Lifted out of DataManagerController so they're testable and the controller
+ * method stays a thin wrapper around the context-provider read/write.
+ */
+
+type SuiteChunks = Array<Record<string, SuiteStatsFragment>>
+
+/**
+ * Mark every suite (and its descendants) as running. Used when the user
+ * clicks the global "TESTS" rerun (uid='*'). Leaf-level tests are cleared so
+ * stale step entries from a previous run don't linger; the new run will
+ * repopulate them. Child suites are preserved so the tree structure stays
+ * visible during the rerun.
+ */
+export function markAllRunning(suites: SuiteChunks): SuiteChunks {
+  const markAllAsRunning = (s: SuiteStatsFragment): SuiteStatsFragment => ({
+    ...s,
+    state: 'running',
+    start: new Date(),
+    end: undefined,
+    tests: [] as TestStatsFragment[],
+    suites: s.suites?.map(markAllAsRunning) || []
+  })
+
+  return suites.map((chunk) => {
+    const updatedChunk: Record<string, SuiteStatsFragment> = {}
+    Object.entries(chunk as Record<string, SuiteStatsFragment>).forEach(
+      ([suiteUid, suite]) => {
+        if (!suite) {
+          updatedChunk[suiteUid] = suite
+          return
+        }
+        updatedChunk[suiteUid] = markAllAsRunning(suite)
+      }
+    )
+    return updatedChunk
+  })
+}
+
+/**
+ * Mark a specific suite OR test as running by walking the tree:
+ *  - When `entryType !== 'test'` and a suite matches by uid, mark that suite
+ *    AND ALL its descendants as running (full feature/scenario rerun).
+ *  - When `entryType === 'test'` and a test matches by uid, mark just that
+ *    test pending (start=now, end=undefined). Parent suites get state:
+ *    'running' marked on the matched path but their start/end are preserved
+ *    if already running so re-clicking a child doesn't reset the feature's
+ *    run timestamp.
+ */
+function markSuiteTreeAsRunning(
+  suiteNode: SuiteStatsFragment,
+  runStart: Date
+): SuiteStatsFragment {
+  return {
+    ...suiteNode,
+    state: 'running',
+    start: runStart,
+    end: undefined,
+    tests: [] as TestStatsFragment[],
+    suites:
+      suiteNode.suites?.map((s) => markSuiteTreeAsRunning(s, runStart)) || []
+  }
+}
+
+function markSuiteWithUid(
+  s: SuiteStatsFragment,
+  uid: string,
+  entryType: 'suite' | 'test' | undefined,
+  runStart: Date
+): { suite: SuiteStatsFragment; matched: boolean } {
+  if (entryType !== 'test' && s.uid === uid) {
+    return { matched: true, suite: markSuiteTreeAsRunning(s, runStart) }
+  }
+  let matched = false
+  const updatedTests = (s.tests?.map((test) => {
+    if (test.uid === uid) {
+      matched = true
+      return { ...test, state: 'pending', start: new Date(), end: undefined }
+    }
+    return test
+  }) ?? []) as TestStatsFragment[]
+  const updatedNestedSuites =
+    s.suites?.map((nestedSuite) => {
+      const nestedResult = markSuiteWithUid(
+        nestedSuite,
+        uid,
+        entryType,
+        runStart
+      )
+      if (nestedResult.matched) {
+        matched = true
+      }
+      return nestedResult.suite
+    }) || []
+  return {
+    matched,
+    suite: {
+      ...s,
+      ...(matched
+        ? {
+            state: 'running' as const,
+            // Preserve parent's start/end if already running — subsequent
+            // child-scenario marks would otherwise reset the feature's
+            // original run timestamp.
+            ...(s.state !== 'running'
+              ? { start: runStart, end: undefined }
+              : {})
+          }
+        : {}),
+      tests: updatedTests || [],
+      suites: updatedNestedSuites
+    }
+  }
+}
+
+export function markSpecificRunning(
+  suites: SuiteChunks,
+  uid: string,
+  entryType: 'suite' | 'test' | undefined
+): SuiteChunks {
+  return suites.map((chunk) => {
+    const updatedChunk: Record<string, SuiteStatsFragment> = {}
+    Object.entries(chunk as Record<string, SuiteStatsFragment>).forEach(
+      ([suiteUid, suite]) => {
+        if (!suite) {
+          updatedChunk[suiteUid] = suite
+          return
+        }
+        const runStart = new Date()
+        updatedChunk[suiteUid] = markSuiteWithUid(
+          suite,
+          uid,
+          entryType,
+          runStart
+        ).suite
+      }
+    )
+    return updatedChunk
+  })
+}
+
+/**
+ * Mark every still-running test (no `end`) as failed. Used when the user
+ * manually stops the run from the dashboard — without this, suites with
+ * `state: 'running'` would keep showing their spinner indefinitely.
+ *
+ * The suite's state is derived from its updated children: if any child is
+ * failed (or the suite itself was 'running' with no live children left),
+ * the suite ends up failed. Otherwise the existing state is preserved.
+ */
+export function markRunningAsStopped(suites: SuiteChunks): SuiteChunks {
+  const updateSuite = (s: SuiteStatsFragment): SuiteStatsFragment => {
+    const updatedTests = s.tests?.map((test): TestStatsFragment => {
+      if (test && !test.end) {
+        return {
+          ...test,
+          end: new Date(),
+          state: 'failed',
+          error: {
+            message: 'Test execution stopped',
+            name: 'TestStoppedError'
+          }
+        }
+      }
+      return test
+    })
+
+    const updatedNestedSuites = s.suites?.map(updateSuite)
+
+    const allTests = [...(updatedTests || []), ...(updatedNestedSuites || [])]
+    const hasFailed = allTests.some((t) => t?.state === 'failed')
+    const hasRunning = allTests.some((t) => !t?.end)
+    const derivedState: SuiteStatsFragment['state'] = hasRunning
+      ? s.state
+      : hasFailed
+        ? 'failed'
+        : s.state === 'running'
+          ? 'failed'
+          : s.state
+
+    return {
+      ...s,
+      state: derivedState,
+      ...(!hasRunning && !s.end ? { end: new Date() } : {}),
+      tests: updatedTests || [],
+      suites: updatedNestedSuites || []
+    }
+  }
+
+  return suites.map((chunk) => {
+    const updatedChunk: Record<string, SuiteStatsFragment> = {}
+    Object.entries(chunk as Record<string, SuiteStatsFragment>).forEach(
+      ([uid, suite]) => {
+        if (!suite) {
+          updatedChunk[uid] = suite
+          return
+        }
+        updatedChunk[uid] = updateSuite(suite)
+      }
+    )
+    return updatedChunk
+  })
+}
diff --git a/packages/app/src/controller/run-detection.ts b/packages/app/src/controller/run-detection.ts
new file mode 100644
index 00000000..51e3cc5b
--- /dev/null
+++ b/packages/app/src/controller/run-detection.ts
@@ -0,0 +1,117 @@
+import { getTimestamp } from '../utils/helpers.js'
+import type { SuiteStatsFragment } from './types.js'
+
+type SuiteChunks = Array<Record<string, SuiteStatsFragment>>
+
+export interface RunDetectionState {
+  /** Highest start-timestamp seen so far across any incoming suite. */
+  lastSeenRunTimestamp: number
+  /** Active feature/scenario rerun (set by clearExecutionData). Presence
+   *  suppresses new-run auto-detection so sibling updates don't wipe data. */
+  activeRerunSuiteUid: string | undefined
+}
+
+export interface RunDetectionResult {
+  /** True if the incoming payload signals a fresh test run — caller should
+   *  reset the execution-data context providers. */
+  shouldReset: boolean
+  /** Updated `lastSeenRunTimestamp` value the caller should write back. */
+  newLastSeenTimestamp: number
+}
+
+/**
+ * Decide whether an incoming `suites` payload represents a new run that
+ * should wipe accumulated execution data.
+ *
+ * Rules (in order):
+ *  1. If a UI-triggered rerun is active (`activeRerunSuiteUid` set), never
+ *     auto-reset — siblings under the same feature would lose state. The
+ *     timestamp tracker still advances so the post-rerun final update isn't
+ *     mistakenly treated as a new run.
+ *  2. If we see a suite whose start-timestamp is newer than anything
+ *     previously seen AND the existing suite for that uid is finished
+ *     (has an `end`), it's a brand-new run → reset.
+ *  3. If the existing suite has no `end`, it's an ongoing run (e.g. a
+ *     cucumber feature spanning multiple scenarios) — continuation, no reset.
+ *
+ * Pure: no `this`. Pass state in, write the returned timestamp back.
+ */
+// During a known rerun: just advance the lastSeen high-water mark and don't
+// signal a reset — we'd otherwise wipe the rerun's own freshly-written tree.
+function advanceLastSeenAcrossPayloads(
+  payloads: Record<string, SuiteStatsFragment>[],
+  lastSeen: number
+): number {
+  for (const chunk of payloads) {
+    if (!chunk) {
+      continue
+    }
+    for (const suite of Object.values(chunk)) {
+      if (!suite?.start) {
+        continue
+      }
+      const t = getTimestamp(suite.start as Date | number | string | undefined)
+      if (t > lastSeen) {
+        lastSeen = t
+      }
+    }
+  }
+  return lastSeen
+}
+
+function lookupExistingSuiteEnd(
+  chunk: Record<string, SuiteStatsFragment>,
+  existingChunks: SuiteChunks
+): unknown {
+  const firstUid = Object.keys(chunk)[0]
+  for (const ec of existingChunks) {
+    for (const [uid, existing] of Object.entries(ec)) {
+      if (uid === firstUid) {
+        return existing?.end
+      }
+    }
+  }
+  return undefined
+}
+
+export function shouldResetForNewRun(
+  data: unknown,
+  state: RunDetectionState,
+  existingChunks: SuiteChunks
+): RunDetectionResult {
+  let lastSeen = state.lastSeenRunTimestamp
+  const payloads = Array.isArray(data)
+    ? (data as Record<string, SuiteStatsFragment>[])
+    : ([data] as Record<string, SuiteStatsFragment>[])
+
+  if (state.activeRerunSuiteUid) {
+    lastSeen = advanceLastSeenAcrossPayloads(payloads, lastSeen)
+    return { shouldReset: false, newLastSeenTimestamp: lastSeen }
+  }
+
+  for (const chunk of payloads) {
+    if (!chunk) {
+      continue
+    }
+    for (const suite of Object.values(chunk)) {
+      if (!suite?.start) {
+        continue
+      }
+      const suiteStartTime = getTimestamp(
+        suite.start as Date | number | string | undefined
+      )
+      if (suiteStartTime <= 0 || suiteStartTime <= lastSeen) {
+        continue
+      }
+      const existingEnd = lookupExistingSuiteEnd(chunk, existingChunks)
+      const previousRunFinished =
+        existingEnd !== null && existingEnd !== undefined
+      if (previousRunFinished) {
+        return { shouldReset: true, newLastSeenTimestamp: suiteStartTime }
+      }
+      // Continuation — advance high-water mark, don't reset.
+      lastSeen = suiteStartTime
+    }
+  }
+  return { shouldReset: false, newLastSeenTimestamp: lastSeen }
+}
diff --git a/packages/app/src/controller/suite-merge.ts b/packages/app/src/controller/suite-merge.ts
new file mode 100644
index 00000000..3cacaecd
--- /dev/null
+++ b/packages/app/src/controller/suite-merge.ts
@@ -0,0 +1,272 @@
+import { getTimestamp } from '../utils/helpers.js'
+import type { SuiteStatsFragment, TestStatsFragment } from './types.js'
+
+/**
+ * Pure suite-tree merge logic, lifted out of DataManagerController to keep it
+ * testable and to drop ~280 lines from the controller class. The functions
+ * take rerun-state explicitly via {@link MergeContext} so they don't depend on
+ * module-level mutable state.
+ */
+export interface MergeContext {
+  /** Set during a single-test rerun — siblings should stay frozen at their
+   *  pre-rerun state. */
+  activeRerunTestUid?: string
+  /** Set during a feature/scenario rerun — used to detect "child rerun" so
+   *  sibling scenarios under the same feature aren't optimistically flipped
+   *  back to 'pending' when the feature suite re-emits with state='pending'. */
+  activeRerunSuiteUid?: string
+}
+
+/**
+ * Stable identity key for a test/suite that survives reporter UID drift
+ * across reruns. The reporter's signature counter can reassign UIDs when a
+ * single scenario is rerun (e.g. Cucumber outline example 2 reruns alone and
+ * gets the UID example 1 originally had). Matching by (file + featureLine +
+ * fullTitle) lets the merge dedupe by stable identity instead of the unstable
+ * uid.
+ */
+export function canonicalKey(
+  item: TestStatsFragment | SuiteStatsFragment
+): string | undefined {
+  const file = item.file ?? ''
+  const featureFile = item.featureFile ?? ''
+  const featureLine = item.featureLine ?? ''
+  const fullTitle = item.fullTitle ?? item.title ?? ''
+  if (!file && !featureFile && !fullTitle) {
+    return undefined
+  }
+  return `${file}::${featureFile}:${featureLine}::${fullTitle}`
+}
+
+/**
+ * Rewrite each incoming item's uid to the matching existing entry's uid when
+ * their canonical keys match. Lets rerun payloads merge into the original
+ * rows even if the reporter assigned a different uid this time around.
+ */
+export function canonicalizeUids<
+  T extends TestStatsFragment | SuiteStatsFragment
+>(prev: T[], next: T[]): T[] {
+  if (!next.length || !prev.length) {
+    return next
+  }
+  const canonicalToUid = new Map<string, string>()
+  for (const item of prev) {
+    if (!item) {
+      continue
+    }
+    const key = canonicalKey(item)
+    if (key && !canonicalToUid.has(key)) {
+      canonicalToUid.set(key, item.uid)
+    }
+  }
+  return next.map((item) => {
+    if (!item) {
+      return item
+    }
+    const key = canonicalKey(item)
+    if (!key) {
+      return item
+    }
+    const stableUid = canonicalToUid.get(key)
+    if (stableUid && stableUid !== item.uid) {
+      return { ...item, uid: stableUid }
+    }
+    return item
+  })
+}
+
+export function mergeTests(
+  prev: TestStatsFragment[] = [],
+  next: TestStatsFragment[] = [],
+  ctx: MergeContext
+): TestStatsFragment[] {
+  const map = new Map<string, TestStatsFragment>()
+  prev?.forEach((test) => test && map.set(test.uid, test))
+
+  const canonicalizedNext = canonicalizeUids(prev || [], next || [])
+
+  canonicalizedNext.forEach((test) => {
+    if (!test) {
+      return
+    }
+    const existing = map.get(test.uid)
+    const activeTargetUid = ctx.activeRerunTestUid
+
+    // During a single-test rerun, keep all sibling tests frozen exactly as
+    // they were before the rerun started. The backend can still emit suite-
+    // wide updates for those siblings, but the UI should only change the
+    // targeted test and its parent suite state.
+    if (activeTargetUid && test.uid !== activeTargetUid && existing) {
+      map.set(test.uid, { ...existing })
+      return
+    }
+
+    // Check if this test is a rerun (different start time)
+    const isRerun =
+      existing &&
+      test.start &&
+      existing.start &&
+      getTimestamp(test.start) !== getTimestamp(existing.start)
+
+    if (activeTargetUid && isRerun && test.state === 'pending' && existing) {
+      // The incoming suite structure marks all tests as "pending" at start.
+      // Preserve the ENTIRE existing record (including its old start time) so
+      // that tests not part of the current rerun keep their previous results.
+      // Crucially, keeping `existing.start` (the old run's timestamp) means
+      // every subsequent update for this test during the new run still has a
+      // different start time and therefore continues to be detected as a
+      // rerun — preventing a later normal-merge from overwriting state/end.
+      // When the test actually starts executing its state changes to "running"
+      // (non-pending), which falls through to the replace branch below.
+      map.set(test.uid, { ...existing })
+      return
+    }
+
+    // Replace on rerun (non-pending incoming), merge on normal update
+    map.set(
+      test.uid,
+      isRerun ? test : existing ? { ...existing, ...test } : test
+    )
+  })
+
+  return Array.from(map.values())
+}
+
+export function mergeChildSuites(
+  prev: SuiteStatsFragment[] = [],
+  next: SuiteStatsFragment[] = [],
+  ctx: MergeContext
+): SuiteStatsFragment[] {
+  const map = new Map<string, SuiteStatsFragment>()
+  prev?.forEach((suite) => suite && map.set(suite.uid, suite))
+
+  const canonicalizedNext = canonicalizeUids(prev || [], next || [])
+
+  canonicalizedNext.forEach((suite) => {
+    if (!suite) {
+      return
+    }
+    const existing = map.get(suite.uid)
+    map.set(suite.uid, existing ? mergeSuite(existing, suite, ctx) : suite)
+  })
+
+  return Array.from(map.values())
+}
+
+interface ChildStateSummary {
+  hasInProgressChildren: boolean
+  hasFailedChildren: boolean
+  allChildrenTerminal: boolean
+}
+
+function summarizeChildStates(
+  mergedTests: SuiteStatsFragment['tests'] | undefined,
+  mergedSuites: SuiteStatsFragment['suites'] | undefined
+): ChildStateSummary {
+  const allChildren = [...(mergedTests || []), ...(mergedSuites || [])]
+  // undefined/null state counts as in-progress so we don't derive 'passed'
+  // before children have reported.
+  const hasInProgressChildren = allChildren.some(
+    (child) =>
+      child?.state === 'running' ||
+      child?.state === 'pending' ||
+      child?.state === null
+  )
+  const hasFailedChildren = allChildren.some(
+    (child) => child?.state === 'failed'
+  )
+  const hasChildren = allChildren.length > 0
+  const allChildrenTerminal =
+    hasChildren &&
+    allChildren.every(
+      (child) =>
+        child?.state === 'passed' ||
+        child?.state === 'failed' ||
+        child?.state === 'skipped'
+    )
+  return { hasInProgressChildren, hasFailedChildren, allChildrenTerminal }
+}
+
+// When a new run starts the backend sends the feature suite with
+// state: 'pending' before it has pushed any scenario children. Stale child
+// suites preserved by mergeChildSuites must not keep their terminal states —
+// mark them 'pending' so they render as a spinner instead of a stale check.
+// Exception: child-scope rerun (activeRerunSuiteUid differs from the
+// incoming feature suite's uid) — sibling scenarios keep terminal states.
+function resetStaleChildrenOnRerun(
+  mergedSuites: SuiteStatsFragment['suites'] | undefined,
+  incoming: SuiteStatsFragment,
+  ctx: MergeContext
+): SuiteStatsFragment['suites'] | undefined {
+  const isChildRerun =
+    !!ctx.activeRerunSuiteUid && ctx.activeRerunSuiteUid !== incoming.uid
+  if (incoming.state !== 'pending' || !mergedSuites || isChildRerun) {
+    return mergedSuites
+  }
+  return mergedSuites.map((s) =>
+    s.state === 'passed' || s.state === 'failed'
+      ? { ...s, state: 'pending' as const, end: undefined }
+      : s
+  )
+}
+
+export function mergeSuite(
+  existing: SuiteStatsFragment,
+  incoming: SuiteStatsFragment,
+  ctx: MergeContext
+): SuiteStatsFragment {
+  const mergedTests = mergeTests(existing.tests, incoming.tests, ctx)
+  const mergedSuites = mergeChildSuites(existing.suites, incoming.suites, ctx)
+
+  // Strip nullish state from incoming so it doesn't overwrite a valid existing
+  // state. Nightwatch reporter may omit state fields entirely.
+  const { tests, suites, ...incomingProps } = incoming
+  void tests
+  void suites
+  if (incomingProps.state === undefined || incomingProps.state === null) {
+    delete (incomingProps as Partial<SuiteStatsFragment>).state
+  }
+
+  // WDIO SuiteStats never carries 'state' on suite end → treat
+  // undefined/null/pending the same.
+  const incomingStateIsPendingOrUnset =
+    incoming.state === 'pending' ||
+    incoming.state === null ||
+    incoming.state === undefined
+  const incomingStateIsUnset =
+    incoming.state === null || incoming.state === undefined
+
+  const { hasInProgressChildren, hasFailedChildren, allChildrenTerminal } =
+    summarizeChildStates(mergedTests, mergedSuites)
+
+  // Keep 'running' when the backend hasn't reported a terminal state and any
+  // child is still in flight — covers both Nightwatch (was 'running') and
+  // WDIO (was 'passed' from previous run, now has new running children).
+  const keepRunningState =
+    incomingStateIsPendingOrUnset && hasInProgressChildren
+
+  // Only derive a terminal state when the backend left it unset AND every
+  // child has settled. Avoids deriving 'passed' from stale previous-run kids.
+  const derivedCompletedState: SuiteStatsFragment['state'] | undefined =
+    allChildrenTerminal && incomingStateIsUnset
+      ? hasFailedChildren
+        ? 'failed'
+        : 'passed'
+      : undefined
+
+  const finalSuites = resetStaleChildrenOnRerun(mergedSuites, incoming, ctx)
+
+  return {
+    ...existing,
+    ...incomingProps,
+    ...(keepRunningState && hasInProgressChildren
+      ? { state: 'running' as const }
+      : incomingStateIsPendingOrUnset &&
+          !hasInProgressChildren &&
+          derivedCompletedState
+        ? { state: derivedCompletedState }
+        : {}),
+    tests: mergedTests,
+    suites: finalSuites
+  }
+}
diff --git a/packages/app/src/controller/types.ts b/packages/app/src/controller/types.ts
index 02d6e085..2945fbc4 100644
--- a/packages/app/src/controller/types.ts
+++ b/packages/app/src/controller/types.ts
@@ -1,13 +1,21 @@
 import type { SuiteStats, TestStats } from '@wdio/reporter'
-import type {
-  TraceLog,
-  CommandLog,
-  PreservedAttempt
-} from '@wdio/devtools-service/types'
+import type { TestStatus } from '@wdio/devtools-shared'
+
+// SocketMessage / WsScope / WsPayloadFor are the WS wire format and live in
+// @wdio/devtools-shared (§2.1 + §2.5). Re-exported here for back-compat with
+// existing import sites; new code should import from shared directly.
+export type {
+  ControlScope,
+  ClearExecutionDataWsPayload,
+  SocketMessage,
+  TraceScope,
+  WsMessageScope,
+  WsPayloadFor
+} from '@wdio/devtools-shared'
 
 export type TestStatsFragment = Omit<Partial<TestStats>, 'uid' | 'state'> & {
   uid: string
-  state?: 'running' | 'passed' | 'failed' | 'pending' | 'skipped'
+  state?: TestStatus
   callSource?: string
   featureFile?: string
   featureLine?: number
@@ -18,7 +26,7 @@ export type SuiteStatsFragment = Omit<
   'uid' | 'tests' | 'suites'
 > & {
   uid: string
-  state?: 'running' | 'passed' | 'failed' | 'pending'
+  state?: TestStatus
   tests?: TestStatsFragment[]
   suites?: SuiteStatsFragment[]
   callSource?: string
@@ -27,36 +35,3 @@ export type SuiteStatsFragment = Omit<
   type?: string
   file?: string
 }
-
-export interface SocketMessage<
-  T extends
-    | keyof TraceLog
-    | 'testStopped'
-    | 'clearExecutionData'
-    | 'replaceCommand'
-    | 'baseline:saved'
-    | 'baseline:cleared' =
-    | keyof TraceLog
-    | 'testStopped'
-    | 'clearExecutionData'
-    | 'replaceCommand'
-    | 'baseline:saved'
-    | 'baseline:cleared'
-> {
-  scope: T
-  data: T extends keyof TraceLog
-    ? TraceLog[T]
-    : T extends 'clearExecutionData'
-      ? {
-          uid?: string
-          entryType?: 'suite' | 'test'
-          clearSuiteTree?: boolean
-        }
-      : T extends 'replaceCommand'
-        ? { oldTimestamp: number; command: CommandLog }
-        : T extends 'baseline:saved'
-          ? { testUid: string; attempt: PreservedAttempt }
-          : T extends 'baseline:cleared'
-            ? { testUid: string }
-            : unknown
-}
diff --git a/packages/app/src/utils/DragController.ts b/packages/app/src/utils/DragController.ts
index 2d1d0a5e..6d831cb9 100644
--- a/packages/app/src/utils/DragController.ts
+++ b/packages/app/src/utils/DragController.ts
@@ -145,17 +145,17 @@ export class DragController implements ReactiveController {
     const host = this.#host
 
     this.#pointerTracker = new PointerTracker(this.#draggableEl, {
-      start(pointer: any) {
+      start(pointer: Pointer) {
         onDragStart(pointer)
         updateState('dragging')
         host.requestUpdate()
         return true
       },
-      move(previousPointers: any, changedPointers: any) {
+      move(previousPointers: Pointer[], changedPointers: Pointer[]) {
         onDrag(previousPointers, changedPointers)
       },
-      end(pointer: any, ev: Event) {
-        onDragEnd(pointer, ev)
+      end(pointer: Pointer, ev: Event) {
+        onDragEnd(pointer, ev as InputEvent)
         updateState('idle')
         host.requestUpdate()
         adjustPosition()
diff --git a/packages/app/tests/contextUpdates.test.ts b/packages/app/tests/contextUpdates.test.ts
new file mode 100644
index 00000000..6389fb8a
--- /dev/null
+++ b/packages/app/tests/contextUpdates.test.ts
@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest'
+import type { CommandLog, NetworkRequest } from '@wdio/devtools-shared'
+import {
+  mergeNetworkRequests,
+  replaceCommand
+} from '../src/controller/contextUpdates.js'
+
+function cmd(
+  id: number | undefined,
+  timestamp: number,
+  command = 'click',
+  extra: Partial<CommandLog> = {}
+): CommandLog & { id?: number } {
+  return { command, args: [], timestamp, id, ...extra }
+}
+
+describe('replaceCommand', () => {
+  it('replaces by stable `id` when both ids match', () => {
+    const current = [cmd(1, 100), cmd(2, 100), cmd(3, 200)]
+    const incoming = cmd(2, 100, 'click-updated')
+    const next = replaceCommand(current, 100, incoming)
+    expect(next).toHaveLength(3)
+    expect(next[1].command).toBe('click-updated')
+    expect(next[0]).toBe(current[0])
+    expect(next[2]).toBe(current[2])
+  })
+
+  it('falls back to timestamp lastIndexOf when id is missing', () => {
+    const current = [cmd(undefined, 100), cmd(undefined, 100)]
+    const incoming = cmd(undefined, 100, 'click-final')
+    const next = replaceCommand(current, 100, incoming)
+    expect(next[0]).toBe(current[0])
+    expect(next[1].command).toBe('click-final')
+  })
+
+  it('appends when no match found', () => {
+    const current = [cmd(1, 100)]
+    const incoming = cmd(99, 999, 'new')
+    const next = replaceCommand(current, 999, incoming)
+    expect(next).toHaveLength(2)
+    expect(next[1].command).toBe('new')
+  })
+
+  it('returns a NEW array (does not mutate input)', () => {
+    const current = [cmd(1, 100)]
+    const incoming = cmd(1, 100, 'replaced')
+    const next = replaceCommand(current, 100, incoming)
+    expect(next).not.toBe(current)
+    expect(current[0].command).toBe('click')
+  })
+})
+
+function req(id: string | undefined, url: string): NetworkRequest {
+  return {
+    id: id as string,
+    url,
+    method: 'GET',
+    timestamp: Date.now(),
+    startTime: 0,
+    type: 'fetch'
+  }
+}
+
+describe('mergeNetworkRequests', () => {
+  it('appends new entries by id', () => {
+    const current = [req('1', '/a')]
+    const next = mergeNetworkRequests(current, [req('2', '/b')])
+    expect(next).toHaveLength(2)
+    expect(next.map((r) => r.id)).toEqual(['1', '2'])
+  })
+
+  it('updates an existing entry when ids match', () => {
+    const current = [req('1', '/a'), req('2', '/b')]
+    const next = mergeNetworkRequests(current, [req('1', '/a-updated')])
+    expect(next).toHaveLength(2)
+    expect(next[0].url).toBe('/a-updated')
+  })
+
+  it('appends id-less entries (no dedup)', () => {
+    const current = [req('1', '/a')]
+    const noId = req(undefined, '/c')
+    const next = mergeNetworkRequests(current, [noId, noId])
+    expect(next).toHaveLength(3)
+  })
+
+  it('returns a new array (does not mutate input)', () => {
+    const current = [req('1', '/a')]
+    const next = mergeNetworkRequests(current, [req('2', '/b')])
+    expect(next).not.toBe(current)
+    expect(current).toHaveLength(1)
+  })
+})
diff --git a/packages/app/tests/mark-running.test.ts b/packages/app/tests/mark-running.test.ts
new file mode 100644
index 00000000..badfb80f
--- /dev/null
+++ b/packages/app/tests/mark-running.test.ts
@@ -0,0 +1,195 @@
+import { describe, it, expect } from 'vitest'
+
+import {
+  markAllRunning,
+  markSpecificRunning,
+  markRunningAsStopped
+} from '../src/controller/mark-running.js'
+import type {
+  SuiteStatsFragment,
+  TestStatsFragment
+} from '../src/controller/types.js'
+
+type SuiteChunks = Array<Record<string, SuiteStatsFragment>>
+
+const test = (
+  uid: string,
+  overrides: Record<string, unknown> = {}
+): TestStatsFragment =>
+  ({
+    uid,
+    title: uid,
+    fullTitle: uid,
+    state: 'passed',
+    start: new Date(2026, 0, 1),
+    end: new Date(2026, 0, 2),
+    ...overrides
+  }) as never as TestStatsFragment
+
+const suite = (
+  uid: string,
+  overrides: Record<string, unknown> = {}
+): SuiteStatsFragment =>
+  ({
+    uid,
+    title: uid,
+    fullTitle: uid,
+    state: 'passed',
+    start: new Date(2026, 0, 1),
+    end: new Date(2026, 0, 2),
+    tests: [],
+    suites: [],
+    ...overrides
+  }) as never as SuiteStatsFragment
+
+const chunks = (...suites: SuiteStatsFragment[]): SuiteChunks =>
+  suites.map((s) => ({ [s.uid]: s }))
+
+describe('markAllRunning', () => {
+  it('marks the root suite and all descendants as running, clearing leaf tests', () => {
+    const input = chunks(
+      suite('root', {
+        tests: [test('t1'), test('t2')],
+        suites: [
+          suite('child', {
+            tests: [test('c1', { state: 'failed' })]
+          })
+        ]
+      })
+    )
+    const out = markAllRunning(input)
+    const root = out[0].root
+    expect(root.state).toBe('running')
+    expect(root.end).toBeUndefined()
+    expect(root.tests).toEqual([])
+    expect(root.suites?.[0]?.state).toBe('running')
+    expect(root.suites?.[0]?.tests).toEqual([])
+  })
+
+  it('skips null/undefined suite entries without throwing', () => {
+    const input = chunks(suite('a'))
+    // Inject an undefined entry — markAllRunning must preserve it.
+    ;(input[0] as Record<string, unknown>)['ghost'] = undefined
+    const out = markAllRunning(input)
+    expect(out[0].ghost).toBeUndefined()
+    expect(out[0].a.state).toBe('running')
+  })
+})
+
+describe('markSpecificRunning', () => {
+  it('marks a matched suite subtree as running when entryType is suite', () => {
+    const input = chunks(
+      suite('root', {
+        suites: [suite('target'), suite('sibling', { state: 'failed' })]
+      })
+    )
+    const out = markSpecificRunning(input, 'target', 'suite')
+    const root = out[0].root
+    const target = root.suites?.find((s) => s.uid === 'target')
+    const sibling = root.suites?.find((s) => s.uid === 'sibling')
+    expect(target?.state).toBe('running')
+    expect(target?.end).toBeUndefined()
+    expect(sibling?.state).toBe('failed') // untouched
+  })
+
+  it('marks a matched test as pending and only flips parent suite state', () => {
+    const input = chunks(
+      suite('root', {
+        state: 'passed',
+        tests: [test('t1'), test('t2', { state: 'failed' })]
+      })
+    )
+    const out = markSpecificRunning(input, 't1', 'test')
+    const root = out[0].root
+    const t1 = root.tests?.find((t) => t.uid === 't1')
+    const t2 = root.tests?.find((t) => t.uid === 't2')
+    expect(t1?.state).toBe('pending')
+    expect(t1?.end).toBeUndefined()
+    expect(t2?.state).toBe('failed') // untouched
+    expect(root.state).toBe('running')
+  })
+
+  it("preserves a parent suite's running start/end on a second child match", () => {
+    const originalStart = new Date(2026, 0, 1)
+    const input = chunks(
+      suite('root', {
+        state: 'running',
+        start: originalStart,
+        end: undefined,
+        tests: [test('t1', { state: 'pending' })]
+      })
+    )
+    const out = markSpecificRunning(input, 't1', 'test')
+    expect(out[0].root.start).toEqual(originalStart) // not reset
+  })
+
+  it('returns the suite unchanged when no descendant matches', () => {
+    const input = chunks(
+      suite('root', {
+        state: 'passed',
+        tests: [test('t1')]
+      })
+    )
+    const out = markSpecificRunning(input, 'no-such-uid', 'test')
+    expect(out[0].root.state).toBe('passed')
+    expect(out[0].root.tests?.[0]?.state).toBe('passed')
+  })
+})
+
+describe('markRunningAsStopped', () => {
+  it('marks running tests (no end) as failed with a TestStoppedError', () => {
+    const input = chunks(
+      suite('root', {
+        tests: [test('t1', { state: 'running', end: null })]
+      })
+    )
+    const out = markRunningAsStopped(input)
+    const t1 = out[0].root.tests?.[0]
+    expect(t1?.state).toBe('failed')
+    expect(t1?.error?.name).toBe('TestStoppedError')
+    expect(t1?.end).toBeInstanceOf(Date)
+  })
+
+  it('leaves already-terminal tests untouched', () => {
+    const input = chunks(
+      suite('root', {
+        tests: [test('t1', { state: 'passed' })]
+      })
+    )
+    const out = markRunningAsStopped(input)
+    expect(out[0].root.tests?.[0]?.state).toBe('passed')
+    expect(out[0].root.tests?.[0]?.error).toBeUndefined()
+  })
+
+  it('derives suite state="failed" when no terminal children remain after stop', () => {
+    const input = chunks(
+      suite('root', {
+        state: 'running',
+        end: null,
+        tests: [test('t1', { state: 'running', end: null })]
+      })
+    )
+    const out = markRunningAsStopped(input)
+    expect(out[0].root.state).toBe('failed')
+    expect(out[0].root.end).toBeInstanceOf(Date)
+  })
+
+  it('recurses into nested suites', () => {
+    const input = chunks(
+      suite('root', {
+        state: 'running',
+        end: null,
+        suites: [
+          suite('child', {
+            state: 'running',
+            end: null,
+            tests: [test('c1', { state: 'running', end: null })]
+          })
+        ]
+      })
+    )
+    const out = markRunningAsStopped(input)
+    expect(out[0].root.suites?.[0]?.state).toBe('failed')
+    expect(out[0].root.suites?.[0]?.tests?.[0]?.state).toBe('failed')
+  })
+})
diff --git a/packages/app/tests/run-detection.test.ts b/packages/app/tests/run-detection.test.ts
new file mode 100644
index 00000000..10037e22
--- /dev/null
+++ b/packages/app/tests/run-detection.test.ts
@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest'
+
+import {
+  shouldResetForNewRun,
+  type RunDetectionState
+} from '../src/controller/run-detection.js'
+import type { SuiteStatsFragment } from '../src/controller/types.js'
+
+type SuiteChunks = Array<Record<string, SuiteStatsFragment>>
+
+const state = (
+  overrides: Partial<RunDetectionState> = {}
+): RunDetectionState => ({
+  lastSeenRunTimestamp: 0,
+  activeRerunSuiteUid: undefined,
+  ...overrides
+})
+
+const suite = (
+  uid: string,
+  overrides: Record<string, unknown> = {}
+): SuiteStatsFragment =>
+  ({
+    uid,
+    title: uid,
+    fullTitle: uid,
+    state: 'passed',
+    start: new Date(2026, 0, 1, 10, 0, 0),
+    end: new Date(2026, 0, 1, 10, 5, 0),
+    tests: [],
+    suites: [],
+    ...overrides
+  }) as never as SuiteStatsFragment
+
+const chunks = (...suites: SuiteStatsFragment[]): SuiteChunks =>
+  suites.map((s) => ({ [s.uid]: s }))
+
+describe('shouldResetForNewRun', () => {
+  it('returns false when an active rerun is in progress', () => {
+    const incoming = chunks(suite('root', { start: new Date(2026, 0, 2) }))
+    const existing = chunks(suite('root'))
+    const result = shouldResetForNewRun(
+      incoming,
+      state({ activeRerunSuiteUid: 'root' }),
+      existing
+    )
+    expect(result.shouldReset).toBe(false)
+    // Tracker still advances so the post-rerun final update isn't mis-detected.
+    expect(result.newLastSeenTimestamp).toBeGreaterThan(0)
+  })
+
+  it('returns true when a newer start arrives AND the previous run was finished', () => {
+    const oldStart = new Date(2026, 0, 1, 10, 0, 0).getTime()
+    const incoming = chunks(
+      suite('root', { start: new Date(2026, 0, 1, 11, 0, 0) })
+    )
+    const existing = chunks(
+      suite('root', { end: new Date(2026, 0, 1, 10, 30, 0) })
+    )
+    const result = shouldResetForNewRun(
+      incoming,
+      state({ lastSeenRunTimestamp: oldStart }),
+      existing
+    )
+    expect(result.shouldReset).toBe(true)
+  })
+
+  it('treats an ongoing previous run as a continuation (no reset)', () => {
+    const oldStart = new Date(2026, 0, 1, 10, 0, 0).getTime()
+    const incoming = chunks(
+      suite('root', { start: new Date(2026, 0, 1, 11, 0, 0) })
+    )
+    // Existing root has no `end` → still running (e.g. cucumber feature
+    // spanning multiple scenarios).
+    const existing = chunks(suite('root', { end: undefined }))
+    const result = shouldResetForNewRun(
+      incoming,
+      state({ lastSeenRunTimestamp: oldStart }),
+      existing
+    )
+    expect(result.shouldReset).toBe(false)
+    // Timestamp still advances.
+    expect(result.newLastSeenTimestamp).toBeGreaterThan(oldStart)
+  })
+
+  it('returns false when no start timestamp is present', () => {
+    const incoming = chunks(suite('root', { start: undefined }))
+    const result = shouldResetForNewRun(incoming, state(), [])
+    expect(result.shouldReset).toBe(false)
+  })
+
+  it('handles array-wrapped and single-chunk payloads identically', () => {
+    const existing: SuiteChunks = []
+    const oneChunk = { root: suite('root', { start: new Date(2026, 0, 2) }) }
+    const asSingle = shouldResetForNewRun(oneChunk, state(), existing)
+    const asArray = shouldResetForNewRun([oneChunk], state(), existing)
+    expect(asSingle).toEqual(asArray)
+  })
+
+  it('skips null chunks in the payload', () => {
+    const incoming = [
+      null as unknown as Record<string, SuiteStatsFragment>,
+      { root: suite('root') }
+    ]
+    expect(() => shouldResetForNewRun(incoming, state(), [])).not.toThrow()
+  })
+})
diff --git a/packages/app/tests/runnerCapabilities.test.ts b/packages/app/tests/runnerCapabilities.test.ts
new file mode 100644
index 00000000..8fd525d0
--- /dev/null
+++ b/packages/app/tests/runnerCapabilities.test.ts
@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest'
+import type { Metadata } from '@wdio/devtools-shared'
+import {
+  getCapabilityWarning,
+  getConfigPath,
+  getFramework,
+  getLaunchCommand,
+  getRerunCommand,
+  getRunCapabilities,
+  getRunDisabledReason,
+  isRunDisabled,
+  isRunDisabledDetail
+} from '../src/components/sidebar/runnerCapabilities.js'
+import type {
+  TestEntry,
+  TestRunDetail
+} from '../src/components/sidebar/types.js'
+
+function md(options: Record<string, unknown> = {}): Metadata {
+  return { options } as unknown as Metadata
+}
+
+function entry(type: 'test' | 'suite'): TestEntry {
+  return { type, uid: 'u', label: 'u', children: [] }
+}
+function detail(entryType: 'test' | 'suite'): TestRunDetail {
+  return { entryType, uid: 'u' }
+}
+
+describe('getFramework', () => {
+  it('reads options.framework', () => {
+    expect(getFramework(md({ framework: 'wdio' }))).toBe('wdio')
+  })
+  it('undefined when metadata missing', () => {
+    expect(getFramework(undefined)).toBeUndefined()
+  })
+})
+
+describe('getRunCapabilities', () => {
+  it('returns explicit runCapabilities merged over defaults', () => {
+    const caps = getRunCapabilities(
+      md({ runCapabilities: { canRunTests: false } })
+    )
+    expect(caps).toEqual({
+      canRunSuites: true,
+      canRunTests: false,
+      canRunAll: true
+    })
+  })
+
+  it('falls back to FRAMEWORK_CAPABILITIES by name', () => {
+    expect(getRunCapabilities(md({ framework: 'cucumber' })).canRunTests).toBe(
+      false
+    )
+  })
+
+  it('returns DEFAULT_CAPABILITIES when framework unknown', () => {
+    expect(getRunCapabilities(md({ framework: 'unknown-x' }))).toEqual({
+      canRunSuites: true,
+      canRunTests: true,
+      canRunAll: true
+    })
+  })
+})
+
+describe('isRunDisabled / isRunDisabledDetail', () => {
+  it('disables test runs when canRunTests is false', () => {
+    const m = md({ runCapabilities: { canRunTests: false } })
+    expect(isRunDisabled(m, entry('test'))).toBe(true)
+    expect(isRunDisabledDetail(m, detail('test'))).toBe(true)
+    expect(isRunDisabled(m, entry('suite'))).toBe(false)
+  })
+
+  it('disables suite runs when canRunSuites is false', () => {
+    const m = md({ runCapabilities: { canRunSuites: false } })
+    expect(isRunDisabled(m, entry('suite'))).toBe(true)
+    expect(isRunDisabledDetail(m, detail('suite'))).toBe(true)
+    expect(isRunDisabled(m, entry('test'))).toBe(false)
+  })
+})
+
+describe('getRunDisabledReason', () => {
+  it('returns undefined when run is allowed', () => {
+    expect(getRunDisabledReason(md({}), entry('test'))).toBeUndefined()
+  })
+  it('phrases reason per type', () => {
+    const m = md({ runCapabilities: { canRunTests: false } })
+    expect(getRunDisabledReason(m, entry('test'))).toContain('Single-test')
+    const m2 = md({ runCapabilities: { canRunSuites: false } })
+    expect(getRunDisabledReason(m2, entry('suite'))).toContain('Suite')
+  })
+})
+
+describe('getCapabilityWarning', () => {
+  it('phrases warning per detail entryType', () => {
+    expect(getCapabilityWarning(detail('test'))).toContain('Single-test')
+    expect(getCapabilityWarning(detail('suite'))).toContain('Suite')
+  })
+})
+
+describe('config + command getters', () => {
+  it('getConfigPath prefers configFilePath over configFile', () => {
+    expect(getConfigPath(md({ configFilePath: '/a', configFile: '/b' }))).toBe(
+      '/a'
+    )
+    expect(getConfigPath(md({ configFile: '/b' }))).toBe('/b')
+    expect(getConfigPath(md({}))).toBeUndefined()
+  })
+
+  it('getRerunCommand / getLaunchCommand pluck from options', () => {
+    expect(getRerunCommand(md({ rerunCommand: 'a' }))).toBe('a')
+    expect(getLaunchCommand(md({ launchCommand: 'b' }))).toBe('b')
+    expect(getRerunCommand(undefined)).toBeUndefined()
+    expect(getLaunchCommand(undefined)).toBeUndefined()
+  })
+})
diff --git a/packages/app/tests/suite-merge.test.ts b/packages/app/tests/suite-merge.test.ts
new file mode 100644
index 00000000..3fe23b9b
--- /dev/null
+++ b/packages/app/tests/suite-merge.test.ts
@@ -0,0 +1,260 @@
+import { describe, it, expect } from 'vitest'
+
+import {
+  canonicalKey,
+  canonicalizeUids,
+  mergeTests,
+  mergeChildSuites,
+  mergeSuite,
+  type MergeContext
+} from '../src/controller/suite-merge.js'
+import type {
+  SuiteStatsFragment,
+  TestStatsFragment
+} from '../src/controller/types.js'
+
+const ctx = (override: Partial<MergeContext> = {}): MergeContext => ({
+  activeRerunTestUid: undefined,
+  activeRerunSuiteUid: undefined,
+  ...override
+})
+
+// Tests use `number` start/end values for terseness — the fragment types
+// declare `Date` (from @wdio/reporter), but the merge logic only compares
+// via `getTimestamp` which accepts both shapes. Cast through `as never` to
+// bypass the structural mismatch.
+const test = (
+  uid: string,
+  overrides: Record<string, unknown> = {}
+): TestStatsFragment =>
+  ({
+    uid,
+    title: uid,
+    fullTitle: uid,
+    state: 'passed',
+    start: 1000,
+    end: 2000,
+    ...overrides
+  }) as never as TestStatsFragment
+
+const suite = (
+  uid: string,
+  overrides: Record<string, unknown> = {}
+): SuiteStatsFragment =>
+  ({
+    uid,
+    title: uid,
+    fullTitle: uid,
+    state: 'passed',
+    start: 1000,
+    end: 2000,
+    tests: [],
+    suites: [],
+    ...overrides
+  }) as never as SuiteStatsFragment
+
+describe('canonicalKey', () => {
+  it('builds a stable key from file + featureLine + fullTitle', () => {
+    expect(
+      canonicalKey({
+        uid: 'a',
+        file: '/path/login.feature',
+        featureFile: '/path/login.feature',
+        featureLine: 5,
+        fullTitle: 'logs in'
+      } as TestStatsFragment)
+    ).toBe('/path/login.feature::/path/login.feature:5::logs in')
+  })
+
+  it('returns undefined when there is nothing to key on', () => {
+    expect(canonicalKey({ uid: 'a' } as TestStatsFragment)).toBeUndefined()
+  })
+
+  it('falls back from fullTitle to title', () => {
+    expect(
+      canonicalKey({
+        uid: 'a',
+        file: '/x.ts',
+        title: 'fallback'
+      } as TestStatsFragment)
+    ).toBe('/x.ts:::::fallback')
+  })
+})
+
+describe('canonicalizeUids', () => {
+  it('rewrites incoming uid to existing uid when canonical keys match', () => {
+    const prev = [test('old-uid', { file: '/a.ts', fullTitle: 'login' })]
+    const next = [test('new-uid', { file: '/a.ts', fullTitle: 'login' })]
+    const result = canonicalizeUids(prev, next)
+    expect(result[0]?.uid).toBe('old-uid')
+  })
+
+  it('leaves uid alone when canonical key does not match', () => {
+    const prev = [test('old', { file: '/a.ts', fullTitle: 'login' })]
+    const next = [test('new', { file: '/b.ts', fullTitle: 'logout' })]
+    expect(canonicalizeUids(prev, next)[0]?.uid).toBe('new')
+  })
+
+  it('short-circuits when either side is empty', () => {
+    expect(canonicalizeUids([], [test('x')])).toEqual([test('x')])
+    expect(canonicalizeUids([test('x')], [])).toEqual([])
+  })
+})
+
+describe('mergeTests', () => {
+  it('replaces a test on rerun (different start time)', () => {
+    const prev = [test('t1', { state: 'failed', start: 1000, end: 2000 })]
+    const next = [test('t1', { state: 'passed', start: 5000, end: 6000 })]
+    const merged = mergeTests(prev, next, ctx())
+    expect(merged[0]?.state).toBe('passed')
+    expect(merged[0]?.start).toBe(5000)
+  })
+
+  it('shallow-merges when start times match (normal update)', () => {
+    const prev = [test('t1', { state: 'running', start: 1000, end: undefined })]
+    const next = [test('t1', { state: 'passed', start: 1000, end: 2000 })]
+    const merged = mergeTests(prev, next, ctx())
+    expect(merged[0]?.state).toBe('passed')
+    expect(merged[0]?.end).toBe(2000)
+  })
+
+  it('freezes sibling tests during a single-test rerun', () => {
+    const prev = [
+      test('target', { state: 'failed', start: 1000 }),
+      test('sibling', { state: 'passed', start: 1000 })
+    ]
+    const next = [
+      test('target', { state: 'running', start: 5000 }),
+      test('sibling', { state: 'pending', start: 5000 })
+    ]
+    const merged = mergeTests(prev, next, ctx({ activeRerunTestUid: 'target' }))
+    const sibling = merged.find((t) => t.uid === 'sibling')!
+    expect(sibling.state).toBe('passed')
+    expect(sibling.start).toBe(1000)
+  })
+
+  it('preserves existing record when incoming test is pending on a rerun', () => {
+    // Mid-rerun: backend sends all tests as 'pending' first. Untouched tests
+    // must keep their previous results (state, end, start) so future updates
+    // for this run still get detected as a rerun via start-time mismatch.
+    const prev = [test('target', { state: 'failed', start: 1000, end: 2000 })]
+    const next = [test('target', { state: 'pending', start: 5000 })]
+    const merged = mergeTests(prev, next, ctx({ activeRerunTestUid: 'target' }))
+    expect(merged[0]?.state).toBe('failed')
+    expect(merged[0]?.start).toBe(1000)
+    expect(merged[0]?.end).toBe(2000)
+  })
+
+  it('inserts a brand-new test', () => {
+    expect(mergeTests([], [test('new')], ctx())[0]?.uid).toBe('new')
+  })
+})
+
+describe('mergeSuite', () => {
+  it('derives state="passed" only when all children are terminal', () => {
+    const existing = suite('s', { state: undefined, tests: [], suites: [] })
+    const incoming = suite('s', {
+      state: undefined,
+      tests: [test('t1', { state: 'passed' }), test('t2', { state: 'passed' })],
+      suites: []
+    })
+    expect(mergeSuite(existing, incoming, ctx()).state).toBe('passed')
+  })
+
+  it('derives state="failed" when any child failed', () => {
+    const existing = suite('s', { state: undefined, tests: [], suites: [] })
+    const incoming = suite('s', {
+      state: undefined,
+      tests: [test('t1', { state: 'failed' }), test('t2', { state: 'passed' })],
+      suites: []
+    })
+    expect(mergeSuite(existing, incoming, ctx()).state).toBe('failed')
+  })
+
+  it('keeps state="running" when children are still in-progress and incoming is pending', () => {
+    const existing = suite('s', { state: 'passed', tests: [], suites: [] })
+    const incoming = suite('s', {
+      state: 'pending',
+      tests: [test('t1', { state: 'running' })],
+      suites: []
+    })
+    expect(mergeSuite(existing, incoming, ctx()).state).toBe('running')
+  })
+
+  it('marks stale child suites as pending on full-feature rerun', () => {
+    // Feature suite re-emits with state='pending', no children yet. The stale
+    // scenario suites from the previous run must show a spinner, not their
+    // old passed/failed icons.
+    const oldChild = suite('scenario-1', { state: 'passed' })
+    const existing = suite('feature', { suites: [oldChild] })
+    const incoming = suite('feature', {
+      state: 'pending',
+      tests: [],
+      suites: [suite('scenario-1', { state: 'passed' })]
+    })
+    const merged = mergeSuite(existing, incoming, ctx())
+    expect(merged.suites?.[0]?.state).toBe('pending')
+    expect(merged.suites?.[0]?.end).toBeUndefined()
+  })
+
+  it('keeps sibling scenarios with their terminal state during a child-scenario rerun', () => {
+    // Scenario 2 is being rerun; the feature suite is re-emitted with
+    // state='pending' but scenario 1's state must stay 'passed'.
+    const existing = suite('feature', {
+      suites: [
+        suite('scenario-1', { state: 'passed' }),
+        suite('scenario-2', { state: 'failed' })
+      ]
+    })
+    const incoming = suite('feature', {
+      state: 'pending',
+      suites: [
+        suite('scenario-1', { state: 'passed' }),
+        suite('scenario-2', { state: 'failed' })
+      ]
+    })
+    const merged = mergeSuite(
+      existing,
+      incoming,
+      ctx({ activeRerunSuiteUid: 'scenario-2' })
+    )
+    expect(merged.suites?.find((s) => s.uid === 'scenario-1')?.state).toBe(
+      'passed'
+    )
+  })
+
+  it('strips undefined/null state from incoming to preserve existing state', () => {
+    const existing = suite('s', { state: 'passed' })
+    const incoming = suite('s', {
+      state: undefined as never,
+      tests: [test('t', { state: 'passed' })]
+    })
+    // Existing state preserved because the merge derives 'passed' from
+    // children (all terminal), but the key behavior is that incoming
+    // state=undefined doesn't clobber existing 'passed'.
+    expect(mergeSuite(existing, incoming, ctx()).state).toBe('passed')
+  })
+})
+
+describe('mergeChildSuites', () => {
+  it('combines existing + incoming suites by uid', () => {
+    const existing = [suite('a'), suite('b')]
+    const incoming = [suite('b', { state: 'failed' }), suite('c')]
+    const merged = mergeChildSuites(existing, incoming, ctx())
+    const uids = merged.map((s) => s.uid).sort()
+    expect(uids).toEqual(['a', 'b', 'c'])
+    expect(merged.find((s) => s.uid === 'b')?.state).toBe('failed')
+  })
+
+  it('canonicalizes uids before merging so rerun-renamed scenarios match', () => {
+    const existing = [
+      suite('original', { file: '/f.feature', fullTitle: 'A scenario' })
+    ]
+    const incoming = [
+      suite('renamed', { file: '/f.feature', fullTitle: 'A scenario' })
+    ]
+    const merged = mergeChildSuites(existing, incoming, ctx())
+    expect(merged).toHaveLength(1)
+    expect(merged[0]?.uid).toBe('original')
+  })
+})
diff --git a/packages/backend/README.md b/packages/backend/README.md
index 9531a576..6686cc78 100644
--- a/packages/backend/README.md
+++ b/packages/backend/README.md
@@ -1,3 +1,21 @@
-# WebdriverIO DevTools Backend
+# @wdio/devtools-backend
 
+The server that the three adapter packages connect to and the dashboard UI talks to. Internal to the monorepo — not published.
 
+## Responsibilities
+
+- **Fastify HTTP server** — REST endpoints for preserve/clear/run/stop and the dashboard's baseline pair lookups.
+- **WebSocket gateway** — one connection per adapter worker, one per dashboard client. Adapter events fan out to every connected dashboard.
+- **Baseline store** (in-memory) — captures a snapshot of a failing test attempt, plus per-uid metadata, so the "Preserve & Rerun" flow can show a side-by-side diff.
+- **Rerun spawner** (`runner.ts`) — spawns the user's `wdio` / `nightwatch` / `selenium` binary with rerun filters built from the dashboard's payload.
+- **Worker-message handler** — dispatches messages from spawned workers (config path, session id, video path, ...).
+
+## Framework awareness
+
+Lives only in `runner.ts` and `framework-filters.ts`. Both branch on a typed `TestRunnerId` from `@wdio/devtools-shared` (never a magic string). `framework-filters.ts` uses an explicit `switch` over the runner id rather than a Map/object lookup so CodeQL's `unvalidated-dynamic-method-call` query trusts the dispatch.
+
+## Public API
+
+The backend is consumed only by other workspace packages. Adapter launchers call `start({ port, hostname })` and receive the bound port. The dashboard accesses it via the documented HTTP routes (`packages/shared/src/baseline.ts`, `packages/shared/src/runner.ts`) and WS scopes (`packages/shared/src/ws.ts`, `packages/shared/src/routes.ts`).
+
+For the full picture of how events flow adapter → backend → dashboard, see [ARCHITECTURE.md](../../ARCHITECTURE.md).
diff --git a/packages/backend/package.json b/packages/backend/package.json
index 235d8c95..5c7c9e75 100644
--- a/packages/backend/package.json
+++ b/packages/backend/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@wdio/devtools-backend",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Backend service to spin up WebdriverIO Devtools",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -17,29 +17,31 @@
   "typeScriptVersion": "^5.0.0",
   "scripts": {
     "dev": "run-p dev:*",
-    "dev:ts": "tsc --watch",
+    "dev:ts": "tsup src/index.ts --format esm --dts --watch",
     "dev:app": "nodemon --watch ./dist ./dist/index.js",
-    "build": "tsc -p ./tsconfig.json",
+    "build": "tsup src/index.ts --format esm --dts --clean",
     "lint": "eslint .",
     "prepublishOnly": "pnpm build"
   },
   "dependencies": {
     "@fastify/rate-limit": "^10.3.0",
-    "@fastify/static": "^9.0.0",
+    "@fastify/static": "^9.1.3",
     "@fastify/websocket": "^11.2.0",
-    "@wdio/cli": "9.27.0",
+    "@wdio/cli": "9.27.2",
     "@wdio/devtools-app": "workspace:^",
     "@wdio/logger": "9.18.0",
-    "fastify": "^5.8.4",
-    "get-port": "^7.1.0",
-    "import-meta-resolve": "^4.1.0",
-    "shell-quote": "^1.8.3",
-    "tree-kill": "^1.2.2"
+    "fastify": "^5.8.5",
+    "get-port": "^7.2.0",
+    "import-meta-resolve": "^4.2.0",
+    "shell-quote": "^1.8.4",
+    "tree-kill": "^1.2.2",
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@types/shell-quote": "^1.7.5",
     "@types/ws": "^8.18.1",
+    "@wdio/devtools-shared": "workspace:^",
     "nodemon": "^3.1.14",
-    "ws": "^8.18.3"
+    "tsup": "^8.5.1"
   }
 }
diff --git a/packages/backend/src/baseline/constants.ts b/packages/backend/src/baseline/constants.ts
deleted file mode 100644
index d958b741..00000000
--- a/packages/backend/src/baseline/constants.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export const BASELINE_API = {
-  preserve: '/api/baseline/preserve',
-  clear: '/api/baseline/clear',
-  get: '/api/baseline/:testUid'
-} as const
-
-export const BASELINE_WS_SCOPE = {
-  saved: 'baseline:saved',
-  cleared: 'baseline:cleared'
-} as const
-
-export type BaselineWsScope =
-  (typeof BASELINE_WS_SCOPE)[keyof typeof BASELINE_WS_SCOPE]
diff --git a/packages/backend/src/baseline/types.ts b/packages/backend/src/baseline/types.ts
index c0729245..a7211761 100644
--- a/packages/backend/src/baseline/types.ts
+++ b/packages/backend/src/baseline/types.ts
@@ -1,40 +1,28 @@
-export interface CommandLogLike {
-  timestamp: number
-  [key: string]: unknown
-}
-
-export interface ConsoleLogLike {
-  timestamp: number
-  [key: string]: unknown
-}
-
-export interface NetworkRequestLike {
-  id?: string
-  timestamp: number
-  startTime?: number
-  endTime?: number
-  [key: string]: unknown
-}
-
+import type {
+  CommandLog,
+  ConsoleLog,
+  NetworkRequest,
+  TestError,
+  TestStatus
+} from '@wdio/devtools-shared'
+
+// Backend storage uses the canonical shared types. The `*Like` aliases below
+// are kept so existing backend code that referenced them continues to compile;
+// new code should use the shared types directly.
+export type CommandLogLike = CommandLog
+export type ConsoleLogLike = ConsoleLog
+export type NetworkRequestLike = NetworkRequest
+
+// Mutations stay loose: the concrete shape (TraceMutation) lives in
+// packages/script (browser-side, depends on DOM types) and isn't safe to
+// import here.
 export interface MutationLike {
   timestamp: number
   [key: string]: unknown
 }
 
-export type NodeState = 'passed' | 'failed' | 'skipped' | 'pending' | 'running'
-
-export interface NodeError {
-  message?: string
-  name?: string
-  stack?: string
-  expected?: unknown
-  actual?: unknown
-  matcherResult?: {
-    expected?: unknown
-    actual?: unknown
-    message?: string
-  }
-}
+export type NodeState = TestStatus
+export type NodeError = TestError
 
 export interface TimeWindowNode {
   uid: string
@@ -50,44 +38,12 @@ export interface TimeWindowNode {
   childUids: string[]
 }
 
-export interface PreservedStep {
-  uid: string
-  title?: string
-  fullTitle?: string
-  start?: number
-  end?: number
-  state?: NodeState
-  error?: NodeError
-}
-
-export interface PreservedAttempt {
-  testUid: string
-  scope: 'test' | 'suite'
-  capturedAt: number
-  window: { start: number; end: number }
-  test: {
-    title?: string
-    fullTitle?: string
-    file?: string
-    callSource?: string
-    start?: number
-    end?: number
-    duration?: number
-    state?: NodeState
-    error?: NodeError
-  }
-  steps?: PreservedStep[]
-  commands: CommandLogLike[]
-  consoleLogs: ConsoleLogLike[]
-  networkRequests: NetworkRequestLike[]
-  mutations: MutationLike[]
-  sources: Record<string, string>
-}
+export type { PreservedAttempt, PreservedStep } from '@wdio/devtools-shared'
 
 export interface ActiveRun {
-  commands: CommandLogLike[]
-  consoleLogs: ConsoleLogLike[]
-  networkRequests: NetworkRequestLike[]
+  commands: CommandLog[]
+  consoleLogs: ConsoleLog[]
+  networkRequests: NetworkRequest[]
   mutations: MutationLike[]
   sources: Record<string, string>
   nodes: Map<string, TimeWindowNode>
diff --git a/packages/backend/src/baselineStore.ts b/packages/backend/src/baselineStore.ts
index 4b5f2efd..d504f9c1 100644
--- a/packages/backend/src/baselineStore.ts
+++ b/packages/backend/src/baselineStore.ts
@@ -266,6 +266,43 @@ class BaselineStore {
     return node.error
   }
 
+  #collectStepsRecursive(node: TimeWindowNode, steps: PreservedStep[]): void {
+    if (node.kind === 'test') {
+      steps.push({
+        uid: node.uid,
+        title: node.title,
+        fullTitle: node.fullTitle,
+        start: node.start,
+        end: node.end,
+        state: node.state,
+        error: node.error
+      })
+    }
+    for (const childUid of node.childUids) {
+      const child = this.#activeRun.nodes.get(childUid)
+      if (child) {
+        this.#collectStepsRecursive(child, steps)
+      }
+    }
+  }
+
+  #buildTestSnapshot(node: TimeWindowNode): PreservedAttempt['test'] {
+    return {
+      title: node.title,
+      fullTitle: node.fullTitle,
+      file: node.file,
+      callSource: node.callSource,
+      start: node.start,
+      end: node.end,
+      duration:
+        node.start !== undefined && node.end !== undefined
+          ? node.end - node.start
+          : undefined,
+      state: this.#deriveState(node),
+      error: this.#deriveError(node)
+    }
+  }
+
   snapshot(uid: string, scope: 'test' | 'suite'): PreservedAttempt | undefined {
     const node = this.#activeRun.nodes.get(uid)
     if (!node) {
@@ -275,7 +312,6 @@ class BaselineStore {
     if (!window) {
       return undefined
     }
-
     const inWindow = (t: number | undefined) =>
       t !== undefined && t >= window.start && t <= window.end
     const inWindowSpan = (start?: number, end?: number) => {
@@ -283,48 +319,14 @@ class BaselineStore {
       const e = end ?? start ?? Date.now()
       return e >= window.start && s <= window.end
     }
-
     const steps: PreservedStep[] = []
-    const collectSteps = (n: TimeWindowNode) => {
-      if (n.kind === 'test') {
-        steps.push({
-          uid: n.uid,
-          title: n.title,
-          fullTitle: n.fullTitle,
-          start: n.start,
-          end: n.end,
-          state: n.state,
-          error: n.error
-        })
-      }
-      for (const childUid of n.childUids) {
-        const child = this.#activeRun.nodes.get(childUid)
-        if (child) {
-          collectSteps(child)
-        }
-      }
-    }
-    collectSteps(node)
-
+    this.#collectStepsRecursive(node, steps)
     return {
       testUid: uid,
       scope,
       capturedAt: Date.now(),
       window,
-      test: {
-        title: node.title,
-        fullTitle: node.fullTitle,
-        file: node.file,
-        callSource: node.callSource,
-        start: node.start,
-        end: node.end,
-        duration:
-          node.start !== undefined && node.end !== undefined
-            ? node.end - node.start
-            : undefined,
-        state: this.#deriveState(node),
-        error: this.#deriveError(node)
-      },
+      test: this.#buildTestSnapshot(node),
       steps: steps.length > 0 ? steps : undefined,
       commands: this.#activeRun.commands.filter((c) => inWindow(c.timestamp)),
       consoleLogs: this.#activeRun.consoleLogs.filter((c) =>
diff --git a/packages/backend/src/bin-resolver.ts b/packages/backend/src/bin-resolver.ts
new file mode 100644
index 00000000..f5ac6414
--- /dev/null
+++ b/packages/backend/src/bin-resolver.ts
@@ -0,0 +1,95 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import { RUNNER_ENV } from '@wdio/devtools-shared'
+
+const require = createRequire(import.meta.url)
+
+/**
+ * Resolve the nightwatch CLI entry point. Honors `DEVTOOLS_NIGHTWATCH_BIN`
+ * for testing/override; otherwise walks up from `baseDir` looking for
+ * `node_modules/nightwatch/package.json` and resolves its `bin` to the
+ * actual JS entry (avoids running the shell-script wrapper at
+ * `node_modules/.bin/nightwatch` via node).
+ */
+export function resolveNightwatchBin(baseDir: string): string {
+  const envOverride = process.env[RUNNER_ENV.NIGHTWATCH_BIN]
+  if (envOverride) {
+    const resolved = path.isAbsolute(envOverride)
+      ? envOverride
+      : path.resolve(process.cwd(), envOverride)
+    if (fs.existsSync(resolved)) {
+      return resolved
+    }
+  }
+
+  let dir = baseDir
+  const root = path.parse(dir).root
+  while (dir !== root) {
+    const nightwatchPkgPath = path.join(
+      dir,
+      'node_modules',
+      'nightwatch',
+      'package.json'
+    )
+    if (fs.existsSync(nightwatchPkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(nightwatchPkgPath, 'utf8'))
+        const nightwatchDir = path.join(dir, 'node_modules', 'nightwatch')
+        const binEntry =
+          typeof pkg.bin === 'string'
+            ? pkg.bin
+            : (pkg.bin?.nightwatch ?? pkg.bin?.nw)
+        if (binEntry) {
+          const jsPath = path.resolve(nightwatchDir, binEntry)
+          if (fs.existsSync(jsPath)) {
+            return jsPath
+          }
+        }
+      } catch {
+        // malformed package.json — continue walking
+      }
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) {
+      break
+    }
+    dir = parent
+  }
+
+  throw new Error(
+    'Cannot find nightwatch binary. Install nightwatch locally or set DEVTOOLS_NIGHTWATCH_BIN env var.'
+  )
+}
+
+/**
+ * Resolve the wdio CLI entry. Honors `DEVTOOLS_WDIO_BIN`; otherwise derives
+ * from the `@wdio/cli` package's location (the published `bin/wdio.js`).
+ */
+export function resolveWdioBin(): string {
+  const envOverride = process.env[RUNNER_ENV.WDIO_BIN]
+  if (envOverride) {
+    const overriddenPath = path.isAbsolute(envOverride)
+      ? envOverride
+      : path.resolve(process.cwd(), envOverride)
+    if (!fs.existsSync(overriddenPath)) {
+      throw new Error(
+        `DEVTOOLS_WDIO_BIN "${overriddenPath}" does not exist or is not accessible`
+      )
+    }
+    return overriddenPath
+  }
+
+  try {
+    const cliEntry = require.resolve('@wdio/cli')
+    const candidate = path.resolve(path.dirname(cliEntry), '../bin/wdio.js')
+    if (!fs.existsSync(candidate)) {
+      throw new Error(`Derived WDIO bin "${candidate}" does not exist`)
+    }
+    return candidate
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve WDIO binary. Provide DEVTOOLS_WDIO_BIN env var. ${(error as Error).message}`
+    )
+  }
+}
diff --git a/packages/backend/src/framework-filters.ts b/packages/backend/src/framework-filters.ts
new file mode 100644
index 00000000..92ff8290
--- /dev/null
+++ b/packages/backend/src/framework-filters.ts
@@ -0,0 +1,147 @@
+import type { RunnerRequestBody } from '@wdio/devtools-shared'
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+export type FilterBuilder = (ctx: {
+  specArg?: string
+  payload: RunnerRequestBody
+}) => string[]
+
+// Each runner's filter builder is a named const — `getFilterBuilder` dispatches
+// via an explicit `switch` over the (untrusted) runner-id string instead of a
+// table lookup. This closes CodeQL's `unvalidated-dynamic-method-call`
+// finding: the call site sees a closed set of statically-known callables.
+
+const buildCucumberFilters: FilterBuilder = ({ specArg, payload }) => {
+  const filters: string[] = []
+
+  // Feature-level suites run the entire feature file
+  if (payload.suiteType === 'feature' && specArg) {
+    const featureFile = specArg.split(':')[0]
+    filters.push('--spec', featureFile)
+    return filters
+  }
+
+  // Priority 1: feature file with line number for exact scenario targeting
+  // (works for examples). Note: Cucumber scenarios are type 'suite', not 'test'.
+  if (payload.featureFile && payload.featureLine) {
+    filters.push('--spec', `${payload.featureFile}:${payload.featureLine}`)
+    return filters
+  }
+
+  // Priority 2: specific test reruns with an example row number use an
+  // exact regex match.
+  if (payload.entryType === 'test' && payload.fullTitle) {
+    // Cucumber fullTitle format: "1: Scenario name" or "2: Scenario name".
+    // Avoid ReDoS by removing ambiguous \s* before .* — use string ops instead.
+    const colonIndex = payload.fullTitle.indexOf(':')
+    if (colonIndex > 0) {
+      const rowNumber = payload.fullTitle.substring(0, colonIndex)
+      const scenarioName = payload.fullTitle.substring(colonIndex + 1).trim()
+      if (/^\d+$/.test(rowNumber)) {
+        if (specArg) {
+          filters.push('--spec', specArg)
+        }
+        filters.push(
+          '--cucumberOpts.name',
+          `^${rowNumber}:\\s*${escapeRegex(scenarioName)}$`
+        )
+        return filters
+      }
+    }
+    // No row number — plain name filter
+    if (specArg) {
+      filters.push('--spec', specArg)
+    }
+    filters.push('--cucumberOpts.name', payload.fullTitle.trim())
+    return filters
+  }
+
+  // Suite-level rerun
+  if (specArg) {
+    filters.push('--spec', specArg)
+  }
+  return filters
+}
+
+const buildMochaFilters: FilterBuilder = ({ specArg, payload }) => {
+  const filters: string[] = []
+  if (specArg) {
+    filters.push('--spec', specArg)
+  }
+  if (payload.fullTitle) {
+    filters.push('--mochaOpts.grep', payload.fullTitle)
+  }
+  return filters
+}
+
+const buildJasmineFilters: FilterBuilder = ({ specArg, payload }) => {
+  const filters: string[] = []
+  if (specArg) {
+    filters.push('--spec', specArg)
+  }
+  if (payload.fullTitle) {
+    filters.push('--jasmineOpts.grep', payload.fullTitle)
+  }
+  return filters
+}
+
+// Nightwatch CLI: positional spec file + optional --testcase filter
+const buildNightwatchFilters: FilterBuilder = ({ specArg, payload }) => {
+  const filters: string[] = []
+  if (specArg) {
+    // Nightwatch doesn't support file:line — strip any trailing line number
+    filters.push(specArg.split(':')[0])
+  }
+  if (payload.entryType === 'test' && payload.label) {
+    filters.push('--testcase', payload.label)
+  }
+  return filters
+}
+
+// Nightwatch + Cucumber: feature files are resolved via the config's
+// feature_path. Never pass .feature files as positional args — Nightwatch
+// rejects them. Nightwatch forwards --name and --tags to underlying Cucumber.
+const buildNightwatchCucumberFilters: FilterBuilder = ({ payload }) => {
+  const filters: string[] = []
+  // Only pass --name for scenario-level reruns. Feature/file-level suites
+  // (suiteType === 'feature') run all their scenarios, so no --name filter.
+  const isFeatureLevel = payload.suiteType === 'feature' || payload.runAll
+  if (!isFeatureLevel && payload.fullTitle) {
+    // Wrap as an anchored exact regex so "Scenario A" never also matches
+    // "Scenario A-1" (Cucumber treats --name as a regex).
+    const escaped = escapeRegex(payload.fullTitle)
+    filters.push('--name', `^${escaped}$`)
+  }
+  return filters
+}
+
+const DEFAULT_FILTERS: FilterBuilder = ({ specArg }) =>
+  specArg ? ['--spec', specArg] : []
+
+/**
+ * Resolve the filter builder for a given runner, falling back to spec-only.
+ *
+ * Takes `string | undefined` (not `TestRunnerId`) so callers can pass the
+ * raw HTTP-payload value without a cast. The switch enumerates every
+ * supported runner explicitly — closes CodeQL's
+ * `js/unvalidated-dynamic-method-call` finding at the call site.
+ */
+export function getFilterBuilder(runnerId: string | undefined): FilterBuilder {
+  switch (runnerId) {
+    case 'cucumber':
+      return buildCucumberFilters
+    case 'mocha':
+      return buildMochaFilters
+    case 'jasmine':
+      return buildJasmineFilters
+    case 'nightwatch':
+      return buildNightwatchFilters
+    case 'nightwatch-cucumber':
+      return buildNightwatchCucumberFilters
+    default:
+      return DEFAULT_FILTERS
+  }
+}
diff --git a/packages/backend/src/index.ts b/packages/backend/src/index.ts
index a6cda5a1..300ffcf2 100644
--- a/packages/backend/src/index.ts
+++ b/packages/backend/src/index.ts
@@ -1,7 +1,11 @@
 import fs from 'node:fs'
 import url from 'node:url'
 
-import Fastify, { type FastifyInstance, type FastifyRequest } from 'fastify'
+import Fastify, {
+  type FastifyInstance,
+  type FastifyReply,
+  type FastifyRequest
+} from 'fastify'
 import staticServer from '@fastify/static'
 import rateLimit from '@fastify/rate-limit'
 import websocket from '@fastify/websocket'
@@ -13,7 +17,19 @@ import { getDevtoolsApp } from './utils.js'
 import { DEFAULT_PORT } from './constants.js'
 import { testRunner } from './runner.js'
 import { baselineStore } from './baselineStore.js'
-import { BASELINE_API, BASELINE_WS_SCOPE } from './baseline/constants.js'
+import { createWorkerMessageHandler } from './worker-message-handler.js'
+import {
+  BASELINE_API,
+  BASELINE_WS_SCOPE,
+  WS_PATHS,
+  WS_SCOPE,
+  type BaselinePreserveRequest,
+  type BaselineClearRequest,
+  type BaselineGetParams,
+  type BaselineGetQuery,
+  type BaselineSavedWsPayload,
+  type BaselineClearedWsPayload
+} from '@wdio/devtools-shared'
 import type { RunnerRequestBody } from './types.js'
 
 let server: FastifyInstance | undefined
@@ -28,7 +44,14 @@ const clients = new Set<WebSocket>()
 
 // Notify the worker when a UI client connects so the plugin can unblock
 // Builder.build() instead of finishing the run before the dashboard appears.
+//
+// `parentWorkerSocket` is the long-lived worker (the original test runner
+// holding the keep-alive on shutdown). `workerSocket` tracks whichever worker
+// most recently connected — typically a rerun child while it runs. Outbound
+// signals like `clientDisconnected` go to the PARENT, otherwise a closed
+// rerun-child leaves the parent unreachable and `clientDisconnected` is lost.
 let workerSocket: WebSocket | undefined
+let parentWorkerSocket: WebSocket | undefined
 
 // sessionId → absolute path of the encoded .webm; queried by /api/video/:sessionId.
 const videoRegistry = new Map<string, string>()
@@ -59,7 +82,7 @@ function replayBufferedMessages(socket: WebSocket) {
   }
 }
 
-function serveVideo(sessionId: string, reply: any) {
+function serveVideo(sessionId: string, reply: FastifyReply) {
   const videoPath = videoRegistry.get(sessionId)
   if (!videoPath) {
     return reply.code(404).send({ error: 'Video not found' })
@@ -72,138 +95,126 @@ function serveVideo(sessionId: string, reply: any) {
     .send(fs.createReadStream(videoPath))
 }
 
-export async function start(
-  opts: DevtoolsBackendOptions = {}
-): Promise<{ server: FastifyInstance; port: number }> {
-  const host = opts.hostname || 'localhost'
-  // Use getPort to find an available port, starting with the preferred port
-  const preferredPort = opts.port || DEFAULT_PORT
-  const port = await getPort({ port: preferredPort })
-
-  // Log if we had to use a different port
-  if (opts.port && port !== opts.port) {
-    log.warn(`Port ${opts.port} is already in use, using port ${port} instead`)
+async function handleTestRun(
+  body: RunnerRequestBody,
+  host: string,
+  port: number,
+  reply: FastifyReply
+): Promise<FastifyReply> {
+  if (!body?.uid || !body.entryType) {
+    return reply.code(400).send({ error: 'Invalid run payload' })
   }
-
-  const appPath = await getDevtoolsApp()
-
-  server = Fastify({ logger: true })
-  await server.register(rateLimit, {
-    max: 100,
-    timeWindow: '1 minute'
-  })
-  await server.register(websocket)
-  await server.register(staticServer, {
-    root: appPath
-  })
-
-  server.post(
-    '/api/tests/run',
-    async (request: FastifyRequest<{ Body: RunnerRequestBody }>, reply) => {
-      const body = request.body
-      if (!body?.uid || !body.entryType) {
-        return reply.code(400).send({ error: 'Invalid run payload' })
-      }
-      // Broadcast a clear so popouts (which only see WS events) wipe too.
+  // Broadcast a clear so popouts (which only see WS events) wipe too.
+  broadcastToClients(
+    JSON.stringify({
+      scope: WS_SCOPE.clearExecutionData,
+      data: { uid: body.uid, entryType: body.entryType }
+    })
+  )
+  // Plain Rerun hides the Compare tab by dropping all baselines.
+  if (!body.preserveBaseline) {
+    const clearedUids = baselineStore.clearAll()
+    for (const testUid of clearedUids) {
       broadcastToClients(
         JSON.stringify({
-          scope: 'clearExecutionData',
-          data: { uid: body.uid, entryType: body.entryType }
+          scope: BASELINE_WS_SCOPE.cleared,
+          data: { testUid }
         })
       )
-      // Plain Rerun hides the Compare tab by dropping all baselines.
-      if (!body.preserveBaseline) {
-        const clearedUids = baselineStore.clearAll()
-        for (const testUid of clearedUids) {
-          broadcastToClients(
-            JSON.stringify({
-              scope: BASELINE_WS_SCOPE.cleared,
-              data: { testUid }
-            })
-          )
-        }
-      }
-      try {
-        await testRunner.run({
-          ...body,
-          devtoolsHost: host,
-          devtoolsPort: port
-        })
-        return reply.send({ ok: true })
-      } catch (error) {
-        log.error(`Failed to start test run: ${(error as Error).message}`)
-        return reply.code(500).send({ error: (error as Error).message })
-      }
     }
+  }
+  try {
+    await testRunner.run({ ...body, devtoolsHost: host, devtoolsPort: port })
+    return reply.send({ ok: true })
+  } catch (error) {
+    log.error(`Failed to start test run: ${(error as Error).message}`)
+    return reply.code(500).send({ error: (error as Error).message })
+  }
+}
+
+function registerTestRoutes(
+  s: FastifyInstance,
+  host: string,
+  port: number
+): void {
+  s.post(
+    '/api/tests/run',
+    (request: FastifyRequest<{ Body: RunnerRequestBody }>, reply) =>
+      handleTestRun(request.body, host, port, reply)
   )
 
-  server.post('/api/tests/stop', async (_request, reply) => {
+  s.post('/api/tests/stop', async (_request, reply) => {
     testRunner.stop()
     broadcastToClients(
       JSON.stringify({
-        scope: 'testStopped',
+        scope: WS_SCOPE.testStopped,
         data: { stopped: true, timestamp: Date.now() }
       })
     )
     reply.send({ ok: true })
   })
+}
 
-  server.post(
+async function handleBaselinePreserve(
+  body: Partial<BaselinePreserveRequest>,
+  reply: FastifyReply
+): Promise<FastifyReply> {
+  const { testUid, scope } = body || {}
+  if (!testUid || (scope !== 'test' && scope !== 'suite')) {
+    return reply.code(400).send({
+      error: 'Invalid preserve payload: testUid and scope required'
+    })
+  }
+  const attempt = baselineStore.preserve(testUid, scope)
+  if (!attempt) {
+    return reply
+      .code(409)
+      .send({ error: 'No captured data for the requested uid' })
+  }
+  const payload: BaselineSavedWsPayload = { testUid, attempt }
+  broadcastToClients(
+    JSON.stringify({ scope: BASELINE_WS_SCOPE.saved, data: payload })
+  )
+  return reply.send({ ok: true, attempt })
+}
+
+async function handleBaselineClear(
+  body: Partial<BaselineClearRequest>,
+  reply: FastifyReply
+): Promise<FastifyReply> {
+  const { testUid } = body || {}
+  if (!testUid) {
+    return reply.code(400).send({ error: 'testUid required' })
+  }
+  const removed = baselineStore.clear(testUid)
+  if (removed) {
+    const payload: BaselineClearedWsPayload = { testUid }
+    broadcastToClients(
+      JSON.stringify({ scope: BASELINE_WS_SCOPE.cleared, data: payload })
+    )
+  }
+  return reply.send({ ok: true, removed })
+}
+
+function registerBaselineRoutes(s: FastifyInstance): void {
+  s.post(
     BASELINE_API.preserve,
-    async (
-      request: FastifyRequest<{
-        Body: { testUid?: string; scope?: 'test' | 'suite' }
-      }>,
+    (
+      request: FastifyRequest<{ Body: Partial<BaselinePreserveRequest> }>,
       reply
-    ) => {
-      const { testUid, scope } = request.body || {}
-      if (!testUid || (scope !== 'test' && scope !== 'suite')) {
-        return reply.code(400).send({
-          error: 'Invalid preserve payload: testUid and scope required'
-        })
-      }
-      const attempt = baselineStore.preserve(testUid, scope)
-      if (!attempt) {
-        return reply
-          .code(409)
-          .send({ error: 'No captured data for the requested uid' })
-      }
-      broadcastToClients(
-        JSON.stringify({
-          scope: BASELINE_WS_SCOPE.saved,
-          data: { testUid, attempt }
-        })
-      )
-      return reply.send({ ok: true, attempt })
-    }
+    ) => handleBaselinePreserve(request.body, reply)
   )
-
-  server.post(
+  s.post(
     BASELINE_API.clear,
-    async (request: FastifyRequest<{ Body: { testUid?: string } }>, reply) => {
-      const { testUid } = request.body || {}
-      if (!testUid) {
-        return reply.code(400).send({ error: 'testUid required' })
-      }
-      const removed = baselineStore.clear(testUid)
-      if (removed) {
-        broadcastToClients(
-          JSON.stringify({
-            scope: BASELINE_WS_SCOPE.cleared,
-            data: { testUid }
-          })
-        )
-      }
-      return reply.send({ ok: true, removed })
-    }
+    (request: FastifyRequest<{ Body: Partial<BaselineClearRequest> }>, reply) =>
+      handleBaselineClear(request.body, reply)
   )
-
-  server.get(
+  s.get(
     BASELINE_API.get,
     async (
       request: FastifyRequest<{
-        Params: { testUid: string }
-        Querystring: { scope?: 'test' | 'suite' }
+        Params: BaselineGetParams
+        Querystring: BaselineGetQuery
       }>,
       reply
     ) => {
@@ -212,9 +223,32 @@ export async function start(
       return reply.send(baselineStore.getPair(testUid, scope))
     }
   )
+}
 
-  server.get(
-    '/client',
+function handleClientWsClose(socket: WebSocket): void {
+  clients.delete(socket)
+  // Last dashboard window closed — tell the worker so it can wind down. Lets
+  // the user close Chrome to end an interactive review session under any
+  // runner. Route to the PARENT worker — it owns the keep-alive + shutdown
+  // handler. The `workerSocket` ref may point at a rerun child that's about
+  // to exit; falling back to `parentWorkerSocket` handles that (and a fresh
+  // post-rerun click before the child fully closes).
+  const target =
+    parentWorkerSocket?.readyState === WebSocket.OPEN
+      ? parentWorkerSocket
+      : workerSocket?.readyState === WebSocket.OPEN
+        ? workerSocket
+        : undefined
+  if (clients.size === 0 && target) {
+    target.send(
+      JSON.stringify({ scope: WS_SCOPE.clientDisconnected, data: {} })
+    )
+  }
+}
+
+function registerClientWebSocket(s: FastifyInstance): void {
+  s.get(
+    WS_PATHS.client,
     { websocket: true },
     (socket: WebSocket, _req: FastifyRequest) => {
       log.info(
@@ -222,28 +256,19 @@ export async function start(
       )
       replayBufferedMessages(socket)
       clients.add(socket)
-      socket.on('close', () => {
-        clients.delete(socket)
-        // Last dashboard window closed — tell the worker so it can wind
-        // down. Lets the user close Chrome to end an interactive review
-        // session under any runner.
-        if (clients.size === 0 && workerSocket?.readyState === WebSocket.OPEN) {
-          workerSocket.send(
-            JSON.stringify({ scope: 'clientDisconnected', data: {} })
-          )
-        }
-      })
-
+      socket.on('close', () => handleClientWsClose(socket))
       if (workerSocket?.readyState === WebSocket.OPEN) {
         workerSocket.send(
-          JSON.stringify({ scope: 'clientConnected', data: {} })
+          JSON.stringify({ scope: WS_SCOPE.clientConnected, data: {} })
         )
       }
     }
   )
+}
 
-  server.get(
-    '/worker',
+function registerWorkerWebSocket(s: FastifyInstance): void {
+  s.get(
+    WS_PATHS.worker,
     { websocket: true },
     (socket: WebSocket, _req: FastifyRequest) => {
       // Don't drop the message buffer for rerun-child connects (the dashboard
@@ -257,86 +282,41 @@ export async function start(
         baselineStore.resetActiveRun()
       }
       workerSocket = socket
+      if (!isRerunChild) {
+        parentWorkerSocket = socket
+      }
       socket.on('close', () => {
         if (workerSocket === socket) {
           workerSocket = undefined
         }
+        if (parentWorkerSocket === socket) {
+          parentWorkerSocket = undefined
+        }
       })
       if (clients.size > 0) {
-        socket.send(JSON.stringify({ scope: 'clientConnected', data: {} }))
-      }
-      socket.on('message', (message: Buffer) => {
-        // Use `debug` — at `info` level this feeds the worker's stream
-        // capture and creates a backend↔capture loop.
-        log.debug(
-          `received ${message.length} byte message from worker to ${clients.size} client${clients.size > 1 ? 's' : ''}`
+        socket.send(
+          JSON.stringify({ scope: WS_SCOPE.clientConnected, data: {} })
         )
-
-        try {
-          const parsed = JSON.parse(message.toString())
-
-          if (parsed.scope === 'clearCommands') {
-            const testUid = parsed.data?.testUid
-            log.info(`Clearing commands for test: ${testUid || 'all'}`)
-            // Mirror the dashboard's reset behavior: clearing without a uid
-            // is a full reset, so wipe the baseline accumulator too.
-            if (!testUid) {
-              baselineStore.resetActiveRun()
-            }
-            broadcastToClients(
-              JSON.stringify({
-                scope: 'clearExecutionData',
-                data: { uid: testUid }
-              })
-            )
-            return
-          }
-
-          if (parsed.scope === 'config' && parsed.data?.configFile) {
-            testRunner.registerConfigFile(parsed.data.configFile)
-            log.info(
-              `Registered config file for reruns: ${parsed.data.configFile}`
-            )
-            return
-          }
-
-          // Intercept screencast messages: store the absolute videoPath in the
-          // registry (backend-only), then forward only the sessionId to the UI
-          // so the UI can request the video via GET /api/video/:sessionId.
-          if (parsed.scope === 'screencast' && parsed.data?.sessionId) {
-            const { sessionId, videoPath } = parsed.data
-            if (videoPath) {
-              videoRegistry.set(sessionId, videoPath)
-              log.info(
-                `Screencast registered for session ${sessionId}: ${videoPath}`
-              )
-            }
-            broadcastToClients(
-              JSON.stringify({
-                scope: 'screencast',
-                data: { sessionId }
-              })
-            )
-            return
-          }
-          // Tee the event into the baseline accumulator for time-window
-          // partitioning at preserve time. Done after special-case handling
-          // so we don't accumulate control frames (clearCommands, screencast).
-          baselineStore.recordEvent(parsed.scope, parsed.data)
-        } catch {
-          // Not JSON or parsing failed, forward as-is
-        }
-
-        // Forward all other messages as-is
-        broadcastToClients(message.toString())
-      })
+      }
+      socket.on(
+        'message',
+        createWorkerMessageHandler({
+          baselineStore,
+          testRunner,
+          videoRegistry,
+          broadcastToClients,
+          clientCount: () => clients.size
+        })
+      )
     }
   )
+}
 
-  server.get(
+function registerVideoRoute(s: FastifyInstance): void {
+  s.get(
     '/api/video/:sessionId',
     {
-      preHandler: server.rateLimit({
+      preHandler: s.rateLimit({
         max: 30,
         timeWindow: '1 minute'
       })
@@ -345,10 +325,32 @@ export async function start(
       request: FastifyRequest<{ Params: { sessionId: string } }>,
       reply
     ) => {
-      const { sessionId } = request.params
-      return serveVideo(sessionId, reply)
+      return serveVideo(request.params.sessionId, reply)
     }
   )
+}
+
+export async function start(
+  opts: DevtoolsBackendOptions = {}
+): Promise<{ server: FastifyInstance; port: number }> {
+  const host = opts.hostname || 'localhost'
+  const preferredPort = opts.port || DEFAULT_PORT
+  const port = await getPort({ port: preferredPort })
+  if (opts.port && port !== opts.port) {
+    log.warn(`Port ${opts.port} is already in use, using port ${port} instead`)
+  }
+
+  const appPath = await getDevtoolsApp()
+  server = Fastify({ logger: true })
+  await server.register(rateLimit, { max: 100, timeWindow: '1 minute' })
+  await server.register(websocket)
+  await server.register(staticServer, { root: appPath })
+
+  registerTestRoutes(server, host, port)
+  registerBaselineRoutes(server)
+  registerClientWebSocket(server)
+  registerWorkerWebSocket(server)
+  registerVideoRoute(server)
 
   log.info(`Starting WebdriverIO Devtools application on port ${port}`)
   await server.listen({ port, host })
diff --git a/packages/backend/src/runner.ts b/packages/backend/src/runner.ts
index 4fc20f07..da1104b5 100644
--- a/packages/backend/src/runner.ts
+++ b/packages/backend/src/runner.ts
@@ -2,145 +2,43 @@ import { spawn, type ChildProcess } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 import url from 'node:url'
-import { createRequire } from 'node:module'
 import kill from 'tree-kill'
-import { parse as shellParse } from 'shell-quote'
-import type { RunnerRequestBody } from './types.js'
+import { parse as shellParse, quote as shellQuote } from 'shell-quote'
+import {
+  REUSE_ENV,
+  RUNNER_ENV,
+  type RunnerRequestBody
+} from '@wdio/devtools-shared'
 import { WDIO_CONFIG_FILENAMES, NIGHTWATCH_CONFIG_FILENAMES } from './types.js'
+import { getFilterBuilder } from './framework-filters.js'
+import { resolveNightwatchBin, resolveWdioBin } from './bin-resolver.js'
 
-const require = createRequire(import.meta.url)
 const wdioBin = resolveWdioBin()
 
 /**
- * Escape special regex characters in a string
+ * Detect a `--name "{{testName}}"` slot anywhere in `template`, with optional
+ * surrounding whitespace. Uses linear-time string scanning (split/indexOf) so
+ * the user-supplied rerun template can't trigger backtracking regardless of
+ * how many spaces it contains. See CodeQL js/polynomial-redos for context.
  */
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+const NAME_SLOT = '--name "{{testName}}"'
+function hasNameTestNameSlot(template: string): boolean {
+  return template.includes(NAME_SLOT)
 }
-
-type FilterBuilder = (ctx: {
-  specArg?: string
-  payload: RunnerRequestBody
-}) => string[]
-
-// Map (not object) keeps payload-supplied `framework` from reaching
-// prototype methods at dispatch time — CodeQL: unvalidated-dynamic-method-call.
-const FRAMEWORK_FILTERS = new Map<string, FilterBuilder>()
-
-FRAMEWORK_FILTERS.set('cucumber', ({ specArg, payload }) => {
-  const filters: string[] = []
-
-  // For feature-level suites, run the entire feature file
-  if (payload.suiteType === 'feature' && specArg) {
-    // Remove any line number from specArg for feature-level execution
-    const featureFile = specArg.split(':')[0]
-    filters.push('--spec', featureFile)
-    return filters
-  }
-
-  // Priority 1: Use feature file with line number for exact scenario targeting (works for examples)
-  // Note: Cucumber scenarios are type 'suite', not 'test'
-  if (payload.featureFile && payload.featureLine) {
-    filters.push('--spec', `${payload.featureFile}:${payload.featureLine}`)
-    return filters
-  }
-
-  // Priority 2: For specific test reruns with example row number, use exact regex match
-  if (payload.entryType === 'test' && payload.fullTitle) {
-    // Cucumber fullTitle format: "1: Scenario name" or "2: Scenario name"
-    // Extract the row number and scenario name
-    // Avoid ReDoS by removing ambiguous \s* before .* - use string operations instead
-    const colonIndex = payload.fullTitle.indexOf(':')
-    if (colonIndex > 0) {
-      const rowNumber = payload.fullTitle.substring(0, colonIndex)
-      const scenarioName = payload.fullTitle.substring(colonIndex + 1).trim()
-      // Validate row number is digits only
-      if (/^\d+$/.test(rowNumber)) {
-        // Use spec file filter
-        if (specArg) {
-          filters.push('--spec', specArg)
-        }
-        // Use regex to match the exact "rowNumber: scenarioName" pattern
-        // This ensures we only run that specific example row
-        filters.push(
-          '--cucumberOpts.name',
-          `^${rowNumber}:\\s*${escapeRegex(scenarioName)}$`
-        )
-        return filters
-      }
-    }
-    // No row number - use plain name filter
-    if (specArg) {
-      filters.push('--spec', specArg)
-    }
-    filters.push('--cucumberOpts.name', payload.fullTitle.trim())
-    return filters
+function stripNameTestNameSlot(template: string): string {
+  const idx = template.indexOf(NAME_SLOT)
+  if (idx === -1) {
+    return template
   }
-
-  // Suite-level rerun
-  if (specArg) {
-    filters.push('--spec', specArg)
+  // Trim adjacent whitespace on the left of the slot so we don't leave a
+  // double space behind. The right side is left intact — the caller appends
+  // the feature path after this segment.
+  let leftEdge = idx
+  while (leftEdge > 0 && /\s/.test(template[leftEdge - 1])) {
+    leftEdge--
   }
-  return filters
-})
-
-FRAMEWORK_FILTERS.set('mocha', ({ specArg, payload }) => {
-  const filters: string[] = []
-  if (specArg) {
-    filters.push('--spec', specArg)
-  }
-  // For both tests and suites, use grep to filter
-  if (payload.fullTitle) {
-    filters.push('--mochaOpts.grep', payload.fullTitle)
-  }
-  return filters
-})
-
-FRAMEWORK_FILTERS.set('jasmine', ({ specArg, payload }) => {
-  const filters: string[] = []
-  if (specArg) {
-    filters.push('--spec', specArg)
-  }
-  // For both tests and suites, use grep to filter
-  if (payload.fullTitle) {
-    filters.push('--jasmineOpts.grep', payload.fullTitle)
-  }
-  return filters
-})
-
-const DEFAULT_FILTERS: FilterBuilder = ({ specArg }) =>
-  specArg ? ['--spec', specArg] : []
-
-// Nightwatch CLI: positional spec file + optional --testcase filter
-FRAMEWORK_FILTERS.set('nightwatch', ({ specArg, payload }) => {
-  const filters: string[] = []
-  if (specArg) {
-    // Nightwatch doesn't support file:line — strip any trailing line number
-    filters.push(specArg.split(':')[0])
-  }
-  if (payload.entryType === 'test' && payload.label) {
-    filters.push('--testcase', payload.label)
-  }
-  return filters
-})
-
-// Nightwatch + Cucumber: feature files are resolved via the config's feature_path.
-// Never pass .feature files as positional args — Nightwatch rejects them.
-// Nightwatch forwards --name and --tags to the underlying Cucumber runner.
-FRAMEWORK_FILTERS.set('nightwatch-cucumber', ({ payload }) => {
-  const filters: string[] = []
-
-  // Only pass --name for scenario-level reruns. Feature/file-level suites
-  // (suiteType === 'feature') run all their scenarios, so no --name filter.
-  const isFeatureLevel = payload.suiteType === 'feature' || payload.runAll
-  if (!isFeatureLevel && payload.fullTitle) {
-    // Wrap as an anchored exact regex so "Scenario A" never also matches
-    // "Scenario A-1" (Cucumber treats --name as a regex).
-    const escaped = payload.fullTitle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-    filters.push('--name', `^${escaped}$`)
-  }
-  return filters
-})
+  return template.slice(0, leftEdge) + template.slice(idx + NAME_SLOT.length)
+}
 
 class TestRunner {
   #child?: ChildProcess
@@ -162,6 +60,79 @@ class TestRunner {
     }
   }
 
+  #buildReuseEnv(payload: RunnerRequestBody): NodeJS.ProcessEnv {
+    const childEnv: NodeJS.ProcessEnv = { ...process.env }
+    if (payload.devtoolsHost && payload.devtoolsPort) {
+      childEnv[REUSE_ENV.HOST] = payload.devtoolsHost
+      childEnv[REUSE_ENV.PORT] = String(payload.devtoolsPort)
+      childEnv[REUSE_ENV.REUSE] = '1'
+    }
+    return childEnv
+  }
+
+  #spawnGeneric(
+    payload: RunnerRequestBody,
+    childEnv: NodeJS.ProcessEnv
+  ): ChildProcess {
+    const command = this.#resolveGenericCommand(payload)
+    this.#baseDir = process.env[RUNNER_ENV.RUNNER_CWD] || process.cwd()
+    const { file, args } = this.#parseGenericCommand(command)
+    return spawn(file, args, {
+      cwd: this.#baseDir,
+      env: childEnv,
+      stdio: 'inherit',
+      detached: false
+    })
+  }
+
+  #spawnFramework(
+    payload: RunnerRequestBody,
+    childEnv: NodeJS.ProcessEnv,
+    isNightwatch: boolean
+  ): ChildProcess {
+    const configPath = this.#resolveConfigPath(payload)
+    this.#baseDir =
+      process.env[RUNNER_ENV.RUNNER_CWD] || path.dirname(configPath)
+    const args: string[] = isNightwatch
+      ? [
+          resolveNightwatchBin(this.#baseDir),
+          '--config',
+          configPath,
+          ...this.#buildFilters(payload)
+        ].filter(Boolean)
+      : [wdioBin, 'run', configPath, ...this.#buildFilters(payload)].filter(
+          Boolean
+        )
+    if (isNightwatch) {
+      if (payload.entryType === 'test' && payload.label) {
+        childEnv[REUSE_ENV.RERUN_ENTRY_TYPE] = 'test'
+        childEnv[REUSE_ENV.RERUN_LABEL] = payload.label
+      } else {
+        delete childEnv[REUSE_ENV.RERUN_ENTRY_TYPE]
+        delete childEnv[REUSE_ENV.RERUN_LABEL]
+      }
+    }
+    return spawn(process.execPath, args, {
+      cwd: this.#baseDir,
+      env: childEnv,
+      stdio: 'inherit',
+      detached: false
+    })
+  }
+
+  #waitForSpawn(child: ChildProcess): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      child.once('spawn', resolve)
+      child.once('error', (error) => {
+        this.#child = undefined
+        this.#lastPayload = undefined
+        this.#baseDir = process.cwd()
+        this.#expectingRerunChild = false
+        reject(error)
+      })
+    })
+  }
+
   async run(payload: RunnerRequestBody) {
     if (this.#child) {
       this.stop()
@@ -171,94 +142,38 @@ class TestRunner {
     this.#expectingRerunChild = Boolean(
       payload.devtoolsHost && payload.devtoolsPort
     )
-
     const isNightwatch = (payload.framework || '')
       .toLowerCase()
       .startsWith('nightwatch')
-    // Used when a plugin supplies its own rerun template (e.g. selenium —
-    // runs under mocha/jest/vitest/cucumber, none of which use wdioBin).
+    // Plugins that supply their own rerun template (e.g. selenium — runs
+    // under mocha/jest/vitest/cucumber, none of which use wdioBin).
     const isGenericShell =
       !isNightwatch && Boolean(payload.rerunCommand || payload.launchCommand)
 
-    const childEnv = { ...process.env }
-    if (payload.devtoolsHost && payload.devtoolsPort) {
-      childEnv.DEVTOOLS_APP_HOST = payload.devtoolsHost
-      childEnv.DEVTOOLS_APP_PORT = String(payload.devtoolsPort)
-      childEnv.DEVTOOLS_APP_REUSE = '1'
-    }
-
-    let child: ChildProcess
-    if (isGenericShell) {
-      const command = this.#resolveGenericCommand(payload)
-      this.#baseDir = process.env.DEVTOOLS_RUNNER_CWD || process.cwd()
-      const { file, args } = this.#parseGenericCommand(command)
-      child = spawn(file, args, {
-        cwd: this.#baseDir,
-        env: childEnv,
-        stdio: 'inherit',
-        detached: false
-      })
-    } else {
-      const configPath = this.#resolveConfigPath(payload)
-      this.#baseDir =
-        process.env.DEVTOOLS_RUNNER_CWD || path.dirname(configPath)
-      let args: string[]
-      if (isNightwatch) {
-        const nightwatchBin = resolveNightwatchBin(this.#baseDir)
-        args = [
-          nightwatchBin,
-          '--config',
-          configPath,
-          ...this.#buildFilters(payload)
-        ].filter(Boolean)
-      } else {
-        args = [
-          wdioBin,
-          'run',
-          configPath,
-          ...this.#buildFilters(payload)
-        ].filter(Boolean)
-      }
-      if (isNightwatch) {
-        if (payload.entryType === 'test' && payload.label) {
-          childEnv.DEVTOOLS_RERUN_ENTRY_TYPE = 'test'
-          childEnv.DEVTOOLS_RERUN_LABEL = payload.label
-        } else {
-          delete childEnv.DEVTOOLS_RERUN_ENTRY_TYPE
-          delete childEnv.DEVTOOLS_RERUN_LABEL
-        }
-      }
-      child = spawn(process.execPath, args, {
-        cwd: this.#baseDir,
-        env: childEnv,
-        stdio: 'inherit',
-        detached: false
-      })
-    }
+    const childEnv = this.#buildReuseEnv(payload)
+    const child = isGenericShell
+      ? this.#spawnGeneric(payload, childEnv)
+      : this.#spawnFramework(payload, childEnv, isNightwatch)
 
     this.#child = child
     this.#lastPayload = payload
-
     child.once('close', () => {
       this.#child = undefined
       this.#lastPayload = undefined
       this.#baseDir = process.cwd()
     })
-
-    await new Promise<void>((resolve, reject) => {
-      child.once('spawn', resolve)
-      child.once('error', (error) => {
-        this.#child = undefined
-        this.#lastPayload = undefined
-        this.#baseDir = process.cwd()
-        this.#expectingRerunChild = false
-        reject(error)
-      })
-    })
+    await this.#waitForSpawn(child)
   }
 
   // Targeted reruns substitute {{testName}} into rerunCommand; suite filtering
   // works because mocha/jest/cucumber filter flags match by name (describe/it/scenario alike).
+  //
+  // Exception: cucumber's `--name` matches scenario titles only, never feature
+  // titles — a suite-level rerun on a feature would substitute the feature name
+  // and match zero scenarios. When the payload looks like a cucumber feature
+  // rerun (entryType='suite', spec file ends in `.feature`, template carries
+  // `--name "{{testName}}"`), strip `--name` and pass the feature file as a
+  // positional arg so cucumber-js runs every scenario in that file.
   #resolveGenericCommand(payload: RunnerRequestBody): string {
     const template = payload.rerunCommand
     const fallback = payload.launchCommand || ''
@@ -266,11 +181,29 @@ class TestRunner {
       !payload.runAll &&
       (payload.entryType === 'test' || payload.entryType === 'suite') &&
       Boolean(payload.label || payload.fullTitle)
-    if (template && isTargetedRerun) {
-      const name = payload.label || payload.fullTitle || ''
-      return template.replace(/\{\{testName\}\}/g, name)
+    if (!template || !isTargetedRerun) {
+      return fallback || template || ''
+    }
+    // Cucumber's `--name` matches scenario titles, never feature titles.
+    // Feature-level reruns must drop `--name` and pass the .feature path as a
+    // positional arg. The dashboard tags the root suite with
+    // `suiteType: 'feature'`, which is what distinguishes a true feature-level
+    // rerun from a scenario rerun (scenarios are also `entryType: 'suite'` but
+    // `suiteType: 'suite'`).
+    const featureSpec =
+      payload.featureFile ||
+      (payload.specFile?.endsWith('.feature') ? payload.specFile : undefined)
+    const isCucumberFeatureRerun =
+      payload.entryType === 'suite' &&
+      payload.suiteType === 'feature' &&
+      Boolean(featureSpec) &&
+      hasNameTestNameSlot(template)
+    if (isCucumberFeatureRerun && featureSpec) {
+      const stripped = stripNameTestNameSlot(template)
+      return `${stripped} ${shellQuote([featureSpec])}`
     }
-    return fallback || template || ''
+    const name = payload.label || payload.fullTitle || ''
+    return template.replace(/\{\{testName\}\}/g, name)
   }
 
   #parseGenericCommand(command: string): { file: string; args: string[] } {
@@ -325,16 +258,15 @@ class TestRunner {
         : specFile
       : undefined
 
-    const candidateBuilder = FRAMEWORK_FILTERS.get(framework)
-    const builder =
-      typeof candidateBuilder === 'function'
-        ? candidateBuilder
-        : DEFAULT_FILTERS
+    // framework is `string` from the HTTP payload; getFilterBuilder
+    // validates it against its known-runner Map and falls back to the
+    // default spec-only builder for anything unrecognised.
+    const builder = getFilterBuilder(framework)
     const baseFilters = builder({ specArg, payload })
 
     // Scope "Run All" to the user's original --spec args. Nightwatch resolves specs via its own filter.
     if (payload.runAll && !framework.startsWith('nightwatch')) {
-      const initialSpecs = process.env.DEVTOOLS_WDIO_INITIAL_SPECS
+      const initialSpecs = process.env[RUNNER_ENV.WDIO_INITIAL_SPECS]
       if (initialSpecs) {
         const specs = initialSpecs.split(path.delimiter).filter(Boolean)
         for (const spec of specs) {
@@ -401,8 +333,8 @@ class TestRunner {
       payload?.configFile,
       this.#lastPayload?.configFile,
       this.#registeredConfigFile,
-      process.env.DEVTOOLS_WDIO_CONFIG,
-      process.env.DEVTOOLS_NIGHTWATCH_CONFIG,
+      process.env[RUNNER_ENV.WDIO_CONFIG],
+      process.env[RUNNER_ENV.NIGHTWATCH_CONFIG],
       this.#findConfigFromSpec(specCandidate, isNightwatch),
       ...this.#expandDefaultConfigsFor(this.#baseDir, isNightwatch),
       ...this.#expandDefaultConfigsFor(
@@ -478,85 +410,4 @@ class TestRunner {
   }
 }
 
-function resolveNightwatchBin(baseDir: string): string {
-  const envOverride = process.env.DEVTOOLS_NIGHTWATCH_BIN
-  if (envOverride) {
-    const resolved = path.isAbsolute(envOverride)
-      ? envOverride
-      : path.resolve(process.cwd(), envOverride)
-    if (fs.existsSync(resolved)) {
-      return resolved
-    }
-  }
-
-  // Walk up from baseDir looking for node_modules/nightwatch/package.json
-  // and resolve the actual JS entry (avoids running the shell-script wrapper
-  // at node_modules/.bin/nightwatch directly via node).
-  let dir = baseDir
-  const root = path.parse(dir).root
-  while (dir !== root) {
-    const nightwatchPkgPath = path.join(
-      dir,
-      'node_modules',
-      'nightwatch',
-      'package.json'
-    )
-    if (fs.existsSync(nightwatchPkgPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(nightwatchPkgPath, 'utf8'))
-        const nightwatchDir = path.join(dir, 'node_modules', 'nightwatch')
-        const binEntry =
-          typeof pkg.bin === 'string'
-            ? pkg.bin
-            : (pkg.bin?.nightwatch ?? pkg.bin?.nw)
-        if (binEntry) {
-          const jsPath = path.resolve(nightwatchDir, binEntry)
-          if (fs.existsSync(jsPath)) {
-            return jsPath
-          }
-        }
-      } catch {
-        // malformed package.json — continue walking
-      }
-    }
-    const parent = path.dirname(dir)
-    if (parent === dir) {
-      break
-    }
-    dir = parent
-  }
-
-  throw new Error(
-    'Cannot find nightwatch binary. Install nightwatch locally or set DEVTOOLS_NIGHTWATCH_BIN env var.'
-  )
-}
-
-function resolveWdioBin() {
-  const envOverride = process.env.DEVTOOLS_WDIO_BIN
-  if (envOverride) {
-    const overriddenPath = path.isAbsolute(envOverride)
-      ? envOverride
-      : path.resolve(process.cwd(), envOverride)
-    if (!fs.existsSync(overriddenPath)) {
-      throw new Error(
-        `DEVTOOLS_WDIO_BIN "${overriddenPath}" does not exist or is not accessible`
-      )
-    }
-    return overriddenPath
-  }
-
-  try {
-    const cliEntry = require.resolve('@wdio/cli')
-    const candidate = path.resolve(path.dirname(cliEntry), '../bin/wdio.js')
-    if (!fs.existsSync(candidate)) {
-      throw new Error(`Derived WDIO bin "${candidate}" does not exist`)
-    }
-    return candidate
-  } catch (error) {
-    throw new Error(
-      `Failed to resolve WDIO binary. Provide DEVTOOLS_WDIO_BIN env var. ${(error as Error).message}`
-    )
-  }
-}
-
 export const testRunner = new TestRunner()
diff --git a/packages/backend/src/types.ts b/packages/backend/src/types.ts
index faa055f3..61a3ded6 100644
--- a/packages/backend/src/types.ts
+++ b/packages/backend/src/types.ts
@@ -13,23 +13,4 @@ export const NIGHTWATCH_CONFIG_FILENAMES = [
   'nightwatch.json'
 ] as const
 
-export interface RunnerRequestBody {
-  uid: string
-  entryType: 'suite' | 'test'
-  specFile?: string
-  fullTitle?: string
-  label?: string
-  callSource?: string
-  runAll?: boolean
-  framework?: string
-  configFile?: string
-  lineNumber?: number
-  devtoolsHost?: string
-  devtoolsPort?: number
-  featureFile?: string
-  featureLine?: number
-  suiteType?: string
-  rerunCommand?: string
-  launchCommand?: string
-  preserveBaseline?: boolean
-}
+export type { RunnerRequestBody } from '@wdio/devtools-shared'
diff --git a/packages/backend/src/worker-message-handler.ts b/packages/backend/src/worker-message-handler.ts
new file mode 100644
index 00000000..ef643f9a
--- /dev/null
+++ b/packages/backend/src/worker-message-handler.ts
@@ -0,0 +1,90 @@
+import logger from '@wdio/logger'
+import { WS_SCOPE } from '@wdio/devtools-shared'
+import type { baselineStore as BaselineStore } from './baselineStore.js'
+import type { testRunner as TestRunner } from './runner.js'
+
+const log = logger('@wdio/devtools-backend')
+
+export interface WorkerMessageContext {
+  baselineStore: typeof BaselineStore
+  testRunner: typeof TestRunner
+  videoRegistry: Map<string, string>
+  broadcastToClients: (message: string) => void
+  clientCount: () => number
+}
+
+// Returns true if the message was fully handled and shouldn't be forwarded.
+function tryHandleControlMessage(
+  parsed: { scope?: string; data?: Record<string, unknown> },
+  ctx: WorkerMessageContext
+): boolean {
+  if (parsed.scope === WS_SCOPE.clearCommands) {
+    const testUid = parsed.data?.testUid
+    log.info(`Clearing commands for test: ${testUid || 'all'}`)
+    // Clearing without a uid is a full reset; wipe the baseline accumulator.
+    if (!testUid) {
+      ctx.baselineStore.resetActiveRun()
+    }
+    ctx.broadcastToClients(
+      JSON.stringify({
+        scope: WS_SCOPE.clearExecutionData,
+        data: { uid: testUid }
+      })
+    )
+    return true
+  }
+  if (parsed.scope === 'config' && parsed.data?.configFile) {
+    const configFile = String(parsed.data.configFile)
+    ctx.testRunner.registerConfigFile(configFile)
+    log.info(`Registered config file for reruns: ${configFile}`)
+    return true
+  }
+  // Screencast: store the absolute videoPath in the registry (backend-only),
+  // then forward only the sessionId so the UI can fetch via /api/video/:sessionId.
+  if (parsed.scope === 'screencast' && parsed.data?.sessionId) {
+    const sessionId = String(parsed.data.sessionId)
+    const videoPath =
+      typeof parsed.data.videoPath === 'string'
+        ? parsed.data.videoPath
+        : undefined
+    if (videoPath) {
+      ctx.videoRegistry.set(sessionId, videoPath)
+      log.info(`Screencast registered for session ${sessionId}: ${videoPath}`)
+    }
+    ctx.broadcastToClients(
+      JSON.stringify({ scope: 'screencast', data: { sessionId } })
+    )
+    return true
+  }
+  return false
+}
+
+/**
+ * Build the worker WS `message` listener for {@link WS_PATHS.worker}. Handles
+ * three control scopes inline (`clearCommands`, `config`, `screencast`) and
+ * forwards everything else verbatim to the dashboard clients.
+ */
+export function createWorkerMessageHandler(
+  ctx: WorkerMessageContext
+): (message: Buffer) => void {
+  return (message: Buffer) => {
+    // Use `debug` — at `info` this feeds the worker's stream capture loop.
+    const count = ctx.clientCount()
+    log.debug(
+      `received ${message.length} byte message from worker to ${count} client${count > 1 ? 's' : ''}`
+    )
+    try {
+      const parsed = JSON.parse(message.toString())
+      if (tryHandleControlMessage(parsed, ctx)) {
+        return
+      }
+      // Tee the event into the baseline accumulator for time-window
+      // partitioning at preserve time. After special-case handling so we
+      // don't accumulate control frames (clearCommands, screencast).
+      ctx.baselineStore.recordEvent(parsed.scope, parsed.data)
+    } catch {
+      // Not JSON or parsing failed — forward as-is.
+    }
+    ctx.broadcastToClients(message.toString())
+  }
+}
diff --git a/packages/backend/tests/baselineStore.test.ts b/packages/backend/tests/baselineStore.test.ts
index e7012cdf..619d0f65 100644
--- a/packages/backend/tests/baselineStore.test.ts
+++ b/packages/backend/tests/baselineStore.test.ts
@@ -111,7 +111,7 @@ describe('baselineStore', () => {
     })
   })
 
-  it('preserve refuses an empty-command snapshot (the 409 case)', () => {
+  it('preserve refuses an empty-command snapshot', () => {
     baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
     expect(baselineStore.preserve(TEST_UID, 'test')).toBeUndefined()
     expect(baselineStore.get(TEST_UID)).toBeUndefined()
@@ -129,4 +129,249 @@ describe('baselineStore', () => {
     expect(baselineStore.clearAll()).toEqual([TEST_UID])
     expect(baselineStore.get(TEST_UID)).toBeUndefined()
   })
+
+  it('clear(uid) removes only the named baseline and returns whether it existed', () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
+    baselineStore.preserve(TEST_UID, 'test')
+
+    expect(baselineStore.clear(TEST_UID)).toBe(true)
+    expect(baselineStore.clear(TEST_UID)).toBe(false)
+    expect(baselineStore.get(TEST_UID)).toBeUndefined()
+  })
+
+  it('getPair returns the stored baseline and a fresh snapshot of the latest run', () => {
+    // First run: capture + preserve a baseline
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'first', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
+    const baseline = baselineStore.preserve(TEST_UID, 'test')!
+
+    // Second run: new commands within a new time window
+    baselineStore.recordEvent(
+      'suites',
+      suite({ start: 500, end: 600, childState: 'passed' })
+    )
+    baselineStore.recordEvent('commands', [
+      { timestamp: 550, command: 'second', args: [] }
+    ])
+
+    const pair = baselineStore.getPair(TEST_UID, 'test')
+    expect(pair.baseline).toBe(baseline)
+    expect(pair.latest?.commands.map((c) => c.command)).toEqual(['second'])
+  })
+
+  it('getPair returns latest only when no baseline has been preserved', () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'live', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
+
+    const pair = baselineStore.getPair(TEST_UID, 'test')
+    expect(pair.baseline).toBeUndefined()
+    expect(pair.latest?.commands.map((c) => c.command)).toEqual(['live'])
+  })
+
+  it('rolls a passing descendant up to a suite without explicit state', () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'ok', args: [] }
+    ])
+    // Suite has no explicit state; child passes → rollup yields 'passed'
+    baselineStore.recordEvent('suites', [
+      {
+        [SUITE_UID]: {
+          uid: SUITE_UID,
+          title: 'parent',
+          file: '/spec.ts',
+          start: 100,
+          end: 200,
+          tests: [
+            {
+              uid: TEST_UID,
+              title: 'child',
+              fullTitle: 'parent child',
+              start: 100,
+              end: 200,
+              state: 'passed'
+            }
+          ],
+          suites: []
+        }
+      }
+    ])
+
+    const snap = baselineStore.snapshot(SUITE_UID, 'suite')!
+    expect(snap.test.state).toBe('passed')
+  })
+
+  it('filters consoleLogs to the test time window', () => {
+    baselineStore.recordEvent('consoleLogs', [
+      { type: 'log', args: ['before'], timestamp: 100 },
+      { type: 'log', args: ['inside'], timestamp: 250 },
+      { type: 'log', args: ['after'], timestamp: 900 }
+    ])
+    baselineStore.recordEvent('commands', [
+      { timestamp: 250, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 200, end: 300 }))
+
+    const snap = baselineStore.snapshot(TEST_UID, 'test')!
+    expect(snap.consoleLogs.map((c) => c.args[0])).toEqual(['inside'])
+  })
+
+  it('filters mutations to the test time window', () => {
+    baselineStore.recordEvent('mutations', [
+      { type: 'attributes', timestamp: 100, addedNodes: [], removedNodes: [] },
+      { type: 'attributes', timestamp: 250, addedNodes: [], removedNodes: [] },
+      { type: 'attributes', timestamp: 900, addedNodes: [], removedNodes: [] }
+    ])
+    baselineStore.recordEvent('commands', [
+      { timestamp: 250, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 200, end: 300 }))
+
+    const snap = baselineStore.snapshot(TEST_UID, 'test')!
+    expect(
+      snap.mutations.map((m) => (m as { timestamp: number }).timestamp)
+    ).toEqual([250])
+  })
+
+  it('filters networkRequests by span overlap with the window', () => {
+    baselineStore.recordEvent('networkRequests', [
+      // ends before window
+      {
+        id: '1',
+        startTime: 50,
+        endTime: 150,
+        url: '/a',
+        method: 'GET',
+        timestamp: 50,
+        type: 'fetch'
+      },
+      // overlaps window
+      {
+        id: '2',
+        startTime: 250,
+        endTime: 280,
+        url: '/b',
+        method: 'GET',
+        timestamp: 250,
+        type: 'fetch'
+      },
+      // starts after window
+      {
+        id: '3',
+        startTime: 500,
+        endTime: 600,
+        url: '/c',
+        method: 'GET',
+        timestamp: 500,
+        type: 'fetch'
+      }
+    ])
+    baselineStore.recordEvent('commands', [
+      { timestamp: 250, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 200, end: 300 }))
+
+    const snap = baselineStore.snapshot(TEST_UID, 'test')!
+    expect(snap.networkRequests.map((r) => r.url)).toEqual(['/b'])
+  })
+
+  it('preserve returns undefined when the uid has no recorded node', () => {
+    expect(baselineStore.preserve('unknown-uid', 'test')).toBeUndefined()
+  })
+
+  it('preserve at suite scope captures the parent windowing leaf commands', () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'one', args: [] },
+      { timestamp: 250, command: 'two', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 300 }))
+
+    const attempt = baselineStore.preserve(SUITE_UID, 'suite')!
+    expect(attempt.scope).toBe('suite')
+    expect(attempt.commands.map((c) => c.command)).toEqual(['one', 'two'])
+  })
+
+  it('recordEvent ignores falsy data', () => {
+    // No throw and no side effect
+    baselineStore.recordEvent('commands', null)
+    baselineStore.recordEvent('commands', undefined)
+    baselineStore.recordEvent('commands', 0 as never)
+
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
+    // Empty array also no-ops without throwing
+    baselineStore.recordEvent('commands', [])
+    expect(baselineStore.snapshot(TEST_UID, 'test')?.commands ?? []).toEqual([])
+  })
+
+  it('recordEvent merges sources via assign', () => {
+    baselineStore.recordEvent('sources', { '/a.ts': 'A' })
+    baselineStore.recordEvent('sources', { '/b.ts': 'B' })
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
+
+    const snap = baselineStore.snapshot(TEST_UID, 'test')!
+    expect(snap.sources).toEqual({ '/a.ts': 'A', '/b.ts': 'B' })
+  })
+
+  it('networkRequests are deduped by id across multiple recordEvent calls', () => {
+    const base = {
+      startTime: 250,
+      endTime: 260,
+      method: 'GET',
+      timestamp: 250,
+      type: 'fetch'
+    }
+    baselineStore.recordEvent('networkRequests', [
+      { id: '1', url: '/a', ...base }
+    ])
+    baselineStore.recordEvent('networkRequests', [
+      { id: '1', url: '/a-updated', ...base },
+      { id: '2', url: '/b', ...base }
+    ])
+    baselineStore.recordEvent('commands', [
+      { timestamp: 250, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 200, end: 300 }))
+
+    const snap = baselineStore.snapshot(TEST_UID, 'test')!
+    expect(snap.networkRequests.map((r) => r.url)).toEqual(['/a-updated', '/b'])
+  })
+
+  it('rolls a running descendant up so a suite without explicit state shows running', () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'go', args: [] }
+    ])
+    baselineStore.recordEvent('suites', [
+      {
+        [SUITE_UID]: {
+          uid: SUITE_UID,
+          title: 'parent',
+          file: '/spec.ts',
+          start: 100,
+          end: 200,
+          tests: [
+            {
+              uid: TEST_UID,
+              title: 'child',
+              fullTitle: 'parent child',
+              start: 100,
+              state: 'running'
+            }
+          ],
+          suites: []
+        }
+      }
+    ])
+
+    const snap = baselineStore.snapshot(SUITE_UID, 'suite')!
+    expect(snap.test.state).toBe('running')
+  })
 })
diff --git a/packages/backend/tests/bin-resolver.test.ts b/packages/backend/tests/bin-resolver.test.ts
new file mode 100644
index 00000000..9e70eb73
--- /dev/null
+++ b/packages/backend/tests/bin-resolver.test.ts
@@ -0,0 +1,150 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { RUNNER_ENV } from '@wdio/devtools-shared'
+import { resolveNightwatchBin, resolveWdioBin } from '../src/bin-resolver.js'
+
+let tmpDir: string
+let savedEnv: NodeJS.ProcessEnv
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bin-resolver-'))
+  // Snapshot the resolver-relevant env so each test starts clean.
+  savedEnv = { ...process.env }
+  delete process.env[RUNNER_ENV.NIGHTWATCH_BIN]
+  delete process.env[RUNNER_ENV.WDIO_BIN]
+})
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+  process.env = savedEnv
+})
+
+// Lay out a minimal node_modules/nightwatch/{package.json + bin/nightwatch.js}
+function plantNightwatch(at: string, binEntry: unknown = 'bin/nightwatch.js') {
+  const pkgDir = path.join(at, 'node_modules', 'nightwatch')
+  fs.mkdirSync(path.join(pkgDir, 'bin'), { recursive: true })
+  fs.writeFileSync(
+    path.join(pkgDir, 'package.json'),
+    JSON.stringify({ name: 'nightwatch', bin: binEntry })
+  )
+  fs.writeFileSync(
+    path.join(pkgDir, 'bin', 'nightwatch.js'),
+    '#!/usr/bin/env node\n'
+  )
+  return path.join(pkgDir, 'bin', 'nightwatch.js')
+}
+
+describe('resolveNightwatchBin — env override (DEVTOOLS_NIGHTWATCH_BIN)', () => {
+  it('honors an absolute env override that exists on disk', () => {
+    const fake = path.join(tmpDir, 'my-nightwatch.js')
+    fs.writeFileSync(fake, '')
+    process.env[RUNNER_ENV.NIGHTWATCH_BIN] = fake
+    expect(resolveNightwatchBin('/anywhere')).toBe(fake)
+  })
+
+  it('honors a relative env override (resolved from cwd)', () => {
+    const fake = path.join(tmpDir, 'rel-nightwatch.js')
+    fs.writeFileSync(fake, '')
+    // Make the override relative by stripping cwd off the path
+    const rel = path.relative(process.cwd(), fake)
+    process.env[RUNNER_ENV.NIGHTWATCH_BIN] = rel
+    expect(resolveNightwatchBin('/anywhere')).toBe(path.resolve(rel))
+  })
+
+  it('falls through to walk-up when the env-override path does not exist', () => {
+    process.env[RUNNER_ENV.NIGHTWATCH_BIN] = '/totally/missing.js'
+    const expected = plantNightwatch(tmpDir)
+    expect(resolveNightwatchBin(tmpDir)).toBe(expected)
+  })
+})
+
+describe('resolveNightwatchBin — walk-up node_modules search', () => {
+  it('finds nightwatch when planted in the start directory', () => {
+    const expected = plantNightwatch(tmpDir)
+    expect(resolveNightwatchBin(tmpDir)).toBe(expected)
+  })
+
+  it('walks up parent directories until it finds node_modules/nightwatch', () => {
+    const child = path.join(tmpDir, 'a', 'b', 'c')
+    fs.mkdirSync(child, { recursive: true })
+    const expected = plantNightwatch(tmpDir)
+    expect(resolveNightwatchBin(child)).toBe(expected)
+  })
+
+  it('supports object-form bin: { nightwatch: ... }', () => {
+    const expected = plantNightwatch(tmpDir, {
+      nightwatch: 'bin/nightwatch.js'
+    })
+    expect(resolveNightwatchBin(tmpDir)).toBe(expected)
+  })
+
+  it('supports object-form bin: { nw: ... } as a fallback', () => {
+    const pkgDir = path.join(tmpDir, 'node_modules', 'nightwatch')
+    fs.mkdirSync(path.join(pkgDir, 'bin'), { recursive: true })
+    fs.writeFileSync(
+      path.join(pkgDir, 'package.json'),
+      JSON.stringify({ name: 'nightwatch', bin: { nw: 'bin/nw-entry.js' } })
+    )
+    fs.writeFileSync(path.join(pkgDir, 'bin', 'nw-entry.js'), '')
+    expect(resolveNightwatchBin(tmpDir)).toBe(
+      path.join(pkgDir, 'bin', 'nw-entry.js')
+    )
+  })
+
+  it('throws a helpful error mentioning DEVTOOLS_NIGHTWATCH_BIN when nothing is found', () => {
+    // tmpDir has no nightwatch planted; walk-up hits filesystem root
+    expect(() => resolveNightwatchBin(tmpDir)).toThrow(
+      /DEVTOOLS_NIGHTWATCH_BIN/
+    )
+  })
+
+  it('skips malformed package.json silently and continues walking', () => {
+    const child = path.join(tmpDir, 'inner')
+    fs.mkdirSync(path.join(child, 'node_modules', 'nightwatch'), {
+      recursive: true
+    })
+    // Write garbage JSON at the inner level
+    fs.writeFileSync(
+      path.join(child, 'node_modules', 'nightwatch', 'package.json'),
+      '{ this is not valid json'
+    )
+    // Plant a valid one at the parent level
+    const expected = plantNightwatch(tmpDir)
+    expect(resolveNightwatchBin(child)).toBe(expected)
+  })
+})
+
+describe('resolveWdioBin — env override (DEVTOOLS_WDIO_BIN)', () => {
+  it('honors an absolute env override that exists', () => {
+    const fake = path.join(tmpDir, 'my-wdio.js')
+    fs.writeFileSync(fake, '')
+    process.env[RUNNER_ENV.WDIO_BIN] = fake
+    expect(resolveWdioBin()).toBe(fake)
+  })
+
+  it('throws a helpful error when env-override path does NOT exist (does NOT fall back to require.resolve)', () => {
+    process.env[RUNNER_ENV.WDIO_BIN] = '/totally/missing-wdio.js'
+    expect(() => resolveWdioBin()).toThrow(/does not exist|not accessible/)
+  })
+
+  it('resolves a relative env override from cwd', () => {
+    const fake = path.join(tmpDir, 'rel-wdio.js')
+    fs.writeFileSync(fake, '')
+    const rel = path.relative(process.cwd(), fake)
+    process.env[RUNNER_ENV.WDIO_BIN] = rel
+    expect(resolveWdioBin()).toBe(path.resolve(rel))
+  })
+})
+
+describe('resolveWdioBin — @wdio/cli derivation', () => {
+  // @wdio/cli IS installed in this workspace (a real dep), so the derivation
+  // succeeds and returns the published bin path. We assert the file exists +
+  // looks like the wdio entry, without locking to a specific absolute path
+  // that varies per machine.
+  it('derives bin/wdio.js from @wdio/cli when no env override is set', () => {
+    const resolved = resolveWdioBin()
+    expect(resolved.endsWith('bin/wdio.js')).toBe(true)
+    expect(fs.existsSync(resolved)).toBe(true)
+  })
+})
diff --git a/packages/backend/tests/framework-filters.test.ts b/packages/backend/tests/framework-filters.test.ts
new file mode 100644
index 00000000..faae96b7
--- /dev/null
+++ b/packages/backend/tests/framework-filters.test.ts
@@ -0,0 +1,221 @@
+import { describe, expect, it } from 'vitest'
+import type { RunnerRequestBody } from '@wdio/devtools-shared'
+import { getFilterBuilder } from '../src/framework-filters.js'
+
+function payload(
+  overrides: Partial<RunnerRequestBody> = {}
+): RunnerRequestBody {
+  return {
+    entryType: 'test',
+    label: '',
+    framework: 'mocha',
+    ...overrides
+  } as RunnerRequestBody
+}
+
+describe('getFilterBuilder fallback (DEFAULT_FILTERS)', () => {
+  it('passes --spec when specArg is given', () => {
+    const fn = getFilterBuilder(undefined)
+    expect(fn({ specArg: '/a.test.ts', payload: payload() })).toEqual([
+      '--spec',
+      '/a.test.ts'
+    ])
+  })
+
+  it('returns [] when no specArg is given', () => {
+    const fn = getFilterBuilder(undefined)
+    expect(fn({ specArg: undefined, payload: payload() })).toEqual([])
+  })
+
+  it('uses default for unknown runner ids', () => {
+    const fn = getFilterBuilder('unknown-runner' as never)
+    expect(fn({ specArg: '/x.ts', payload: payload() })).toEqual([
+      '--spec',
+      '/x.ts'
+    ])
+  })
+})
+
+describe('mocha filter builder', () => {
+  const fn = getFilterBuilder('mocha')
+
+  it('adds --spec + --mochaOpts.grep when both are set', () => {
+    expect(
+      fn({ specArg: '/a.test.ts', payload: payload({ fullTitle: 'Login >' }) })
+    ).toEqual(['--spec', '/a.test.ts', '--mochaOpts.grep', 'Login >'])
+  })
+
+  it('omits --mochaOpts.grep when fullTitle is empty', () => {
+    expect(fn({ specArg: '/a.test.ts', payload: payload() })).toEqual([
+      '--spec',
+      '/a.test.ts'
+    ])
+  })
+
+  it('omits --spec when specArg is undefined', () => {
+    expect(
+      fn({ specArg: undefined, payload: payload({ fullTitle: 'X' }) })
+    ).toEqual(['--mochaOpts.grep', 'X'])
+  })
+})
+
+describe('jasmine filter builder', () => {
+  const fn = getFilterBuilder('jasmine')
+  it('mirrors mocha shape with --jasmineOpts.grep', () => {
+    expect(
+      fn({ specArg: '/a.ts', payload: payload({ fullTitle: 'A' }) })
+    ).toEqual(['--spec', '/a.ts', '--jasmineOpts.grep', 'A'])
+  })
+})
+
+describe('nightwatch filter builder', () => {
+  const fn = getFilterBuilder('nightwatch')
+
+  it('strips trailing :line from specArg (Nightwatch does not support it)', () => {
+    expect(
+      fn({
+        specArg: '/a.test.ts:42',
+        payload: payload({ entryType: 'test', label: 'should pass' })
+      })
+    ).toEqual(['/a.test.ts', '--testcase', 'should pass'])
+  })
+
+  it('passes positional spec without --testcase for suite entryType', () => {
+    expect(
+      fn({
+        specArg: '/a.test.ts',
+        payload: payload({ entryType: 'suite' as never })
+      })
+    ).toEqual(['/a.test.ts'])
+  })
+
+  it('returns empty filters when no specArg and no label', () => {
+    expect(fn({ specArg: undefined, payload: payload() })).toEqual([])
+  })
+})
+
+describe('cucumber filter builder', () => {
+  const fn = getFilterBuilder('cucumber')
+
+  it('feature-level: strips line and runs the whole feature', () => {
+    expect(
+      fn({
+        specArg: '/login.feature:10',
+        payload: payload({ suiteType: 'feature' as never })
+      })
+    ).toEqual(['--spec', '/login.feature'])
+  })
+
+  it('scenario file:line takes priority when feature/line are provided', () => {
+    expect(
+      fn({
+        specArg: '/a.feature',
+        payload: payload({
+          featureFile: '/login.feature',
+          featureLine: 12
+        } as never)
+      })
+    ).toEqual(['--spec', '/login.feature:12'])
+  })
+
+  it('test entry with row number: uses anchored regex --cucumberOpts.name', () => {
+    const result = fn({
+      specArg: '/login.feature',
+      payload: payload({
+        entryType: 'test',
+        fullTitle: '3: User signs in with valid creds'
+      } as never)
+    })
+    expect(result).toEqual([
+      '--spec',
+      '/login.feature',
+      '--cucumberOpts.name',
+      '^3:\\s*User signs in with valid creds$'
+    ])
+  })
+
+  it('test entry with no row prefix uses plain name filter', () => {
+    const result = fn({
+      specArg: '/login.feature',
+      payload: payload({
+        entryType: 'test',
+        fullTitle: 'Plain scenario'
+      } as never)
+    })
+    expect(result).toEqual([
+      '--spec',
+      '/login.feature',
+      '--cucumberOpts.name',
+      'Plain scenario'
+    ])
+  })
+
+  it('test entry with non-numeric prefix falls back to plain name', () => {
+    const result = fn({
+      specArg: '/login.feature',
+      payload: payload({
+        entryType: 'test',
+        fullTitle: 'foo: bar'
+      } as never)
+    })
+    // colon present but rowNumber is "foo" not digits → plain name path
+    expect(result.slice(-2)).toEqual(['--cucumberOpts.name', 'foo: bar'])
+  })
+
+  it('suite-level: only spec, no name filter', () => {
+    expect(
+      fn({
+        specArg: '/login.feature',
+        payload: payload({ entryType: 'suite' as never })
+      })
+    ).toEqual(['--spec', '/login.feature'])
+  })
+
+  it('escapes regex metacharacters in scenario name', () => {
+    const result = fn({
+      specArg: '/x.feature',
+      payload: payload({
+        entryType: 'test',
+        fullTitle: '1: a.b*c'
+      } as never)
+    })
+    expect(result[result.length - 1]).toBe('^1:\\s*a\\.b\\*c$')
+  })
+})
+
+describe('nightwatch-cucumber filter builder', () => {
+  const fn = getFilterBuilder('nightwatch-cucumber')
+
+  it('adds --name with anchored regex for scenario-level reruns', () => {
+    expect(
+      fn({ specArg: undefined, payload: payload({ fullTitle: 'My Scenario' }) })
+    ).toEqual(['--name', '^My Scenario$'])
+  })
+
+  it('skips --name for feature-level (suiteType=feature)', () => {
+    expect(
+      fn({
+        specArg: undefined,
+        payload: payload({
+          suiteType: 'feature' as never,
+          fullTitle: 'unused'
+        })
+      })
+    ).toEqual([])
+  })
+
+  it('skips --name when runAll is set', () => {
+    expect(
+      fn({
+        specArg: undefined,
+        payload: payload({ runAll: true as never, fullTitle: 'unused' })
+      })
+    ).toEqual([])
+  })
+
+  it('escapes regex metacharacters in the scenario name', () => {
+    expect(
+      fn({ specArg: undefined, payload: payload({ fullTitle: 'a.b*c' }) })
+    ).toEqual(['--name', '^a\\.b\\*c$'])
+  })
+})
diff --git a/packages/backend/tests/worker-message-handler.test.ts b/packages/backend/tests/worker-message-handler.test.ts
new file mode 100644
index 00000000..9b171d99
--- /dev/null
+++ b/packages/backend/tests/worker-message-handler.test.ts
@@ -0,0 +1,158 @@
+import { describe, it, expect, vi } from 'vitest'
+import { WS_SCOPE } from '@wdio/devtools-shared'
+import {
+  createWorkerMessageHandler,
+  type WorkerMessageContext
+} from '../src/worker-message-handler.js'
+
+function makeCtx(overrides: Partial<WorkerMessageContext> = {}) {
+  const broadcastToClients = vi.fn()
+  const baselineStore = {
+    resetActiveRun: vi.fn(),
+    recordEvent: vi.fn()
+  }
+  const testRunner = {
+    registerConfigFile: vi.fn()
+  }
+  const videoRegistry = new Map<string, string>()
+  const ctx: WorkerMessageContext = {
+    baselineStore:
+      baselineStore as unknown as WorkerMessageContext['baselineStore'],
+    testRunner: testRunner as unknown as WorkerMessageContext['testRunner'],
+    videoRegistry,
+    broadcastToClients,
+    clientCount: () => 1,
+    ...overrides
+  }
+  return { ctx, broadcastToClients, baselineStore, testRunner, videoRegistry }
+}
+
+const buf = (obj: unknown) => Buffer.from(JSON.stringify(obj))
+
+describe('createWorkerMessageHandler — clearCommands', () => {
+  it('with a testUid: broadcasts clearExecutionData scoped to that uid; does NOT reset the baseline accumulator', () => {
+    const { ctx, broadcastToClients, baselineStore } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(buf({ scope: WS_SCOPE.clearCommands, data: { testUid: 't-1' } }))
+    expect(baselineStore.resetActiveRun).not.toHaveBeenCalled()
+    expect(broadcastToClients).toHaveBeenCalledWith(
+      JSON.stringify({
+        scope: WS_SCOPE.clearExecutionData,
+        data: { uid: 't-1' }
+      })
+    )
+  })
+
+  it('without a testUid: resets baseline AND broadcasts a full-clear', () => {
+    const { ctx, broadcastToClients, baselineStore } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(buf({ scope: WS_SCOPE.clearCommands, data: {} }))
+    expect(baselineStore.resetActiveRun).toHaveBeenCalledOnce()
+    expect(broadcastToClients).toHaveBeenCalledWith(
+      JSON.stringify({
+        scope: WS_SCOPE.clearExecutionData,
+        data: { uid: undefined }
+      })
+    )
+  })
+})
+
+describe('createWorkerMessageHandler — config scope', () => {
+  it('registers the config file and does NOT broadcast (control message)', () => {
+    const { ctx, broadcastToClients, testRunner } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(buf({ scope: 'config', data: { configFile: '/p/wdio.conf.ts' } }))
+    expect(testRunner.registerConfigFile).toHaveBeenCalledWith(
+      '/p/wdio.conf.ts'
+    )
+    expect(broadcastToClients).not.toHaveBeenCalled()
+  })
+
+  it('ignores config messages without a configFile', () => {
+    const { ctx, testRunner } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(buf({ scope: 'config', data: {} }))
+    expect(testRunner.registerConfigFile).not.toHaveBeenCalled()
+  })
+})
+
+describe('createWorkerMessageHandler — screencast scope (the videoPath strip)', () => {
+  it('stores videoPath in the backend registry and forwards only sessionId to clients', () => {
+    const { ctx, broadcastToClients, videoRegistry } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(
+      buf({
+        scope: 'screencast',
+        data: {
+          sessionId: 'sess-x',
+          videoPath: '/abs/path/to/video.webm',
+          videoFile: 'video.webm',
+          frameCount: 42
+        }
+      })
+    )
+    // Backend keeps the absolute path private (security + path stripping)
+    expect(videoRegistry.get('sess-x')).toBe('/abs/path/to/video.webm')
+    // UI only ever sees the sessionId — never the path
+    expect(broadcastToClients).toHaveBeenCalledWith(
+      JSON.stringify({
+        scope: 'screencast',
+        data: { sessionId: 'sess-x' }
+      })
+    )
+  })
+
+  it('still broadcasts even when videoPath is missing (e.g. for re-fired notifications)', () => {
+    const { ctx, broadcastToClients, videoRegistry } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(buf({ scope: 'screencast', data: { sessionId: 'sess-y' } }))
+    expect(videoRegistry.has('sess-y')).toBe(false)
+    expect(broadcastToClients).toHaveBeenCalledWith(
+      JSON.stringify({
+        scope: 'screencast',
+        data: { sessionId: 'sess-y' }
+      })
+    )
+  })
+
+  it('ignores screencast messages without a sessionId', () => {
+    const { ctx, broadcastToClients, videoRegistry } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(buf({ scope: 'screencast', data: { videoPath: '/x' } }))
+    expect(videoRegistry.size).toBe(0)
+    // No special-case broadcast — falls through to the generic forward
+    expect(broadcastToClients).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('createWorkerMessageHandler — pass-through behavior', () => {
+  it('forwards unknown scopes verbatim to clients AND tees them into the baseline accumulator', () => {
+    const { ctx, broadcastToClients, baselineStore } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    const msg = buf({ scope: 'commands', data: [{ command: 'click' }] })
+    handler(msg)
+    expect(broadcastToClients).toHaveBeenCalledWith(msg.toString())
+    expect(baselineStore.recordEvent).toHaveBeenCalledWith('commands', [
+      { command: 'click' }
+    ])
+  })
+
+  it('does NOT tee control-frame scopes (clearCommands/config/screencast) into the accumulator', () => {
+    const { ctx, baselineStore } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    handler(buf({ scope: WS_SCOPE.clearCommands, data: {} }))
+    handler(buf({ scope: 'config', data: { configFile: '/p/wdio.conf.ts' } }))
+    handler(buf({ scope: 'screencast', data: { sessionId: 's' } }))
+    expect(baselineStore.recordEvent).not.toHaveBeenCalled()
+  })
+
+  it('forwards non-JSON messages verbatim without crashing', () => {
+    const { ctx, broadcastToClients, baselineStore } = makeCtx()
+    const handler = createWorkerMessageHandler(ctx)
+    const garbage = Buffer.from('not-json-at-all{{')
+    handler(garbage)
+    // Falls through to the catch + raw forward branch
+    expect(broadcastToClients).toHaveBeenCalledWith(garbage.toString())
+    expect(baselineStore.recordEvent).not.toHaveBeenCalled()
+  })
+})
diff --git a/packages/backend/tsconfig.json b/packages/backend/tsconfig.json
index 7cfb7e99..9ccab6be 100644
--- a/packages/backend/tsconfig.json
+++ b/packages/backend/tsconfig.json
@@ -5,7 +5,7 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "outDir": "dist",
-    "rootDir": "src",
+    "rootDir": "..",
     "noEmit": false,
     "allowImportingTsExtensions": false,
     "declaration": true
diff --git a/packages/core/package.json b/packages/core/package.json
new file mode 100644
index 00000000..b637cd88
--- /dev/null
+++ b/packages/core/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "@wdio/devtools-core",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Framework-agnostic capture/reporter logic shared by @wdio/devtools-* adapters. Workspace-internal, never published — code is inlined into each consuming adapter at build time.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webdriverio/devtools.git",
+    "directory": "packages/core"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "types": "./src/index.ts",
+  "scripts": {
+    "lint": "eslint ."
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/ws": "^8.18.1",
+    "@wdio/devtools-script": "workspace:*",
+    "@wdio/devtools-shared": "workspace:^",
+    "stacktrace-parser": "^0.1.11",
+    "ws": "^8.21.0"
+  }
+}
diff --git a/packages/core/src/assert-patcher.ts b/packages/core/src/assert-patcher.ts
new file mode 100644
index 00000000..10e18a4b
--- /dev/null
+++ b/packages/core/src/assert-patcher.ts
@@ -0,0 +1,177 @@
+import { createRequire } from 'node:module'
+import { getCallSourceFromStack } from './stack.js'
+import { toError } from './error.js'
+
+const require = createRequire(import.meta.url)
+
+/** Per-process guard so a second `patchNodeAssert()` call is a no-op. */
+export const ASSERT_PATCHED_SYMBOL = Symbol.for(
+  '@wdio/devtools-core/assert-patched'
+)
+
+/** node:assert methods the patcher wraps. */
+export const TRACKED_ASSERT_METHODS = [
+  'equal',
+  'strictEqual',
+  'deepEqual',
+  'deepStrictEqual',
+  'notEqual',
+  'notStrictEqual',
+  'notDeepEqual',
+  'notDeepStrictEqual',
+  'ok',
+  'fail',
+  'throws',
+  'doesNotThrow',
+  'rejects',
+  'doesNotReject',
+  'match',
+  'doesNotMatch'
+] as const
+
+/**
+ * Minimum shape `patchNodeAssert` emits. Adapters that need extra bookkeeping
+ * (selenium adds `fromElement` and `rawResult`) wrap the callback to extend
+ * the object before forwarding to their own `onCommand` sink.
+ */
+export interface CapturedAssert {
+  command: string
+  args: unknown[]
+  result: 'passed' | undefined
+  error: Error | undefined
+  callSource: string | undefined
+  timestamp: number
+}
+
+/**
+ * JSON-safe stringify of an assert argument. Non-serialisable inputs degrade
+ * gracefully: functions → '[Function]', RegExp → `/.../i`, cyclic objects →
+ * `String(value)`. Exported so adapters can mirror the shape if they wrap.
+ */
+export function safeSerializeAssertArg(value: unknown): unknown {
+  if (value === null || value === undefined) {
+    return value
+  }
+  if (value instanceof RegExp) {
+    return value.toString()
+  }
+  if (typeof value === 'function') {
+    return '[Function]'
+  }
+  if (typeof value === 'object') {
+    try {
+      return JSON.parse(JSON.stringify(value))
+    } catch {
+      return String(value)
+    }
+  }
+  return value
+}
+
+function makePatchedAssertMethod(
+  methodName: string,
+  original: (...a: unknown[]) => unknown,
+  onCommand: (cmd: CapturedAssert) => void
+): (...args: unknown[]) => unknown {
+  return function patchedAssert(this: unknown, ...args: unknown[]) {
+    const callInfo = getCallSourceFromStack()
+    const startedAt = Date.now()
+    const sanitizedArgs = args.map(safeSerializeAssertArg)
+    const passed = () =>
+      onCommand({
+        command: `assert.${methodName}`,
+        args: sanitizedArgs,
+        result: 'passed',
+        error: undefined,
+        callSource: callInfo.callSource,
+        timestamp: startedAt
+      })
+    const failed = (err: unknown) =>
+      onCommand({
+        command: `assert.${methodName}`,
+        args: sanitizedArgs,
+        result: undefined,
+        error: toError(err),
+        callSource: callInfo.callSource,
+        timestamp: startedAt
+      })
+
+    try {
+      const result = original.apply(this, args)
+      // Async assert methods (rejects/doesNotReject) return a Promise.
+      const maybe = result as { then?: unknown } | null | undefined
+      if (maybe && typeof maybe.then === 'function') {
+        return (result as Promise<unknown>).then(
+          (v) => {
+            passed()
+            return v
+          },
+          (err) => {
+            failed(err)
+            throw err
+          }
+        )
+      }
+      passed()
+      return result
+    } catch (err) {
+      failed(err)
+      throw err
+    }
+  }
+}
+
+/**
+ * Patch `node:assert` so each tracked method emits a `CapturedAssert` to the
+ * supplied hook. Idempotent across calls (guarded by `ASSERT_PATCHED_SYMBOL`).
+ * Returns `true` on success, `false` when node:assert can't be resolved
+ * (rare — browser-only Node-incompatible runtimes).
+ *
+ * Wraps both the function-form (`assert(...)`) and the namespace methods
+ * (`assert.equal(...)`). User code that imported the methods BEFORE this
+ * patcher loaded keeps stale references — adapters should import node:assert
+ * from their main entry before user test files load.
+ *
+ * @param onCommand Callback invoked once per assert call (sync OR async).
+ *                  Receives the captured shape; do NOT throw — the wrapper
+ *                  re-throws the original assert error after the callback.
+ * @param onLog     Optional logger for lifecycle events. Default: silent.
+ */
+export function patchNodeAssert(
+  onCommand: (cmd: CapturedAssert) => void,
+  onLog?: (level: 'info' | 'warn', message: string) => void
+): boolean {
+  const log = (level: 'info' | 'warn', message: string) =>
+    onLog?.(level, message)
+
+  let assertModule: unknown
+  try {
+    assertModule = require('node:assert')
+  } catch {
+    log('warn', 'node:assert not available — skipping assertion capture')
+    return false
+  }
+
+  // Node's `assert` is a function with methods on it — cast once for the
+  // symbol + dynamic method access we do here.
+  const assertObj = assertModule as Record<string | symbol, unknown>
+  if (assertObj[ASSERT_PATCHED_SYMBOL]) {
+    return true
+  }
+  assertObj[ASSERT_PATCHED_SYMBOL] = true
+
+  for (const methodName of TRACKED_ASSERT_METHODS) {
+    const original = assertObj[methodName]
+    if (typeof original !== 'function') {
+      continue
+    }
+    assertObj[methodName] = makePatchedAssertMethod(
+      methodName,
+      original as (...a: unknown[]) => unknown,
+      onCommand
+    )
+  }
+
+  log('info', `Patched ${TRACKED_ASSERT_METHODS.length} node:assert method(s)`)
+  return true
+}
diff --git a/packages/core/src/bidi.ts b/packages/core/src/bidi.ts
new file mode 100644
index 00000000..39ce416f
--- /dev/null
+++ b/packages/core/src/bidi.ts
@@ -0,0 +1,314 @@
+import { createRequire } from 'node:module'
+import type {
+  ConsoleLog,
+  LogLevel,
+  NetworkRequest
+} from '@wdio/devtools-shared'
+import {
+  LOG_SOURCES,
+  chromeLogLevelToLogLevel,
+  type LogSource
+} from './console.js'
+import { errorMessage } from './error.js'
+import { getRequestType } from './net.js'
+
+/**
+ * Generic sinks the BiDi handlers push into. Each adapter wires these to its
+ * own SessionCapturer state — selenium's `buildBidiSinks` is the canonical
+ * example; nightwatch can mirror the pattern when it wires up BiDi.
+ */
+export interface BidiHandlerSinks {
+  pushConsoleLog: (entry: ConsoleLog) => void
+  pushNetworkRequest: (entry: NetworkRequest) => void
+  replaceNetworkRequest: (id: string, entry: NetworkRequest) => void
+}
+
+/**
+ * Resolve a `selenium-webdriver/<subpath>` module from the user's install
+ * (preferred) or the package's local install (fallback). Returns `null` if
+ * neither resolves — caller should treat as "BiDi not available on this
+ * runtime" and degrade gracefully.
+ *
+ * Used by both selenium-devtools and (when wired up) nightwatch-devtools —
+ * both ship selenium-webdriver-style drivers under the hood.
+ */
+export function loadSeleniumSubmodule<T = unknown>(subpath: string): T | null {
+  try {
+    const userRequire = createRequire(`${process.cwd()}/`)
+    return userRequire(`selenium-webdriver/${subpath}`) as T
+  } catch {
+    try {
+      const localRequire = createRequire(import.meta.url)
+      return localRequire(`selenium-webdriver/${subpath}`) as T
+    } catch {
+      return null
+    }
+  }
+}
+
+type BidiLogger = (level: 'info' | 'warn', message: string) => void
+type InspectorFactory = (driver: unknown) => Promise<unknown>
+
+interface LogInspector {
+  onConsoleEntry: (cb: (entry: unknown) => void) => Promise<void>
+  onJavascriptException: (cb: (exc: unknown) => void) => Promise<void>
+}
+
+interface NetworkInspector {
+  beforeRequestSent: (cb: (e: unknown) => void) => Promise<void>
+  responseCompleted: (cb: (e: unknown) => void) => Promise<void>
+}
+
+export function handleBidiConsoleEntry(
+  rawEntry: unknown,
+  sinks: BidiHandlerSinks,
+  log: BidiLogger
+): void {
+  const entry = rawEntry as {
+    level?: string
+    type?: string
+    text?: string
+    message?: string
+    timestamp?: number
+  }
+  try {
+    const level = (entry?.level ?? entry?.type ?? 'info').toString()
+    const text = entry?.text ?? entry?.message ?? ''
+    sinks.pushConsoleLog({
+      timestamp: Number(entry?.timestamp) || Date.now(),
+      type: chromeLogLevelToLogLevel(level) as LogLevel,
+      args: [text],
+      source: LOG_SOURCES.BROWSER as LogSource
+    })
+  } catch (err) {
+    log('warn', `onConsoleEntry handler threw: ${errorMessage(err)}`)
+  }
+}
+
+export function handleBidiJsException(
+  rawExc: unknown,
+  sinks: BidiHandlerSinks,
+  log: BidiLogger
+): void {
+  const exception = rawExc as { text?: string; message?: string }
+  try {
+    const text = exception?.text ?? exception?.message ?? String(rawExc)
+    const trimmed = String(text).replace(/\s+/g, ' ').slice(0, 200)
+    log(
+      'warn',
+      `🐛 JS error in page: ${trimmed}${String(text).length > 200 ? '…' : ''}`
+    )
+    sinks.pushConsoleLog({
+      timestamp: Date.now(),
+      type: 'error',
+      args: [text],
+      source: LOG_SOURCES.BROWSER as LogSource
+    })
+  } catch (err) {
+    log('warn', `onJavascriptException handler threw: ${errorMessage(err)}`)
+  }
+}
+
+async function attachLogInspector(
+  driver: unknown,
+  factory: InspectorFactory,
+  sinks: BidiHandlerSinks,
+  log: BidiLogger
+): Promise<boolean> {
+  try {
+    const inspector = (await factory(driver)) as LogInspector
+    await inspector.onConsoleEntry((e) => handleBidiConsoleEntry(e, sinks, log))
+    await inspector.onJavascriptException((e) =>
+      handleBidiJsException(e, sinks, log)
+    )
+    log('info', '✓ BiDi LogInspector attached (console + JS exceptions)')
+    return true
+  } catch (err) {
+    log('warn', `BiDi LogInspector attach failed: ${errorMessage(err)}`)
+    return false
+  }
+}
+
+interface BeforeRequestSentEvent {
+  request?: {
+    request?: string
+    url?: string
+    method?: string
+    headers?: unknown
+  }
+  id?: string
+  timestamp?: number
+}
+
+interface ResponseCompletedEvent {
+  request?: { request?: string }
+  id?: string
+  timestamp?: number
+  response?: {
+    status?: number
+    statusText?: string
+    headers?: unknown
+    mimeType?: string
+    bytesReceived?: number
+  }
+}
+
+export function handleBidiRequestSent(
+  rawEvent: unknown,
+  pending: Map<string, NetworkRequest>,
+  sinks: BidiHandlerSinks,
+  log: BidiLogger
+): void {
+  const event = rawEvent as BeforeRequestSentEvent
+  try {
+    const requestId = String(event?.request?.request ?? event?.id ?? '')
+    if (!requestId) {
+      return
+    }
+    const entry: NetworkRequest = {
+      id: requestId,
+      url: event?.request?.url ?? '',
+      method: event?.request?.method ?? 'GET',
+      requestHeaders: arrayHeadersToObject(event?.request?.headers),
+      timestamp: Date.now(),
+      startTime: Number(event?.timestamp ?? Date.now()),
+      type: getRequestType(event?.request?.url ?? '')
+    }
+    pending.set(requestId, entry)
+    sinks.pushNetworkRequest(entry)
+  } catch (err) {
+    log('warn', `beforeRequestSent threw: ${errorMessage(err)}`)
+  }
+}
+
+export function handleBidiResponseCompleted(
+  rawEvent: unknown,
+  pending: Map<string, NetworkRequest>,
+  sinks: BidiHandlerSinks,
+  log: BidiLogger
+): void {
+  const event = rawEvent as ResponseCompletedEvent
+  try {
+    const requestId = String(event?.request?.request ?? event?.id ?? '')
+    const previous = pending.get(requestId)
+    if (!previous) {
+      return
+    }
+    const finalized: NetworkRequest = {
+      ...previous,
+      status: Number(event?.response?.status) || previous.status,
+      statusText: event?.response?.statusText ?? previous.statusText,
+      responseHeaders: arrayHeadersToObject(event?.response?.headers),
+      type: getRequestType(previous.url, event?.response?.mimeType),
+      endTime: Number(event?.timestamp ?? Date.now()),
+      time: Number(event?.timestamp ?? Date.now()) - previous.startTime,
+      size: Number(event?.response?.bytesReceived) || undefined
+    }
+    pending.delete(requestId)
+    sinks.replaceNetworkRequest(requestId, finalized)
+  } catch (err) {
+    log('warn', `responseCompleted threw: ${errorMessage(err)}`)
+  }
+}
+
+async function attachNetworkInspector(
+  driver: unknown,
+  factory: InspectorFactory,
+  sinks: BidiHandlerSinks,
+  log: BidiLogger
+): Promise<boolean> {
+  try {
+    const inspector = (await factory(driver)) as NetworkInspector
+    const pending = new Map<string, NetworkRequest>()
+    await inspector.beforeRequestSent((e) =>
+      handleBidiRequestSent(e, pending, sinks, log)
+    )
+    await inspector.responseCompleted((e) =>
+      handleBidiResponseCompleted(e, pending, sinks, log)
+    )
+    log('info', '✓ BiDi NetworkInspector attached (request + response)')
+    return true
+  } catch (err) {
+    log('warn', `BiDi NetworkInspector attach failed: ${errorMessage(err)}`)
+    return false
+  }
+}
+
+/**
+ * Attach the selenium-webdriver BiDi LogInspector + NetworkInspector to a
+ * driver and route their events into the given sinks. Returns `true` when at
+ * least one inspector connected — caller can disable the equivalent
+ * script-injection collectors to avoid duplicates.
+ *
+ * Tolerant of older / non-BiDi runtimes: if either submodule fails to load
+ * or the inspector factory throws (driver session doesn't have webSocketUrl
+ * capability set, etc.), the corresponding stream is silently skipped and
+ * the function returns false.
+ *
+ * @param onLog Optional callback for adapter-side logging. Receives ('info' |
+ * 'warn', message) on lifecycle events. Default: silent — adapters wire their
+ * own logger when they want visibility into BiDi attach state.
+ */
+export async function attachBidiHandlers(
+  driver: unknown,
+  sinks: BidiHandlerSinks,
+  onLog?: (level: 'info' | 'warn', message: string) => void
+): Promise<boolean> {
+  const log: BidiLogger = (level, message) => onLog?.(level, message)
+  const logFactory =
+    loadSeleniumSubmodule<InspectorFactory>('bidi/logInspector')
+  const networkFactory = loadSeleniumSubmodule<InspectorFactory>(
+    'bidi/networkInspector'
+  )
+
+  let attached = 0
+  if (typeof logFactory === 'function') {
+    if (await attachLogInspector(driver, logFactory, sinks, log)) {
+      attached++
+    }
+  } else {
+    log('info', 'selenium-webdriver/bidi/logInspector not available — skipping')
+  }
+  if (typeof networkFactory === 'function') {
+    if (await attachNetworkInspector(driver, networkFactory, sinks, log)) {
+      attached++
+    }
+  } else {
+    log(
+      'info',
+      'selenium-webdriver/bidi/networkInspector not available — skipping'
+    )
+  }
+  return attached > 0
+}
+
+/**
+ * Flatten BiDi's `Array<{name, value:{value|type}}>` header shape to a
+ * lowercased `Record<string, string>`. Exported so adapter-side helpers can
+ * reuse it for their own header normalization.
+ */
+export function arrayHeadersToObject(
+  headers: unknown
+): Record<string, string> | undefined {
+  if (!Array.isArray(headers)) {
+    return undefined
+  }
+  const out: Record<string, string> = {}
+  for (const h of headers as Array<{
+    name?: string
+    value?: string | { value?: string; type?: string }
+  }>) {
+    const name = String(h?.name ?? '').toLowerCase()
+    if (!name) {
+      continue
+    }
+    const v = h?.value
+    out[name] =
+      typeof v === 'string'
+        ? v
+        : typeof (v as { value?: string })?.value === 'string'
+          ? (v as { value: string }).value
+          : JSON.stringify(v ?? '')
+  }
+  return out
+}
diff --git a/packages/core/src/console.ts b/packages/core/src/console.ts
new file mode 100644
index 00000000..96d572ee
--- /dev/null
+++ b/packages/core/src/console.ts
@@ -0,0 +1,150 @@
+import type { ConsoleLog, LogLevel, LogSource } from '@wdio/devtools-shared'
+
+/**
+ * Console methods we intercept to forward test/runner-process output into the
+ * UI Console tab.
+ */
+export const CONSOLE_METHODS = ['log', 'info', 'warn', 'error'] as const
+
+/**
+ * Strips ANSI escape sequences (colour codes, cursor moves, etc.) from
+ * terminal output so the UI Console renders plain text. The pattern accepts
+ * any trailing letter, not just `m`, so cursor/style sequences are handled
+ * too.
+ */
+export const ANSI_REGEX = /\x1b\[[?]?[0-9;]*[A-Za-z]/g
+
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI_REGEX, '')
+}
+
+/**
+ * Log-level detection patterns, applied in priority order (highest to
+ * lowest). The first matching pattern wins.
+ */
+export const LOG_LEVEL_PATTERNS: ReadonlyArray<{
+  level: 'trace' | 'debug' | 'info' | 'warn' | 'error'
+  pattern: RegExp
+}> = [
+  { level: 'trace', pattern: /\btrace\b/i },
+  { level: 'debug', pattern: /\bdebug\b/i },
+  { level: 'info', pattern: /\binfo\b/i },
+  { level: 'warn', pattern: /\bwarn(ing)?\b/i },
+  { level: 'error', pattern: /\berror\b/i }
+] as const
+
+/** Visual indicators that suggest error-level logs in unstructured output. */
+export const ERROR_INDICATORS = ['✗', 'failed', 'failure'] as const
+
+/**
+ * Matches the leading Braille spinner glyphs that runners (Nightwatch CLI,
+ * Selenium tooling) emit for in-place progress updates. Adapters skip lines
+ * that match this so the dashboard's Console tab isn't flooded with frames.
+ */
+export const SPINNER_RE = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/u
+
+/**
+ * Filter out terminal/stream lines that would feed back into the WS bridge
+ * and cause an infinite forwarding loop: pino JSON output, [SESSION] markers,
+ * backend logger lines, Jest console framing, and bare stack-frame lines.
+ *
+ * Adapters call this from their stream-patch before forwarding lines to the
+ * UI Console tab. Combine with SPINNER_RE for full noise filtering.
+ */
+export function isInternalStreamLine(line: string): boolean {
+  const t = line.trim()
+  if (t.startsWith('{"') || t.startsWith('[SESSION]')) {
+    return true
+  }
+  if (t.includes('@wdio/devtools-backend')) {
+    return true
+  }
+  if (/^console\.(log|info|warn|error|debug|trace)$/.test(t)) {
+    return true
+  }
+  if (/^at\s.+:\d+:\d+\)?$/.test(t)) {
+    return true
+  }
+  return false
+}
+
+/** Enum-style accessor for the canonical LogSource values from shared. */
+export const LOG_SOURCES = {
+  BROWSER: 'browser',
+  TEST: 'test',
+  TERMINAL: 'terminal'
+} as const satisfies Record<string, LogSource>
+
+export type { LogSource } from '@wdio/devtools-shared'
+
+/**
+ * Classify a line of unstructured terminal output by scanning for log-level
+ * keywords. Falls back to `'log'` when no pattern matches.
+ */
+export function detectLogLevel(text: string): LogLevel {
+  const normalised = stripAnsi(text).toLowerCase()
+  for (const { level, pattern } of LOG_LEVEL_PATTERNS) {
+    if (pattern.test(normalised)) {
+      return level
+    }
+  }
+  if (ERROR_INDICATORS.some((i) => normalised.includes(i.toLowerCase()))) {
+    return 'error'
+  }
+  return 'log'
+}
+
+/** Build a ConsoleLog entry tagged with the supplied source. */
+export function createConsoleLogEntry(
+  type: LogLevel,
+  args: unknown[],
+  source: LogSource = LOG_SOURCES.TEST
+): ConsoleLog {
+  return { timestamp: Date.now(), type, args, source }
+}
+
+/**
+ * Map raw Chrome browser-log entries (the shape returned by both
+ * `driver.manage().logs().get('browser')` in selenium-webdriver and
+ * `browser.getLog('browser')` in nightwatch) into the dashboard's typed
+ * ConsoleLog shape, tagged as source='browser'. Each entry's Chrome level
+ * (`SEVERE` / `WARNING` / `INFO` / `DEBUG`) is normalised through
+ * {@link chromeLogLevelToLogLevel}.
+ */
+export function mapChromeBrowserLogs(
+  entries: Array<{ level: unknown; message: string; timestamp: number }>
+): ConsoleLog[] {
+  return entries.map((entry) => ({
+    timestamp: entry.timestamp,
+    type: chromeLogLevelToLogLevel(
+      entry.level as string | { value?: number; name?: string }
+    ),
+    args: [entry.message],
+    source: LOG_SOURCES.BROWSER
+  }))
+}
+
+/**
+ * Map a Chrome DevTools log-level string (or `{name, value}` object) to our
+ * `LogLevel` union. Used by CDP/BiDi consumers that surface browser-side
+ * console output through SEVERE/WARNING/INFO/DEBUG severity names.
+ */
+export function chromeLogLevelToLogLevel(
+  level: string | { value?: number; name?: string }
+): LogLevel {
+  const levelName = (
+    typeof level === 'object' ? (level?.name ?? '') : (level ?? '')
+  ).toUpperCase()
+  switch (levelName) {
+    case 'SEVERE':
+      return 'error'
+    case 'WARNING':
+      return 'warn'
+    case 'INFO':
+      return 'info'
+    case 'DEBUG':
+      return 'debug'
+    default:
+      return 'log'
+  }
+}
diff --git a/packages/core/src/error.ts b/packages/core/src/error.ts
new file mode 100644
index 00000000..7422fb84
--- /dev/null
+++ b/packages/core/src/error.ts
@@ -0,0 +1,79 @@
+/** Plain-object shape of an Error after `serializeError`. */
+export interface SerializedError {
+  name: string
+  message: string
+  stack?: string
+}
+
+/**
+ * Coerce an unknown value (caught exception, framework-supplied error
+ * object, string, etc.) into an Error instance. Used at adapter command
+ * boundaries where caught values can be anything — Error subclasses,
+ * thrown strings, framework objects with a `.message` — and downstream
+ * code wants a stable `Error` to inspect and serialize.
+ */
+export function toError(value: unknown): Error {
+  if (value instanceof Error) {
+    return value
+  }
+  if (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as { message?: unknown }).message === 'string'
+  ) {
+    const e = new Error((value as { message: string }).message)
+    const name = (value as { name?: unknown }).name
+    if (typeof name === 'string') {
+      e.name = name
+    }
+    return e
+  }
+  return new Error(String(value))
+}
+
+/**
+ * Extract a printable message from a caught value. Equivalent to reading
+ * `.message` on an Error, but degrades cleanly when the thrown value is a
+ * string, a plain object, undefined, or anything else — `(err as Error).message`
+ * silently returns `undefined` in those cases and yields useless log output.
+ */
+export function errorMessage(value: unknown): string {
+  if (value instanceof Error) {
+    return value.message
+  }
+  if (typeof value === 'string') {
+    return value
+  }
+  if (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as { message?: unknown }).message === 'string'
+  ) {
+    return (value as { message: string }).message
+  }
+  if (value === undefined || value === null) {
+    return 'unknown error'
+  }
+  try {
+    return String(value)
+  } catch {
+    return 'unknown error'
+  }
+}
+
+/**
+ * Normalize an Error to a plain object so its fields survive `JSON.stringify`
+ * over the WS bridge. Error instances have `message`/`name`/`stack` as
+ * non-enumerable, which `JSON.stringify` would drop.
+ *
+ * Returns `undefined` when the input is undefined so callers can pass through
+ * possibly-undefined values without an extra branch.
+ */
+export function serializeError(
+  error: Error | undefined
+): SerializedError | undefined {
+  if (!error) {
+    return undefined
+  }
+  return { name: error.name, message: error.message, stack: error.stack }
+}
diff --git a/packages/core/src/finalize-screencast.ts b/packages/core/src/finalize-screencast.ts
new file mode 100644
index 00000000..ed0a2474
--- /dev/null
+++ b/packages/core/src/finalize-screencast.ts
@@ -0,0 +1,83 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import type { ScreencastInfo } from '@wdio/devtools-shared'
+
+import type { ScreencastRecorderBase } from './screencast.js'
+import { errorMessage } from './error.js'
+import { encodeToVideo } from './video-encoder.js'
+
+export interface FinalizeScreencastInput {
+  recorder: ScreencastRecorderBase
+  sessionId: string
+  /** Filename without the .webm suffix (e.g. 'wdio-video', 'selenium-video'). */
+  filenamePrefix: string
+  /** Preferred output dir; falls back to cwd, then os.tmpdir() if unwritable. */
+  outputDir?: string
+  /** Skip encoding when the recorder collected fewer frames than this. */
+  minFrames?: number
+  captureFormat?: 'jpeg' | 'png'
+  /** Forward the encoded-video metadata to the dashboard. */
+  sendUpstream: (scope: string, data: ScreencastInfo) => void
+  /** Optional hook for adapter-side logging on each lifecycle step. */
+  onLog?: (level: 'info' | 'warn', message: string) => void
+}
+
+/**
+ * Stop the recorder, encode its frames to a `.webm` (preferred dir → cwd →
+ * tmpdir), and forward the metadata to the dashboard. All errors are caught
+ * and reported via `onLog` — screencast is best-effort and must not abort the
+ * run on stop/encode failure.
+ *
+ * Shared across all three adapters: each one provides only the recorder
+ * subclass, the filename prefix, and a sendUpstream binding to its
+ * SessionCapturer.
+ */
+export async function finalizeScreencast({
+  recorder,
+  sessionId,
+  filenamePrefix,
+  outputDir,
+  minFrames = 1,
+  captureFormat,
+  sendUpstream,
+  onLog
+}: FinalizeScreencastInput): Promise<void> {
+  const log = (level: 'info' | 'warn', message: string) =>
+    onLog?.(level, message)
+
+  try {
+    await recorder.stop()
+  } catch (err) {
+    log('warn', `Screencast stop failed: ${errorMessage(err)}`)
+    return
+  }
+
+  const frames = recorder.frames
+  if (frames.length < minFrames) {
+    return
+  }
+
+  const fileName = `${filenamePrefix}-${sessionId}.webm`
+  const candidate = outputDir || process.cwd()
+  let videoPath = path.join(candidate, fileName)
+  try {
+    fs.accessSync(candidate, fs.constants.W_OK)
+  } catch {
+    videoPath = path.join(os.tmpdir(), fileName)
+  }
+
+  try {
+    await encodeToVideo(frames, videoPath, { captureFormat })
+    log('info', `📹 Screencast video: ${videoPath}`)
+    sendUpstream('screencast', {
+      sessionId,
+      videoPath,
+      videoFile: fileName,
+      frameCount: frames.length,
+      duration: recorder.duration
+    })
+  } catch (err) {
+    log('warn', `Screencast encode failed: ${errorMessage(err)}`)
+  }
+}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
new file mode 100644
index 00000000..e34b6ac4
--- /dev/null
+++ b/packages/core/src/index.ts
@@ -0,0 +1,21 @@
+// Framework-agnostic capture/reporter logic shared by @wdio/devtools-*
+// adapters. See ARCHITECTURE.md §2 and CLAUDE.md §2.2.
+
+export * from './assert-patcher.js'
+export * from './bidi.js'
+export * from './console.js'
+export * from './uid.js'
+export * from './net.js'
+export * from './stack.js'
+export * from './error.js'
+export * from './finalize-screencast.js'
+export * from './output-dir.js'
+export * from './performance-capture.js'
+export * from './retry-tracker.js'
+export * from './screencast.js'
+export * from './script-loader.js'
+export * from './session-capturer.js'
+export * from './suite-helpers.js'
+export * from './test-discovery.js'
+export * from './test-reporter.js'
+export * from './video-encoder.js'
diff --git a/packages/core/src/net.ts b/packages/core/src/net.ts
new file mode 100644
index 00000000..eaf385da
--- /dev/null
+++ b/packages/core/src/net.ts
@@ -0,0 +1,76 @@
+import * as net from 'node:net'
+
+/**
+ * Return true if the given TCP port on `hostname` cannot be bound for
+ * listening (already in use, or otherwise unavailable).
+ */
+export function isPortInUse(port: number, hostname: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer()
+    server.once('error', () => resolve(true))
+    server.once('listening', () => server.close(() => resolve(false)))
+    server.listen(port, hostname)
+  })
+}
+
+/**
+ * Walk upward from `startPort` until a free port is found and return it.
+ * Silent: callers that want to log retries should wrap this themselves.
+ */
+export async function findFreePort(
+  startPort: number,
+  hostname: string
+): Promise<number> {
+  let port = startPort
+  while (await isPortInUse(port, hostname)) {
+    port++
+  }
+  return port
+}
+
+/**
+ * Classify an HTTP request into the categories the dashboard's Network tab
+ * uses, preferring the response `mimeType` and falling back to URL extension
+ * heuristics. Unknown shapes return `'xhr'`.
+ */
+export function getRequestType(url: string, mimeType?: string): string {
+  const contentType = mimeType?.toLowerCase() ?? ''
+  const urlLower = url.toLowerCase()
+  if (contentType.includes('text/html')) {
+    return 'document'
+  }
+  if (contentType.includes('text/css')) {
+    return 'stylesheet'
+  }
+  if (
+    contentType.includes('javascript') ||
+    contentType.includes('ecmascript')
+  ) {
+    return 'script'
+  }
+  if (contentType.includes('image/')) {
+    return 'image'
+  }
+  if (contentType.includes('font/') || contentType.includes('woff')) {
+    return 'font'
+  }
+  if (contentType.includes('application/json')) {
+    return 'fetch'
+  }
+  if (urlLower.endsWith('.html') || urlLower.endsWith('.htm')) {
+    return 'document'
+  }
+  if (urlLower.endsWith('.css')) {
+    return 'stylesheet'
+  }
+  if (urlLower.endsWith('.js') || urlLower.endsWith('.mjs')) {
+    return 'script'
+  }
+  if (/\.(png|jpg|jpeg|gif|svg|webp|ico)$/.test(urlLower)) {
+    return 'image'
+  }
+  if (/\.(woff|woff2|ttf|eot|otf)$/.test(urlLower)) {
+    return 'font'
+  }
+  return 'xhr'
+}
diff --git a/packages/core/src/output-dir.ts b/packages/core/src/output-dir.ts
new file mode 100644
index 00000000..fa659ace
--- /dev/null
+++ b/packages/core/src/output-dir.ts
@@ -0,0 +1,86 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+export interface ResolveAdapterOutputDirInput {
+  /**
+   * Honored as-is if set — used by adapters that expose a user-facing
+   * `outputDir` option (e.g. WDIO). Skips all other resolution steps.
+   */
+  userConfiguredDir?: string
+  /**
+   * Absolute path to the current test file. When known, the video / trace
+   * lands in the same folder as the spec the user just ran. This is the
+   * preferred location across adapters.
+   */
+  testFilePath?: string
+  /**
+   * Absolute path to the resolved framework config file (wdio.conf.ts,
+   * nightwatch.conf.cjs, etc.). Used as a fallback when the test file
+   * isn't known.
+   */
+  configPath?: string
+  /** Last-resort fallback. Defaults to `process.cwd()`. */
+  fallbackDir?: string
+}
+
+const NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`
+
+function isWritable(dir: string): boolean {
+  try {
+    fs.accessSync(dir, fs.constants.W_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Resolve the directory where an adapter should write output files
+ * (screencast .webm, trace JSON, etc.).
+ *
+ * Priority:
+ *   1. `userConfiguredDir` — explicit opt-in, honored as-is.
+ *   2. `dirname(testFilePath)` — same folder as the spec that just ran.
+ *   3. `dirname(configPath)` — fallback to the framework config dir.
+ *   4. `fallbackDir` (default `process.cwd()`).
+ *
+ * Any candidate inside a `node_modules/` segment is skipped — this can
+ * happen in symlinked workspaces where the test file resolves through a
+ * linked dependency. Each candidate must also be writable; non-writable
+ * dirs fall through to the next.
+ *
+ * Shared by all three adapters (service / nightwatch-devtools /
+ * selenium-devtools) so the output location stays consistent regardless
+ * of where the user invoked the runner from. See CLAUDE.md §2.2.
+ */
+export function resolveAdapterOutputDir(
+  input: ResolveAdapterOutputDirInput = {}
+): string {
+  const fallback = input.fallbackDir ?? process.cwd()
+  // userConfiguredDir bypasses the node_modules and writability filters
+  // because the user opted into it explicitly — surprising overrides are
+  // worse than failing loudly here.
+  if (input.userConfiguredDir) {
+    return input.userConfiguredDir
+  }
+  const candidates: string[] = []
+  if (input.testFilePath) {
+    candidates.push(path.dirname(input.testFilePath))
+  }
+  if (input.configPath) {
+    candidates.push(path.dirname(input.configPath))
+  }
+  candidates.push(fallback)
+  for (const dir of candidates) {
+    if (!dir) {
+      continue
+    }
+    if (dir.includes(NODE_MODULES_SEGMENT)) {
+      continue
+    }
+    if (isWritable(dir)) {
+      return dir
+    }
+  }
+  return fallback
+}
diff --git a/packages/core/src/performance-capture.ts b/packages/core/src/performance-capture.ts
new file mode 100644
index 00000000..0e1f5b3f
--- /dev/null
+++ b/packages/core/src/performance-capture.ts
@@ -0,0 +1,102 @@
+import type {
+  CommandLog,
+  DocumentInfo,
+  PerformanceData
+} from '@wdio/devtools-shared'
+
+/**
+ * JS source that captures Performance API data, cookies, and document info
+ * from the page under test. Passed as a string to the adapter's `execute`/
+ * `executeScript` driver method so the browser-only types (PerformanceEntry,
+ * Document) don't leak into the Node-side type-checker.
+ *
+ * Returns the bag shape consumed by {@link applyPerformanceData}.
+ * Framework-agnostic — all three adapters can use it.
+ */
+export const CAPTURE_PERFORMANCE_SCRIPT = `
+  (function() {
+    const performance = window.performance;
+    const navigation = performance.getEntriesByType?.('navigation')?.[0];
+    const resources = performance.getEntriesByType?.('resource') || [];
+
+    return {
+      navigation: navigation ? {
+        url: window.location.href,
+        timing: {
+          loadTime: navigation.loadEventEnd - navigation.fetchStart,
+          domReady: navigation.domContentLoadedEventEnd - navigation.fetchStart,
+          responseTime: navigation.responseEnd - navigation.requestStart,
+          dnsLookup: navigation.domainLookupEnd - navigation.domainLookupStart,
+          tcpConnection: navigation.connectEnd - navigation.connectStart,
+          serverResponse: navigation.responseEnd - navigation.responseStart
+        }
+      } : undefined,
+      resources: resources.map(function(resource) {
+        return {
+          url: resource.name,
+          duration: resource.duration,
+          size: resource.transferSize || 0,
+          type: resource.initiatorType,
+          startTime: resource.startTime,
+          responseEnd: resource.responseEnd
+        };
+      }),
+      cookies: (function() {
+        try { return document.cookie; } catch (e) { return ''; }
+      })(),
+      documentInfo: {
+        url: window.location.href,
+        title: document.title,
+        headers: {
+          userAgent: navigator.userAgent,
+          language: navigator.language,
+          platform: navigator.platform
+        },
+        documentInfo: {
+          readyState: document.readyState,
+          referrer: document.referrer,
+          characterSet: document.characterSet
+        }
+      }
+    };
+  })()
+`
+
+/** Untyped bag returned by {@link CAPTURE_PERFORMANCE_SCRIPT}. */
+export interface CapturedPerformancePayload {
+  navigation?: PerformanceData['navigation']
+  resources?: PerformanceData['resources']
+  cookies?: string
+  documentInfo?: DocumentInfo
+}
+
+/**
+ * Apply a captured performance payload onto a CommandLog entry in-place,
+ * setting `performance`, `cookies`, `documentInfo`, and a synthesized `result`
+ * matching nightwatch's existing dashboard shape. Returns `true` if anything
+ * was applied — caller can branch on this to skip further work.
+ */
+export function applyPerformanceData(
+  command: CommandLog,
+  payload: CapturedPerformancePayload | undefined,
+  navigatedUrl?: string
+): boolean {
+  if (!payload || !payload.navigation) {
+    return false
+  }
+  command.performance = {
+    navigation: payload.navigation,
+    resources: payload.resources
+  }
+  command.cookies = payload.cookies
+  command.documentInfo = payload.documentInfo
+  command.result = {
+    url: navigatedUrl,
+    loadTime: payload.navigation?.timing?.loadTime,
+    resources: payload.resources,
+    resourceCount: payload.resources?.length,
+    cookies: payload.cookies,
+    title: payload.documentInfo?.title
+  }
+  return true
+}
diff --git a/packages/core/src/retry-tracker.ts b/packages/core/src/retry-tracker.ts
new file mode 100644
index 00000000..332e3cdb
--- /dev/null
+++ b/packages/core/src/retry-tracker.ts
@@ -0,0 +1,62 @@
+/**
+ * Tiny state holder for command-retry detection. Both the selenium and
+ * nightwatch adapters need exactly this same pattern: compute a stable
+ * signature for the incoming command, compare it to the last one we
+ * captured, and treat a match as "the framework is retrying — replace the
+ * previous entry instead of pushing a new one".
+ *
+ * The signature is JSON-stringified `{command, args, src: callSource}`. Test
+ * boundaries (new test, new scenario) call `reset()` to drop the last
+ * signature so a deliberate re-run of the same call counts as a fresh
+ * command, not a retry.
+ */
+export class RetryTracker {
+  #lastSig: string | null = null
+  #lastId: number | null = null
+
+  /** Build the canonical signature used for retry-equality checks. */
+  static signature(
+    command: string,
+    args: unknown,
+    callSource?: string
+  ): string {
+    return JSON.stringify({ command, args, src: callSource ?? null })
+  }
+
+  /** True when the incoming signature matches the last captured one AND we
+   *  have an id to replace (otherwise there's nothing to replace yet). */
+  isRetry(sig: string): boolean {
+    return sig === this.#lastSig && this.#lastId !== null
+  }
+
+  /** The id of the last captured command, if any (for the replace-in-place
+   *  flow). */
+  get lastId(): number | null {
+    return this.#lastId
+  }
+
+  /** Record a fresh capture — sets both sig and id together. */
+  recordCapture(sig: string, id: number | null): void {
+    this.#lastSig = sig
+    this.#lastId = id
+  }
+
+  /** Record only the id (used by adapters that compute the sig but defer the
+   *  id assignment to after an async capture call). */
+  setLastId(id: number | null): void {
+    this.#lastId = id
+  }
+
+  /** Stage the sig before an async capture so the next call already sees the
+   *  signature change (prevents stale-sig matches on rapid back-to-back
+   *  commands). Pair with {@link setLastId} once the capture resolves. */
+  setLastSig(sig: string): void {
+    this.#lastSig = sig
+  }
+
+  /** Reset at test/scenario boundaries so the next capture is "fresh". */
+  reset(): void {
+    this.#lastSig = null
+    this.#lastId = null
+  }
+}
diff --git a/packages/core/src/screencast.ts b/packages/core/src/screencast.ts
new file mode 100644
index 00000000..892d1bcd
--- /dev/null
+++ b/packages/core/src/screencast.ts
@@ -0,0 +1,212 @@
+import type { ScreencastFrame, ScreencastOptions } from '@wdio/devtools-shared'
+import { SCREENCAST_DEFAULTS } from '@wdio/devtools-shared'
+
+/**
+ * Shared screencast scaffolding consumed by every adapter (service, selenium,
+ * nightwatch). Owns the frame buffer, public API (start/stop/setStartMarker,
+ * frames/duration/isRecording getters) and the polling fallback. Subclasses
+ * provide framework-specific driver access:
+ *
+ *   - `takeScreenshot()` — required. Used by the polling path.
+ *   - `tryStartCdp() / tryStopCdp()` — optional CDP push-mode override.
+ *     Default returns false → falls through to polling.
+ *
+ * Adapters that have a stable CDP escape hatch (WDIO via getPuppeteer,
+ * Selenium via createCDPConnection) override the CDP hooks. Nightwatch
+ * inherits the polling-only default — works on every browser Nightwatch
+ * supports without extra plumbing.
+ */
+export abstract class ScreencastRecorderBase<TDriver = unknown> {
+  protected buffer: ScreencastFrame[] = []
+  protected options: Required<ScreencastOptions>
+  protected driver?: TDriver
+  #pollTimer: ReturnType<typeof setInterval> | undefined
+  #isRecording = false
+  #cdpActive = false
+  #startIndex = 0
+  #startMarkerSet = false
+
+  constructor(options: ScreencastOptions = {}) {
+    this.options = { ...SCREENCAST_DEFAULTS, ...options }
+  }
+
+  /**
+   * Start recording. Tries the CDP fast-path first (if the subclass overrode
+   * `tryStartCdp`); falls back to screenshot polling otherwise. Safe to call
+   * even if the browser doesn't support screenshots — failures are logged and
+   * recording is simply skipped.
+   */
+  async start(driver: TDriver): Promise<void> {
+    if (this.#isRecording) {
+      return
+    }
+    this.driver = driver
+    const cdpOk = await this.tryStartCdp()
+    if (cdpOk) {
+      this.#cdpActive = true
+      this.#isRecording = true
+      return
+    }
+    await this.#startPolling()
+  }
+
+  /**
+   * Stop recording and release resources. Safe to call even if start() was
+   * never called or failed.
+   */
+  async stop(): Promise<void> {
+    if (!this.#isRecording) {
+      return
+    }
+    if (this.#cdpActive) {
+      await this.tryStopCdp()
+      this.#cdpActive = false
+    } else if (this.#pollTimer !== undefined) {
+      this.#stopPolling()
+    }
+    this.#isRecording = false
+  }
+
+  /**
+   * Mark the current frame position as the start of meaningful recording.
+   * Frames captured before this call (blank browser, pre-navigation pauses)
+   * are excluded from `frames`. Idempotent — only the first call takes effect.
+   */
+  setStartMarker(): void {
+    if (!this.#startMarkerSet) {
+      this.#startMarkerSet = true
+      this.#startIndex = this.buffer.length
+    }
+  }
+
+  /** Frames to encode — everything from the first meaningful action onwards. */
+  get frames(): ScreencastFrame[] {
+    return this.buffer.slice(this.#startIndex)
+  }
+
+  /** Duration in ms between first and last captured frame. Zero if <2 frames. */
+  get duration(): number {
+    const f = this.frames
+    if (f.length < 2) {
+      return 0
+    }
+    return f[f.length - 1].timestamp - f[0].timestamp
+  }
+
+  get isRecording(): boolean {
+    return this.#isRecording
+  }
+
+  // ─── Subclass hooks ──────────────────────────────────────────────────────
+
+  /**
+   * Capture a single screenshot via the framework's driver API. Used by the
+   * polling fallback. Return `null` to indicate a transient failure (loop
+   * continues); throw to abort polling entirely.
+   */
+  protected abstract takeScreenshot(): Promise<string | null>
+
+  /**
+   * Try to start CDP push-mode recording. Return `true` on success. Default
+   * returns `false` → caller falls back to polling. Subclasses that wire CDP
+   * push themselves (WDIO via Puppeteer, Selenium via createCDPConnection)
+   * override and push frames into `this.frames` directly when CDP fires.
+   */
+  protected async tryStartCdp(): Promise<boolean> {
+    return false
+  }
+
+  /** Stop the CDP push-mode session started by `tryStartCdp`. */
+  protected async tryStopCdp(): Promise<void> {
+    // no-op
+  }
+
+  /**
+   * Helper for CDP subclasses: push a frame onto the buffer with the right
+   * timestamp normalization (CDP gives seconds-as-float; we store ms).
+   */
+  protected pushCdpFrame(data: string, timestampSeconds?: number): void {
+    const timestamp =
+      typeof timestampSeconds === 'number'
+        ? Math.round(timestampSeconds * 1000)
+        : Date.now()
+    this.buffer.push({ data, timestamp })
+  }
+
+  /** Whether `setStartMarker` (or `markStartAtLatest`) has fired yet. */
+  protected get hasStartMarker(): boolean {
+    return this.#startMarkerSet
+  }
+
+  /**
+   * Anchor the start marker to the most recently pushed frame. Used by
+   * subclasses that detect the first content-bearing frame heuristically
+   * (e.g. selenium's blank-frame-byte-size threshold) and want to skip the
+   * preceding about:blank dead-air without waiting for an explicit caller.
+   */
+  protected markStartAtLatest(): void {
+    if (!this.#startMarkerSet) {
+      this.#startMarkerSet = true
+      this.#startIndex = Math.max(0, this.buffer.length - 1)
+    }
+  }
+
+  // ─── Polling implementation ─────────────────────────────────────────────
+
+  /**
+   * Hook fired when the polling loop starts. Default: no-op. Subclasses
+   * (adapters with their own logger) override to surface visibility.
+   */
+  protected onPollingStarted(_intervalMs: number): void {
+    // no-op
+  }
+
+  /** Hook fired when polling stops cleanly (driver still alive at the time). */
+  protected onPollingStopped(_frameCount: number): void {
+    // no-op
+  }
+
+  /** Hook fired when the polling fallback couldn't even take the first shot. */
+  protected onUnavailable(_err: unknown): void {
+    // no-op
+  }
+
+  // ─── Polling implementation ─────────────────────────────────────────────
+
+  async #startPolling(): Promise<void> {
+    try {
+      const first = await this.takeScreenshot()
+      if (first === null) {
+        this.onUnavailable(new Error('first screenshot returned null'))
+        return
+      }
+      this.buffer.push({ data: first, timestamp: Date.now() })
+
+      const intervalMs = this.options.pollIntervalMs
+      this.#pollTimer = setInterval(async () => {
+        try {
+          const data = await this.takeScreenshot()
+          if (data !== null) {
+            this.buffer.push({ data, timestamp: Date.now() })
+          }
+        } catch {
+          // Session ended mid-interval — stop polling gracefully.
+          this.#stopPolling()
+        }
+      }, intervalMs)
+
+      this.#isRecording = true
+      this.onPollingStarted(intervalMs)
+    } catch (err) {
+      this.onUnavailable(err)
+    }
+  }
+
+  #stopPolling(): void {
+    if (this.#pollTimer !== undefined) {
+      clearInterval(this.#pollTimer)
+      this.#pollTimer = undefined
+      this.onPollingStopped(this.buffer.length)
+    }
+  }
+}
diff --git a/packages/core/src/script-loader.ts b/packages/core/src/script-loader.ts
new file mode 100644
index 00000000..a17a472a
--- /dev/null
+++ b/packages/core/src/script-loader.ts
@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+
+/**
+ * Load the `@wdio/devtools-script` browser preload, wrapped in an async IIFE
+ * so its top-level `await` works inside a regular `<script>` element body.
+ * Shared by selenium-devtools and nightwatch-devtools, which both inject the
+ * script via `document.createElement('script')` rather than BiDi preload (the
+ * WDIO service uses `browser.scriptAddPreloadScript`, which doesn't need the
+ * wrap and stays in its own adapter).
+ */
+export async function loadInjectableScript(): Promise<string> {
+  const scriptPath = require.resolve('@wdio/devtools-script')
+  const scriptDir = path.dirname(scriptPath)
+  const preloadScriptPath = path.join(scriptDir, 'script.js')
+  const scriptContent = await fs.readFile(preloadScriptPath, 'utf-8')
+  return `(async function() { ${scriptContent} })()`
+}
+
+/**
+ * Poll a readiness check until it returns true, or the attempts run out.
+ * Defaults to 5 × 200ms = up to 1 second total — chosen empirically to cover
+ * the async IIFE init time across browsers we test against.
+ */
+export async function pollUntilReady(
+  check: () => Promise<boolean>,
+  opts: { attempts?: number; intervalMs?: number } = {}
+): Promise<boolean> {
+  const attempts = opts.attempts ?? 5
+  const intervalMs = opts.intervalMs ?? 200
+  for (let i = 0; i < attempts; i++) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs))
+    if (await check()) {
+      return true
+    }
+  }
+  return false
+}
diff --git a/packages/core/src/session-capturer.ts b/packages/core/src/session-capturer.ts
new file mode 100644
index 00000000..115e8360
--- /dev/null
+++ b/packages/core/src/session-capturer.ts
@@ -0,0 +1,502 @@
+import fs from 'node:fs/promises'
+import { WebSocket } from 'ws'
+import type {
+  CommandLog,
+  ConsoleLog,
+  LogLevel,
+  LogSource,
+  Metadata,
+  NetworkRequest,
+  TraceMutation
+} from '@wdio/devtools-shared'
+import { WS_PATHS, WS_SCOPE } from '@wdio/devtools-shared'
+import {
+  CONSOLE_METHODS,
+  LOG_SOURCES,
+  SPINNER_RE,
+  createConsoleLogEntry,
+  detectLogLevel,
+  isInternalStreamLine,
+  stripAnsi
+} from './console.js'
+
+/**
+ * Foundation class for adapter SessionCapturers. Owns the cross-framework
+ * scaffolding (WS connection, console/stream patching, command id
+ * bookkeeping). Framework-specific event handling stays in subclasses.
+ *
+ * Step 2 of {@link file://./../../../SESSIONCAPTURER_EXTRACTION_PLAN.md}.
+ * **Not yet consumed by any adapter** — published so a future session can
+ * migrate adapter SessionCapturer classes one at a time.
+ */
+
+export interface SessionCapturerOptions {
+  hostname?: string
+  port?: number
+}
+
+type ConsoleMethod = (typeof CONSOLE_METHODS)[number]
+
+export abstract class SessionCapturerBase {
+  // ── State (mostly private; subclasses access shared ws via `this.ws`) ────
+  /**
+   * Exposed as `protected` so subclasses with framework-specific close/wait
+   * semantics (e.g. nightwatch's `closeWebSocket` with timeout) can operate
+   * on the socket directly. Default lifecycle is fully managed by the base.
+   */
+  protected ws: WebSocket | undefined
+  #hasConnected = false
+  #originalConsoleMethods: Record<ConsoleMethod, typeof console.log>
+  #originalStdoutWrite = process.stdout.write.bind(process.stdout)
+  #originalStderrWrite = process.stderr.write.bind(process.stderr)
+  // Two flags (not one): prevents re-entrant capture when console.* writes to
+  // stdout, OR when stream forwarding wants to log via console.
+  #isCapturingConsole = false
+  #isCapturingStream = false
+
+  // Command bookkeeping — used by adapters that emit commands themselves
+  // (nightwatch, selenium). The WDIO service adapter doesn't call sendCommand
+  // (WDIO owns the command lifecycle), so this state is harmless overhead.
+  // `protected` (not `#`) so subclasses can override the send/replace flow
+  // while still sharing the counter and de-dup set with base helpers.
+  protected commandCounter = 0
+  protected sentCommandIds = new Set<number>()
+
+  // Map of file path → source text. Populated by `captureSource` (also
+  // accessed by adapter-specific source-discovery flows, e.g. service's
+  // `ensureSourceLoaded` which parses `file://` locations first).
+  sources = new Map<string, string>()
+
+  // Captured trace payload — populated by `processTracePayload` (driven from
+  // adapter-specific `captureTrace` flows) and by direct pushes from BiDi/CDP
+  // listeners. Mutations stay `unknown[]` here because the canonical
+  // `TraceMutation` shape is a browser-only DOM type (script package); cross-
+  // package consumers treat the array as opaque.
+  commandsLog: CommandLog[] = []
+  consoleLogs: ConsoleLog[] = []
+  networkRequests: NetworkRequest[] = []
+  mutations: TraceMutation[] = []
+  traceLogs: string[] = []
+  metadata?: Metadata
+
+  // ── Construction ────────────────────────────────────────────────────────
+  constructor(opts: SessionCapturerOptions = {}) {
+    const { hostname, port } = opts
+    if (hostname && port) {
+      this.ws = new WebSocket(`ws://${hostname}:${port}${WS_PATHS.worker}`)
+      this.ws.on('open', () => {
+        this.#hasConnected = true
+        this.onWsOpen()
+      })
+      this.ws.on('error', (err: unknown) => this.onWsError(err))
+      this.ws.on('close', () => this.onWsClose())
+      this.ws.on('message', (raw: Buffer | string) => {
+        try {
+          const parsed = JSON.parse(raw.toString())
+          this.onWsMessage(parsed)
+        } catch {
+          // ignore non-JSON
+        }
+      })
+    }
+
+    this.#originalConsoleMethods = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error
+    }
+  }
+
+  // ── Public API ──────────────────────────────────────────────────────────
+  /**
+   * Send a typed event to the dashboard. No-op if the WS isn't open. Catches
+   * send-time exceptions so a transient socket error never aborts the host
+   * runner. Subclasses that want diagnostics on drop or error override
+   * {@link onUpstreamDrop}.
+   */
+  sendUpstream(event: string, data: unknown): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.onUpstreamDrop(event, 'closed')
+      return
+    }
+    try {
+      this.ws.send(JSON.stringify({ scope: event, data }))
+    } catch (err) {
+      this.onUpstreamDrop(event, 'send-error', err)
+    }
+  }
+
+  /**
+   * Hook fired when a {@link sendUpstream} call can't deliver. Default: silent
+   * (matches the historical behavior of service/selenium). Nightwatch overrides
+   * this to log a warning — useful when a runner drops mid-test and the user
+   * needs to know why captured data is incomplete.
+   */
+  protected onUpstreamDrop(
+    _event: string,
+    _reason: 'closed' | 'send-error',
+    _err?: unknown
+  ): void {
+    // no-op
+  }
+
+  /** True once the WS has opened at least once and is currently OPEN. */
+  isConnected(): boolean {
+    return Boolean(this.ws) && this.ws?.readyState === WebSocket.OPEN
+  }
+
+  /** Property-style alias for {@link isConnected} — used by tests that
+   *  read it as a getter while mutating `ws.readyState` directly. */
+  get isReportingUpstream(): boolean {
+    return this.isConnected()
+  }
+
+  /** Subclasses can read this to gate retry/reconnect logic. */
+  protected hasEverConnected(): boolean {
+    return this.#hasConnected
+  }
+
+  /**
+   * Send a CommandLog over the WS. If the entry already has an `_id` (set by
+   * the adapter's `captureCommand` during buffering), use it; otherwise
+   * allocate a fresh one. The `_id` is the de-dup key and is stripped from
+   * the broadcast payload — it's adapter-internal bookkeeping.
+   * Returns the id, or 0 if the entry had no `_id` and none could be assigned.
+   */
+  sendCommand(command: CommandLog & { _id?: number }): number {
+    if (command._id === undefined) {
+      command._id = this.commandCounter++
+    }
+    const id = command._id
+    if (this.sentCommandIds.has(id)) {
+      return id
+    }
+    this.sentCommandIds.add(id)
+    const toSend = { ...command }
+    delete toSend._id
+    this.sendUpstream('commands', [toSend])
+    return id
+  }
+
+  /**
+   * Emit a `replaceCommand` event swapping an earlier entry in-place. Strips
+   * the adapter-internal `_id` field before sending — that's bookkeeping for
+   * the local `sentCommandIds` set and shouldn't reach the UI.
+   */
+  sendReplaceCommand(
+    oldTimestamp: number,
+    command: CommandLog & { _id?: number }
+  ): void {
+    const toSend = { ...command }
+    delete toSend._id
+    this.sendUpstream(WS_SCOPE.replaceCommand, {
+      oldTimestamp,
+      command: toSend
+    })
+  }
+
+  /**
+   * Read a file from disk, store in `sources`, and broadcast to the UI via
+   * `sendUpstream('sources', { [path]: text })`. Idempotent — a cached path is
+   * a no-op. Read errors are logged via `onSourceReadError` (default: silent)
+   * so a missing source never aborts capture.
+   */
+  async captureSource(filePath: string): Promise<void> {
+    if (this.sources.has(filePath)) {
+      return
+    }
+    try {
+      const source = (await fs.readFile(filePath, 'utf-8')).toString()
+      this.sources.set(filePath, source)
+      this.sendUpstream('sources', { [filePath]: source })
+    } catch (err) {
+      this.onSourceReadError(filePath, err)
+    }
+  }
+
+  /**
+   * Hook fired when `captureSource` can't read a file. Default: silent.
+   * Subclasses (nightwatch, selenium) override to log a warning.
+   */
+  protected onSourceReadError(_filePath: string, _err: unknown): void {
+    // no-op — service silently swallows; subclasses can opt into a log line.
+  }
+
+  /**
+   * Ingest the `{ mutations, traceLogs, consoleLogs, networkRequests, metadata }`
+   * payload returned by the page-side `wdioTraceCollector.getTraceData()`.
+   * Tags console logs with `source: 'browser'`, pushes each array into the
+   * matching local field, and broadcasts via the appropriate WS scopes.
+   *
+   * `skipConsoleLogs` / `skipNetworkRequests` opt out when an out-of-band
+   * channel (BiDi) is already delivering those streams — without the gate
+   * the dashboard would see each entry twice.
+   */
+  protected processTracePayload(
+    payload: {
+      mutations?: unknown
+      traceLogs?: unknown
+      consoleLogs?: unknown
+      networkRequests?: unknown
+      metadata?: unknown
+    },
+    opts: { skipConsoleLogs?: boolean; skipNetworkRequests?: boolean } = {}
+  ): void {
+    const { mutations, traceLogs, consoleLogs, networkRequests, metadata } =
+      payload
+
+    if (metadata && typeof metadata === 'object') {
+      // Page-side trace data is a JS bag; only fields that match Metadata
+      // survive at runtime, but TS can't prove that. Cast to Partial<Metadata>
+      // so the merge stays type-checked while accepting incomplete payloads.
+      this.metadata = {
+        ...this.metadata,
+        ...(metadata as Partial<Metadata>)
+      } as Metadata
+      this.sendUpstream('metadata', this.metadata)
+    }
+
+    if (
+      !opts.skipConsoleLogs &&
+      Array.isArray(consoleLogs) &&
+      consoleLogs.length > 0
+    ) {
+      const tagged = (consoleLogs as ConsoleLog[]).map((entry) => ({
+        ...entry,
+        source: LOG_SOURCES.BROWSER as LogSource
+      }))
+      this.consoleLogs.push(...tagged)
+      this.sendUpstream('consoleLogs', tagged)
+    }
+
+    if (
+      !opts.skipNetworkRequests &&
+      Array.isArray(networkRequests) &&
+      networkRequests.length > 0
+    ) {
+      const reqs = networkRequests as NetworkRequest[]
+      this.networkRequests.push(...reqs)
+      this.sendUpstream('networkRequests', reqs)
+    }
+
+    if (Array.isArray(mutations) && mutations.length > 0) {
+      this.mutations.push(...mutations)
+      this.sendUpstream('mutations', mutations)
+    }
+
+    if (Array.isArray(traceLogs) && traceLogs.length > 0) {
+      const logs = traceLogs as string[]
+      this.traceLogs.push(...logs)
+      this.sendUpstream('logs', logs)
+    }
+  }
+
+  /**
+   * Resolve when the WS reaches OPEN state, or `false` on timeout / error.
+   * Returns immediately if already open. Used by adapters that need a
+   * synchronization barrier before injecting page-side scripts.
+   */
+  async waitForConnection(timeoutMs = 5000): Promise<boolean> {
+    if (!this.ws) {
+      return false
+    }
+    if (this.ws.readyState === WebSocket.OPEN) {
+      return true
+    }
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => resolve(false), timeoutMs)
+      this.ws!.once('open', () => {
+        clearTimeout(timeout)
+        resolve(true)
+      })
+      this.ws!.once('error', () => {
+        clearTimeout(timeout)
+        resolve(false)
+      })
+    })
+  }
+
+  /**
+   * Gracefully close the WS, waiting up to 2s for buffered messages to flush.
+   * Call before process exit in reuse mode (or after dashboard close) so the
+   * backend sees a clean close instead of an abrupt TCP reset.
+   */
+  async closeWebSocket(): Promise<void> {
+    if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+      return
+    }
+    return new Promise<void>((resolve) => {
+      const timeout = setTimeout(resolve, 2000)
+      this.ws!.once('close', () => {
+        clearTimeout(timeout)
+        resolve()
+      })
+      this.ws!.close()
+    })
+  }
+
+  /**
+   * Restore console/streams. Does NOT close the WS — that's the subclass's
+   * call (see `closeWebSocket` on nightwatch/selenium). Closing here would
+   * break the wait-for-dashboard-close flow, since the worker WS is the
+   * channel the backend uses to signal `clientDisconnected`.
+   */
+  cleanup(): void {
+    this.restoreConsole()
+    this.restoreStreams()
+  }
+
+  // ── Patching (call from subclass constructor) ───────────────────────────
+  /** Patch `console.log/info/warn/error` to forward through `onLine`. */
+  protected patchConsole(): void {
+    CONSOLE_METHODS.forEach((method) => {
+      const original = this.#originalConsoleMethods[method]
+      console[method] = (...args: unknown[]) => {
+        this.#isCapturingConsole = true
+        const result = original.apply(console, args)
+        this.#isCapturingConsole = false
+
+        const serialized = args.map((a) =>
+          typeof a === 'object' && a !== null ? safeStringify(a) : String(a)
+        )
+        const joined = stripAnsi(serialized.join(' ')).trim()
+        if (!joined || this.isInternalStreamLine(joined)) {
+          return result
+        }
+        // Pass the per-arg serialized array (`['payload', '{"x":1}']`) rather
+        // than the joined string. The dashboard's `#formatArgs` joins on its
+        // own; preserving the array form is lossless and lets future consumers
+        // group/style individual args.
+        this.onLine(method as LogLevel, serialized, LOG_SOURCES.TEST)
+        return result
+      }
+    })
+  }
+
+  /**
+   * Wrap `process.stdout.write` and `process.stderr.write` to forward chunks
+   * through `onLine`. The base's `#isCapturingConsole` flag prevents
+   * re-entrance when console patching itself writes to stdout.
+   */
+  protected patchStreams(): void {
+    const captureChunk = (raw: string | Uint8Array) => {
+      if (this.#isCapturingStream) {
+        return
+      }
+      const text = typeof raw === 'string' ? raw : raw.toString()
+      if (!text?.trim()) {
+        return
+      }
+      this.#isCapturingStream = true
+      try {
+        for (const rawLine of text.split('\n')) {
+          // Strip CR-overwrites so progress bars don't show partial frames.
+          const segments = rawLine.split('\r').filter((s) => s.trim())
+          const lastSegment = segments[segments.length - 1] ?? rawLine
+          const clean = stripAnsi(lastSegment).trim()
+          if (
+            !clean ||
+            this.isInternalStreamLine(clean) ||
+            SPINNER_RE.test(clean)
+          ) {
+            continue
+          }
+          this.onLine(detectLogLevel(clean), [clean], LOG_SOURCES.TERMINAL)
+        }
+      } finally {
+        this.#isCapturingStream = false
+      }
+    }
+
+    // `stream.write` has Node's complex multi-overload signature that
+    // doesn't unify with a generic `unknown[]` rest type — keep the
+    // original ref typed by the stream itself.
+    const wrap = (
+      stream: NodeJS.WriteStream,
+      original: NodeJS.WriteStream['write']
+    ) => {
+      const capturer = this
+      // `stream.write` has Node's multi-overload signature that's hard to
+      // satisfy with a single function expression — cast to the stream's
+      // own `write` member type rather than `any`.
+      stream.write = function (chunk: unknown, ...rest: unknown[]): boolean {
+        // Cast original to a permissive shape — Node's multi-overload
+        // signature for `stream.write` can't be unified with the `unknown`-
+        // typed chunk we receive at the wrap boundary.
+        const writeAny = original as unknown as (...a: unknown[]) => boolean
+        const result = writeAny.call(stream, chunk, ...rest)
+        if (chunk && !capturer.#isCapturingConsole) {
+          captureChunk(chunk as string | Uint8Array)
+        }
+        return result
+      } as typeof stream.write
+    }
+
+    wrap(process.stdout, this.#originalStdoutWrite)
+    wrap(process.stderr, this.#originalStderrWrite)
+  }
+
+  protected restoreConsole(): void {
+    CONSOLE_METHODS.forEach((method) => {
+      console[method] = this.#originalConsoleMethods[method]
+    })
+  }
+
+  protected restoreStreams(): void {
+    // Restoring the pre-patch references — the typed write signature differs
+    // slightly from the runtime instance type after `.bind()`, hence the cast
+    // through the stream's own `write` member type.
+    process.stdout.write = this
+      .#originalStdoutWrite as typeof process.stdout.write
+    process.stderr.write = this
+      .#originalStderrWrite as typeof process.stderr.write
+  }
+
+  // ── Hooks (subclasses override) ─────────────────────────────────────────
+  /**
+   * Default: forward a single ConsoleLog via the `consoleLogs` scope.
+   * Args is passed as an array (matching the original console.* call shape:
+   * `console.log('a', 'b')` → `args = ['a', 'b']`) so subclasses can preserve
+   * the multi-argument structure for the UI.
+   *
+   * Subclasses that need to maintain local capture state (for the rerun/
+   * replay flow) should override to also push the entry into their own
+   * array — see service's onLine override.
+   */
+  protected onLine(type: LogLevel, args: string[], source: LogSource): void {
+    const entry = createConsoleLogEntry(type, args, source)
+    this.sendUpstream('consoleLogs', [entry])
+  }
+
+  /**
+   * Default delegates to {@link isInternalStreamLine} from `./console.js`.
+   * Subclasses can override to add framework-specific filters.
+   */
+  protected isInternalStreamLine(line: string): boolean {
+    return isInternalStreamLine(line)
+  }
+
+  /** Hook: WS opened. Subclasses override to send a handshake, etc. */
+  protected onWsOpen(): void {}
+
+  /** Hook: WS errored before opening (likely no backend listening). */
+  protected onWsError(_err: unknown): void {}
+
+  /** Hook: WS closed (after open, or as a result of cleanup). */
+  protected onWsClose(): void {}
+
+  /**
+   * Hook: WS message received from the backend. Currently used by selenium's
+   * `awaitClientConnected` to know when a dashboard tab has subscribed.
+   */
+  protected onWsMessage(_msg: unknown): void {}
+}
+
+function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
diff --git a/packages/core/src/stack.ts b/packages/core/src/stack.ts
new file mode 100644
index 00000000..b414d27c
--- /dev/null
+++ b/packages/core/src/stack.ts
@@ -0,0 +1,58 @@
+import { parse as parseStackTrace } from 'stacktrace-parser'
+
+/**
+ * Return true if a stack frame belongs to user code (not dependencies, Node
+ * internals, build output, or a generic `index.js` entry point).
+ */
+export function isUserCodeFrame(frame: {
+  file?: string | null
+}): frame is { file: string } {
+  const { file } = frame
+  return !!(
+    file &&
+    !file.includes('/node_modules/') &&
+    !file.includes('<anonymous>') &&
+    !file.includes('node:internal') &&
+    !file.includes('/dist/') &&
+    !file.endsWith('/index.js')
+  )
+}
+
+/**
+ * Strip the `file://` protocol, any trailing `:line:col` suffix, and
+ * percent-decode the result. Node's ESM stack traces use file:// URLs which
+ * URL-encode spaces — without decoding, `fs.readFile` hits ENOENT on any
+ * path that contains one. Falls back to the literal path if decoding fails.
+ */
+export function normalizeFilePath(filePath: string): string {
+  const stripped = filePath.replace(/^file:\/\//, '').split(':')[0]
+  try {
+    return decodeURIComponent(stripped)
+  } catch {
+    return stripped
+  }
+}
+
+/**
+ * Capture `{ filePath, callSource }` for the first user-code frame on the
+ * current stack. `callSource` is `<file>:<line>` for the UI's source-location
+ * displays; returns `'unknown:0'` (and `undefined` filePath) when no user
+ * frame can be found.
+ */
+export function getCallSourceFromStack(): {
+  filePath: string | undefined
+  callSource: string
+} {
+  const stack = new Error().stack
+  if (!stack) {
+    return { filePath: undefined, callSource: 'unknown:0' }
+  }
+
+  const frame = parseStackTrace(stack).find(isUserCodeFrame)
+  if (!frame?.file) {
+    return { filePath: undefined, callSource: 'unknown:0' }
+  }
+
+  const filePath = normalizeFilePath(frame.file)
+  return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` }
+}
diff --git a/packages/core/src/suite-helpers.ts b/packages/core/src/suite-helpers.ts
new file mode 100644
index 00000000..a69569ba
--- /dev/null
+++ b/packages/core/src/suite-helpers.ts
@@ -0,0 +1,164 @@
+import type { SuiteStats, TestStats, TestStatus } from '@wdio/devtools-shared'
+import { TEST_STATE } from '@wdio/devtools-shared'
+
+/**
+ * Pure factories + state computations shared by the per-adapter SuiteManager
+ * and TestManager classes. Pattern A from CLAUDE.md §the-four-patterns —
+ * stateless helpers each adapter calls; no base class because storage
+ * strategy differs (selenium uses a single root suite + optional Cucumber
+ * sub-suites; nightwatch uses a Map keyed by test file).
+ */
+
+export interface SuiteStatsInit {
+  uid: string
+  title: string
+  file: string
+  cid?: string
+  callSource?: string
+  featureFile?: string
+  parent?: string
+  start?: Date
+  state?: TestStatus
+}
+
+export interface TestStatsInit {
+  uid: string
+  title: string
+  file: string
+  parent: string
+  cid?: string
+  fullTitle?: string
+  callSource?: string
+  state?: TestStatus
+  start?: Date
+}
+
+/**
+ * Build a SuiteStats with the standard defaults (empty children arrays,
+ * RUNNING state, fresh start time). Adapters override fields as needed
+ * before/after the call.
+ */
+export function createSuiteStats(init: SuiteStatsInit): SuiteStats {
+  return {
+    uid: init.uid,
+    cid: init.cid ?? '0-0',
+    title: init.title,
+    fullTitle: init.title,
+    file: init.file,
+    type: 'suite',
+    start: init.start ?? new Date(),
+    state: init.state ?? TEST_STATE.RUNNING,
+    end: null,
+    tests: [],
+    suites: [],
+    hooks: [],
+    _duration: 0,
+    callSource: init.callSource,
+    featureFile: init.featureFile,
+    parent: init.parent
+  }
+}
+
+/** Build a TestStats with the standard defaults. */
+export function createTestStats(init: TestStatsInit): TestStats {
+  return {
+    uid: init.uid,
+    cid: init.cid ?? '0-0',
+    title: init.title,
+    fullTitle: init.fullTitle ?? init.title,
+    parent: init.parent,
+    state: init.state ?? TEST_STATE.RUNNING,
+    start: init.start ?? new Date(),
+    end: null,
+    type: 'test',
+    file: init.file,
+    retries: 0,
+    _duration: 0,
+    hooks: [],
+    callSource: init.callSource
+  }
+}
+
+/**
+ * "Permissive" finalize: any failed child → FAILED, otherwise PASSED.
+ * Matches selenium's policy — RUNNING tests don't fail the suite.
+ */
+export function computeSuiteFinalStatePermissive(
+  suite: SuiteStats
+): TestStatus {
+  const failedDirect = suite.tests.some(
+    (t) => typeof t !== 'string' && t.state === TEST_STATE.FAILED
+  )
+  const failedNested = (suite.suites ?? []).some(
+    (s) => s.state === TEST_STATE.FAILED
+  )
+  return failedDirect || failedNested ? TEST_STATE.FAILED : TEST_STATE.PASSED
+}
+
+/**
+ * "Strict" finalize: any failed → FAILED; all PASSED/SKIPPED → PASSED;
+ * empty suite → PASSED; orphaned RUNNING tests → FAILED. Matches nightwatch's
+ * policy — incomplete runs are surfaced as failures.
+ */
+export function computeSuiteFinalStateStrict(suite: SuiteStats): TestStatus {
+  const tests = suite.tests as TestStats[]
+  const suites = suite.suites ?? []
+  const hasFailures =
+    tests.some((t) => t.state === TEST_STATE.FAILED) ||
+    suites.some((s) => s.state === TEST_STATE.FAILED)
+  if (hasFailures) {
+    return TEST_STATE.FAILED
+  }
+  const allPassed =
+    tests.every(
+      (t) => t.state === TEST_STATE.PASSED || t.state === TEST_STATE.SKIPPED
+    ) &&
+    suites.every(
+      (s) => s.state === TEST_STATE.PASSED || s.state === TEST_STATE.SKIPPED
+    )
+  const hasSkipped = tests.some((t) => t.state === TEST_STATE.SKIPPED)
+  const hasItems = tests.length > 0 || suites.length > 0
+  if (!hasItems || allPassed) {
+    return TEST_STATE.PASSED
+  }
+  if (hasSkipped) {
+    return TEST_STATE.PASSED
+  }
+  return TEST_STATE.FAILED
+}
+
+/**
+ * In-progress state computation: if any child is FAILED → FAILED;
+ * else if any RUNNING / unfinished → RUNNING; else → PASSED. Used to keep
+ * a parent suite's state fresh while children are still executing
+ * (Cucumber feature suite updates as each scenario completes).
+ */
+export function computeSuiteRunningState(suite: SuiteStats): TestStatus {
+  const tests = suite.tests as TestStats[]
+  const suites = suite.suites ?? []
+  const hasFailures =
+    tests.some((t) => t.state === TEST_STATE.FAILED) ||
+    suites.some((s) => s.state === TEST_STATE.FAILED)
+  if (hasFailures) {
+    return TEST_STATE.FAILED
+  }
+  const hasRunning =
+    tests.some((t) => t.state === TEST_STATE.RUNNING) ||
+    suites.some((s) => s.state === TEST_STATE.RUNNING || !s.end)
+  return hasRunning ? TEST_STATE.RUNNING : TEST_STATE.PASSED
+}
+
+/**
+ * Stamp `end` + `_duration` on a suite. Pure mutation — kept here so the
+ * arithmetic stays in one place; callers still own the state assignment.
+ */
+export function stampSuiteEnd(suite: SuiteStats, end: Date = new Date()): void {
+  suite.end = end
+  suite._duration = end.getTime() - (suite.start?.getTime() || end.getTime())
+}
+
+/** Stamp `end` + `_duration` on a test. */
+export function stampTestEnd(test: TestStats, end: Date = new Date()): void {
+  test.end = end
+  test._duration = end.getTime() - (test.start?.getTime() ?? end.getTime())
+}
diff --git a/packages/core/src/test-discovery.ts b/packages/core/src/test-discovery.ts
new file mode 100644
index 00000000..ac6d0492
--- /dev/null
+++ b/packages/core/src/test-discovery.ts
@@ -0,0 +1,87 @@
+import fs from 'node:fs'
+
+/**
+ * One test/suite definition discovered in a source file by line-regex scan.
+ * Adapter-agnostic shape — both selenium and nightwatch consume this.
+ */
+export interface TestDefinition {
+  kind: 'suite' | 'test'
+  title: string
+  line: number
+}
+
+/**
+ * Regex-scan a JS/TS test file for `describe('...')` / `it('...')` style
+ * definitions (and Mocha/Jest aliases — `suite`, `context`, `test`,
+ * `specify`). Adapters call this from line-based helpers that resolve a
+ * call-source `file:line` for the dashboard's TestLens / Actions tab.
+ *
+ * Set `includeNightwatchObjectStyle` to also match the object-export shape
+ * Nightwatch's `--yes` scaffolder generates:
+ *
+ *     'My test name': () => { ... }
+ *     'My test name': async function () { ... }
+ *
+ * Returns definitions in source order. Unreadable / unparseable files yield
+ * an empty array — the dashboard already degrades to `file:0` in that case.
+ */
+export function findTestDefinitions(
+  filePath: string,
+  opts: { includeNightwatchObjectStyle?: boolean } = {}
+): TestDefinition[] {
+  if (!fs.existsSync(filePath)) {
+    return []
+  }
+  let source: string
+  try {
+    source = fs.readFileSync(filePath, 'utf-8')
+  } catch {
+    return []
+  }
+
+  const out: TestDefinition[] = []
+  const lines = source.split('\n')
+
+  const suiteRe = /\b(?:describe|suite|context)\s*\(\s*['"`]([^'"`]+)['"`]/
+  const testRe = /\b(?:it|test|specify)\s*\(\s*['"`]([^'"`]+)['"`]/
+  // Nightwatch object-export: `'Title': () => { ... }` or `: function () {`
+  const objRe =
+    /^\s*['"`]([^'"`]+)['"`]\s*:\s*(?:async\s+)?(?:\([^)]*\)\s*=>|function\s*\()/
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const lineNum = i + 1
+
+    const suiteMatch = line.match(suiteRe)
+    if (suiteMatch) {
+      out.push({ kind: 'suite', title: suiteMatch[1], line: lineNum })
+      continue
+    }
+    const testMatch = line.match(testRe)
+    if (testMatch) {
+      out.push({ kind: 'test', title: testMatch[1], line: lineNum })
+      continue
+    }
+    if (opts.includeNightwatchObjectStyle) {
+      const objMatch = line.match(objRe)
+      if (objMatch) {
+        out.push({ kind: 'test', title: objMatch[1], line: lineNum })
+      }
+    }
+  }
+  return out
+}
+
+/**
+ * Convenience: find the line number where a specific test/suite is defined.
+ * Returns null if the file or title isn't found. Used by adapter call-source
+ * resolution from hooks where the user's stack frame isn't reachable.
+ */
+export function findTestLineInFile(
+  filePath: string,
+  title: string,
+  kind: 'test' | 'suite' = 'test'
+): number | null {
+  const defs = findTestDefinitions(filePath)
+  return defs.find((d) => d.kind === kind && d.title === title)?.line ?? null
+}
diff --git a/packages/core/src/test-reporter.ts b/packages/core/src/test-reporter.ts
new file mode 100644
index 00000000..b9863bd3
--- /dev/null
+++ b/packages/core/src/test-reporter.ts
@@ -0,0 +1,87 @@
+import type { SuiteStats, TestStats } from '@wdio/devtools-shared'
+import { resetSignatureCounters } from './uid.js'
+
+/**
+ * Shape of the payload sent upstream — one record per suite, keyed by UID,
+ * so the UI can merge it into its existing suite map without scanning.
+ */
+export type ReporterUpstreamPayload = Record<string, SuiteStats>[]
+export type ReporterUpstream = (data: ReporterUpstreamPayload) => void
+
+/**
+ * Foundation class for adapter TestReporters. Owns the cross-framework
+ * scaffolding (suite collection, upstream batching). Framework-specific
+ * lifecycle hooks (spec-file scanning, UID generation, skipped-test
+ * synthesis) stay in subclasses.
+ *
+ * Service uses the WDIO reporter base instead — this class is for adapters
+ * that own their own reporter lifecycle (nightwatch, selenium).
+ */
+export abstract class TestReporterBase {
+  #report: ReporterUpstream
+  protected allSuites: SuiteStats[] = []
+
+  constructor(report: ReporterUpstream) {
+    this.#report = report
+    resetSignatureCounters()
+  }
+
+  /** Swap the upstream sink, e.g. after a WS reconnect. */
+  updateUpstream(report: ReporterUpstream): void {
+    this.#report = report
+  }
+
+  /** Manually trigger a flush of current state to the UI. */
+  updateSuites(): void {
+    this.sendUpstream()
+  }
+
+  /**
+   * Reset collected state. Subclasses with extra state (test-name cache,
+   * current-suite ref) override and call `super.clearExecutionData()` first.
+   */
+  clearExecutionData(): void {
+    this.allSuites = []
+    resetSignatureCounters()
+  }
+
+  /** Default: find by `uid`, replace in place. */
+  onTestEnd(test: TestStats): void {
+    for (const suite of this.allSuites) {
+      const idx = suite.tests.findIndex(
+        (t) => typeof t !== 'string' && t.uid === test.uid
+      )
+      if (idx !== -1) {
+        suite.tests[idx] = test
+        break
+      }
+    }
+    this.sendUpstream()
+  }
+
+  /** Default: just flush. Subclasses with skipped-test synthesis override. */
+  onSuiteEnd(_suite: SuiteStats): void {
+    this.sendUpstream()
+  }
+
+  get report(): SuiteStats[] {
+    return this.allSuites
+  }
+
+  /**
+   * Flush current suite state to the upstream callback. Empty-payload guard
+   * matches the existing adapter behavior — UI shouldn't receive an empty
+   * array.
+   */
+  protected sendUpstream(): void {
+    const payload: ReporterUpstreamPayload = []
+    for (const suite of this.allSuites) {
+      if (suite.uid) {
+        payload.push({ [suite.uid]: suite })
+      }
+    }
+    if (payload.length > 0) {
+      this.#report(payload)
+    }
+  }
+}
diff --git a/packages/core/src/uid.ts b/packages/core/src/uid.ts
new file mode 100644
index 00000000..40ee085f
--- /dev/null
+++ b/packages/core/src/uid.ts
@@ -0,0 +1,41 @@
+// Stable UID generation for tests and suites. The hash function is a tiny
+// djb2-style char-code accumulator that produces compact base36 strings.
+// "Stable" means: the same input produces the same output across runs.
+
+/**
+ * Hash arbitrary string parts into a stable, deterministic UID. Calling this
+ * multiple times with the same inputs always returns the same value — no
+ * counter, no hidden state. Use for entities that must map to the same UID
+ * across retries (Cucumber scenarios, feature steps, etc.).
+ */
+export function deterministicUid(...parts: string[]): string {
+  const hash = parts
+    .join('::')
+    .split('')
+    .reduce((acc, char) => ((acc << 5) - acc + char.charCodeAt(0)) | 0, 0)
+  return `stable-${Math.abs(hash).toString(36)}`
+}
+
+// Counter for disambiguating repeated (file, name) signatures within a single
+// test run. Cleared by resetSignatureCounters() between runs.
+const signatureCounters = new Map<string, number>()
+
+/**
+ * Generate a UID from a (file, name) pair, disambiguating repeated calls with
+ * the same inputs via an in-run counter. Use for test/suite identity where
+ * the same file::name combo may legitimately appear multiple times in one run
+ * (e.g. parameterised tests). For entities that must produce the same UID on
+ * every retry (Cucumber scenarios), use {@link deterministicUid} instead.
+ */
+export function generateStableUid(file: string, name: string): string {
+  const signature = `${file}::${name}`
+  const count = signatureCounters.get(signature) ?? 0
+  signatureCounters.set(signature, count + 1)
+  const input = count > 0 ? `${signature}::${count}` : signature
+  return deterministicUid(input)
+}
+
+/** Reset the signature counter map. Call at the start of each test run. */
+export function resetSignatureCounters(): void {
+  signatureCounters.clear()
+}
diff --git a/packages/core/src/video-encoder.ts b/packages/core/src/video-encoder.ts
new file mode 100644
index 00000000..54e59ac2
--- /dev/null
+++ b/packages/core/src/video-encoder.ts
@@ -0,0 +1,152 @@
+// VP8/WebM encoder for screencast frames. Loads fluent-ffmpeg lazily via
+// createRequire so the dep stays optional — adapters that ship screencast
+// support are expected to list fluent-ffmpeg in their own dependencies.
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import os from 'node:os'
+import { createRequire } from 'node:module'
+
+import type { ScreencastFrame, ScreencastOptions } from '@wdio/devtools-shared'
+
+const require = createRequire(import.meta.url)
+
+/**
+ * Encode an array of CDP screencast frames into a .webm file using ffmpeg
+ * (via fluent-ffmpeg) and the VP8 codec (libvpx).
+ *
+ * Strategy:
+ *   1. Write each frame as a JPEG (or PNG) file in a temp directory.
+ *   2. Write an ffconcat manifest that assigns each frame its exact display
+ *      duration based on the inter-frame timestamp delta. Variable-frame-rate
+ *      output reflects real timing even across long command pauses.
+ *   3. Run ffmpeg with the concat demuxer → libvpx (VP8) → .webm output.
+ *      Force CFR at 10fps — VFR WebMs don't write Cues reliably, so the
+ *      dashboard `<video>` can't read duration/seek without it.
+ *   4. Clean up the temp directory regardless of success or failure.
+ *
+ * @throws If no frames are provided, fluent-ffmpeg is not installed, or
+ *         the ffmpeg binary is not found on PATH.
+ */
+// fluent-ffmpeg is loaded lazily and its types aren't worth pinning — we
+// only call a tiny chained builder API on it. `unknown` at the boundary
+// + a single cast in the runner keeps the surface honest.
+type FfmpegBuilder = {
+  input(path: string): FfmpegBuilder
+  inputOptions(opts: string[]): FfmpegBuilder
+  videoCodec(name: string): FfmpegBuilder
+  outputOptions(opts: string[]): FfmpegBuilder
+  output(path: string): FfmpegBuilder
+  on(event: 'end', cb: () => void): FfmpegBuilder
+  on(event: 'error', cb: (err: Error) => void): FfmpegBuilder
+  run(): void
+}
+type FfmpegFactory = () => FfmpegBuilder
+
+function loadFfmpeg(): FfmpegFactory {
+  try {
+    return require('fluent-ffmpeg') as FfmpegFactory
+  } catch {
+    throw new Error(
+      'VideoEncoder: fluent-ffmpeg is required for screencast encoding. ' +
+        'Install it with: npm install fluent-ffmpeg'
+    )
+  }
+}
+
+async function writeFramesAndManifest(
+  frames: ScreencastFrame[],
+  tmpDir: string,
+  ext: string
+): Promise<string> {
+  const manifestLines: string[] = ['ffconcat version 1.0']
+  for (let i = 0; i < frames.length; i++) {
+    const frameName = `frame-${String(i).padStart(6, '0')}.${ext}`
+    const framePath = path.join(tmpDir, frameName)
+    await fs.writeFile(framePath, Buffer.from(frames[i].data, 'base64'))
+    const nextTs = frames[i + 1]?.timestamp ?? frames[i].timestamp + 100
+    const durationSecs = Math.max((nextTs - frames[i].timestamp) / 1000, 0.01)
+    manifestLines.push(`file '${framePath}'`)
+    manifestLines.push(`duration ${durationSecs.toFixed(6)}`)
+  }
+  // The last frame needs to appear twice in the manifest — ffconcat ignores
+  // the final `duration` directive without a trailing `file` line.
+  const lastFramePath = path.join(
+    tmpDir,
+    `frame-${String(frames.length - 1).padStart(6, '0')}.${ext}`
+  )
+  manifestLines.push(`file '${lastFramePath}'`)
+  const manifestPath = path.join(tmpDir, 'manifest.txt')
+  await fs.writeFile(manifestPath, manifestLines.join('\n'))
+  return manifestPath
+}
+
+function classifyFfmpegError(err: Error): Error {
+  const msg = err.message || ''
+  if (
+    msg.includes('Cannot find ffmpeg') ||
+    msg.includes('ENOENT') ||
+    msg.includes('spawn') ||
+    msg.includes('not found')
+  ) {
+    return new Error(
+      'VideoEncoder: ffmpeg binary not found on PATH. ' +
+        'Install ffmpeg: https://ffmpeg.org/download.html'
+    )
+  }
+  return new Error(`VideoEncoder: ffmpeg error — ${msg}`)
+}
+
+function runFfmpeg(
+  ffmpeg: FfmpegFactory,
+  manifestPath: string,
+  outputPath: string
+): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    ffmpeg()
+      .input(manifestPath)
+      .inputOptions(['-f', 'concat', '-safe', '0'])
+      .videoCodec('libvpx')
+      .outputOptions([
+        '-b:v',
+        '1M',
+        '-pix_fmt',
+        'yuv420p',
+        '-vsync',
+        'cfr',
+        '-r',
+        '10',
+        '-auto-alt-ref',
+        '0',
+        '-disposition:v',
+        'default'
+      ])
+      .output(outputPath)
+      .on('end', () => resolve())
+      .on('error', (err: Error) => reject(classifyFfmpegError(err)))
+      .run()
+  })
+}
+
+export async function encodeToVideo(
+  frames: ScreencastFrame[],
+  outputPath: string,
+  options: Pick<ScreencastOptions, 'captureFormat'> = {}
+): Promise<void> {
+  if (frames.length === 0) {
+    throw new Error('VideoEncoder: no frames to encode')
+  }
+  const ffmpeg = loadFfmpeg()
+  const ext = options.captureFormat === 'png' ? 'png' : 'jpg'
+  const tmpDir = await fs.mkdtemp(
+    path.join(os.tmpdir(), 'devtools-screencast-')
+  )
+  try {
+    const manifestPath = await writeFramesAndManifest(frames, tmpDir, ext)
+    await runFfmpeg(ffmpeg, manifestPath, outputPath)
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+      /* tmp cleanup is best-effort */
+    })
+  }
+}
diff --git a/packages/core/tests/assert-patcher.test.ts b/packages/core/tests/assert-patcher.test.ts
new file mode 100644
index 00000000..feaf746b
--- /dev/null
+++ b/packages/core/tests/assert-patcher.test.ts
@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import assert from 'node:assert'
+import {
+  ASSERT_PATCHED_SYMBOL,
+  TRACKED_ASSERT_METHODS,
+  patchNodeAssert,
+  safeSerializeAssertArg,
+  type CapturedAssert
+} from '../src/assert-patcher.js'
+
+// Snapshot real methods once so each test starts from a fresh assert.
+const ASSERT_MUT = assert as unknown as Record<string | symbol, unknown>
+const originals: Record<string, unknown> = {}
+for (const m of TRACKED_ASSERT_METHODS) {
+  originals[m] = ASSERT_MUT[m]
+}
+
+beforeEach(() => {
+  delete ASSERT_MUT[ASSERT_PATCHED_SYMBOL]
+  for (const m of TRACKED_ASSERT_METHODS) {
+    ASSERT_MUT[m] = originals[m]
+  }
+})
+
+describe('safeSerializeAssertArg', () => {
+  // One sweep covers every branch — function, RegExp, plain object,
+  // cyclic-object fallback, passthrough primitives.
+  it('coerces each input class to a JSON-safe value', () => {
+    const cyclic: Record<string, unknown> = {}
+    cyclic.self = cyclic
+    expect(safeSerializeAssertArg(/foo/gi)).toBe('/foo/gi')
+    expect(safeSerializeAssertArg(() => 0)).toBe('[Function]')
+    expect(safeSerializeAssertArg({ a: 1 })).toEqual({ a: 1 })
+    expect(safeSerializeAssertArg(cyclic)).toBe('[object Object]')
+    expect(safeSerializeAssertArg(42)).toBe(42)
+    expect(safeSerializeAssertArg(null)).toBe(null)
+  })
+})
+
+describe('patchNodeAssert', () => {
+  it('emits a passed capture on sync success', () => {
+    const captured: CapturedAssert[] = []
+    expect(patchNodeAssert((c) => captured.push(c))).toBe(true)
+    assert.equal(1, 1)
+    expect(captured[0]).toMatchObject({
+      command: 'assert.equal',
+      args: [1, 1],
+      result: 'passed',
+      error: undefined
+    })
+  })
+
+  it('emits a failed capture (with the thrown error) and re-throws on sync failure', () => {
+    const captured: CapturedAssert[] = []
+    patchNodeAssert((c) => captured.push(c))
+    expect(() => assert.equal(1, 2)).toThrow()
+    expect(captured[0].result).toBeUndefined()
+    expect(captured[0].error).toBeInstanceOf(Error)
+  })
+
+  it('handles Promise-returning asserts (rejects/doesNotReject)', async () => {
+    const captured: CapturedAssert[] = []
+    patchNodeAssert((c) => captured.push(c))
+    await assert.doesNotReject(async () => 1)
+    await expect(assert.rejects(async () => 1)).rejects.toThrow()
+    const results = captured.map((c) => c.result)
+    expect(results).toEqual(['passed', undefined]) // first resolved, second rejected
+  })
+
+  it('is idempotent — second patch is a no-op and sets the guard symbol', () => {
+    const a: CapturedAssert[] = []
+    patchNodeAssert((c) => a.push(c))
+    const wrapped = ASSERT_MUT['equal']
+    const b: CapturedAssert[] = []
+    patchNodeAssert((c) => b.push(c))
+    expect(ASSERT_MUT['equal']).toBe(wrapped) // same wrapper, NOT re-bound
+    expect(ASSERT_MUT[ASSERT_PATCHED_SYMBOL]).toBe(true)
+    assert.equal(1, 1)
+    expect(a).toHaveLength(1)
+    expect(b).toHaveLength(0) // second callback never bound
+  })
+
+  it('serializes RegExp args before invoking onCommand', () => {
+    const captured: CapturedAssert[] = []
+    patchNodeAssert((c) => captured.push(c))
+    assert.match('hello', /hello/)
+    expect(captured[0].args).toEqual(['hello', '/hello/'])
+  })
+})
diff --git a/packages/core/tests/bidi.test.ts b/packages/core/tests/bidi.test.ts
new file mode 100644
index 00000000..eb7ab66d
--- /dev/null
+++ b/packages/core/tests/bidi.test.ts
@@ -0,0 +1,288 @@
+import { describe, it, expect } from 'vitest'
+import {
+  arrayHeadersToObject,
+  attachBidiHandlers,
+  loadSeleniumSubmodule,
+  handleBidiConsoleEntry,
+  handleBidiJsException,
+  handleBidiRequestSent,
+  handleBidiResponseCompleted,
+  type BidiHandlerSinks
+} from '../src/bidi.js'
+import type { NetworkRequest } from '@wdio/devtools-shared'
+
+function makeSinks() {
+  const consoleLogs: any[] = []
+  const networkRequests: any[] = []
+  const replacements: Array<{ id: string; entry: NetworkRequest }> = []
+  const sinks: BidiHandlerSinks = {
+    pushConsoleLog: (e) => consoleLogs.push(e),
+    pushNetworkRequest: (e) => networkRequests.push(e),
+    replaceNetworkRequest: (id, entry) => replacements.push({ id, entry })
+  }
+  return { sinks, consoleLogs, networkRequests, replacements }
+}
+
+const silentLog = () => {}
+
+describe('arrayHeadersToObject', () => {
+  it('flattens BiDi { name, value: string } headers to a lowercased dict', () => {
+    expect(
+      arrayHeadersToObject([
+        { name: 'Content-Type', value: 'application/json' },
+        { name: 'X-Foo', value: 'bar' }
+      ])
+    ).toEqual({ 'content-type': 'application/json', 'x-foo': 'bar' })
+  })
+
+  it('unwraps { value: { value: string } } shape (BiDi sometimes wraps)', () => {
+    expect(
+      arrayHeadersToObject([
+        { name: 'Accept', value: { type: 'string', value: 'text/html' } }
+      ])
+    ).toEqual({ accept: 'text/html' })
+  })
+
+  it('falls back to JSON.stringify when value is neither string nor wrapped string', () => {
+    expect(
+      arrayHeadersToObject([
+        { name: 'X-Weird', value: { type: 'object' } as unknown as string }
+      ])
+    ).toEqual({ 'x-weird': '{"type":"object"}' })
+  })
+
+  it('returns undefined for non-array input + skips entries with empty names', () => {
+    expect(arrayHeadersToObject(undefined)).toBeUndefined()
+    expect(arrayHeadersToObject('not-an-array')).toBeUndefined()
+    expect(
+      arrayHeadersToObject([
+        { name: '', value: 'skipped' },
+        { name: 'kept', value: 'v' }
+      ])
+    ).toEqual({ kept: 'v' })
+  })
+})
+
+describe('loadSeleniumSubmodule', () => {
+  it('returns null for a submodule that does not exist anywhere', () => {
+    expect(
+      loadSeleniumSubmodule('definitely/not/a/real/submodule-xyz123')
+    ).toBeNull()
+  })
+})
+
+describe('handleBidiConsoleEntry', () => {
+  it('pushes a console-log entry with the chrome-mapped level and text', () => {
+    const { sinks, consoleLogs } = makeSinks()
+    handleBidiConsoleEntry(
+      { level: 'WARNING', text: 'careful', timestamp: 1700 },
+      sinks,
+      silentLog
+    )
+    expect(consoleLogs).toHaveLength(1)
+    expect(consoleLogs[0].timestamp).toBe(1700)
+    expect(consoleLogs[0].type).toBe('warn')
+    expect(consoleLogs[0].args).toEqual(['careful'])
+    expect(consoleLogs[0].source).toBe('browser')
+  })
+
+  it('falls back to the entry.type when level is absent', () => {
+    const { sinks, consoleLogs } = makeSinks()
+    handleBidiConsoleEntry(
+      { type: 'SEVERE', message: 'oops' },
+      sinks,
+      silentLog
+    )
+    expect(consoleLogs[0].type).toBe('error')
+    expect(consoleLogs[0].args).toEqual(['oops'])
+  })
+
+  it('defaults to "info" and current time when nothing is set', () => {
+    const { sinks, consoleLogs } = makeSinks()
+    handleBidiConsoleEntry({}, sinks, silentLog)
+    expect(consoleLogs[0].type).toBe('info')
+    expect(consoleLogs[0].timestamp).toBeGreaterThan(0)
+    expect(consoleLogs[0].args).toEqual([''])
+  })
+
+  it('reports a warning when the sink throws', () => {
+    const sinks: BidiHandlerSinks = {
+      pushConsoleLog: () => {
+        throw new Error('sink broke')
+      },
+      pushNetworkRequest: () => {},
+      replaceNetworkRequest: () => {}
+    }
+    const logs: Array<[string, string]> = []
+    handleBidiConsoleEntry({ text: 'x' }, sinks, (lvl, msg) =>
+      logs.push([lvl, msg])
+    )
+    expect(logs.some(([lvl, msg]) => lvl === 'warn' && /threw/.test(msg))).toBe(
+      true
+    )
+  })
+})
+
+describe('handleBidiJsException', () => {
+  it('logs a JS-error notice and pushes a "browser console" error entry', () => {
+    const { sinks, consoleLogs } = makeSinks()
+    const logs: Array<[string, string]> = []
+    handleBidiJsException(
+      { text: 'TypeError: x is undefined' },
+      sinks,
+      (lvl, msg) => logs.push([lvl, msg])
+    )
+    expect(consoleLogs).toHaveLength(1)
+    expect(consoleLogs[0].type).toBe('error')
+    expect(consoleLogs[0].args[0]).toBe('TypeError: x is undefined')
+    expect(logs.some(([, msg]) => msg.includes('JS error in page'))).toBe(true)
+  })
+
+  it('truncates long messages with an ellipsis in the warn line', () => {
+    const long = 'x'.repeat(500)
+    const logs: Array<[string, string]> = []
+    handleBidiJsException({ text: long }, makeSinks().sinks, (lvl, msg) =>
+      logs.push([lvl, msg])
+    )
+    const warning = logs.find(([, msg]) => msg.includes('JS error'))![1]
+    expect(warning).toContain('…')
+    expect(warning.length).toBeLessThan(500)
+  })
+
+  it('stringifies the raw value when neither text nor message is present', () => {
+    const { sinks, consoleLogs } = makeSinks()
+    handleBidiJsException('plain string', sinks, silentLog)
+    expect(consoleLogs[0].args[0]).toBe('plain string')
+  })
+})
+
+describe('handleBidiRequestSent', () => {
+  it('records a pending request and pushes to the sink', () => {
+    const { sinks, networkRequests } = makeSinks()
+    const pending = new Map<string, NetworkRequest>()
+    handleBidiRequestSent(
+      {
+        request: {
+          request: 'req-1',
+          url: 'https://api.example.com/users',
+          method: 'GET',
+          headers: [{ name: 'Accept', value: 'application/json' }]
+        },
+        timestamp: 1234
+      },
+      pending,
+      sinks,
+      silentLog
+    )
+    expect(networkRequests).toHaveLength(1)
+    expect(networkRequests[0].url).toBe('https://api.example.com/users')
+    expect(networkRequests[0].method).toBe('GET')
+    expect(networkRequests[0].requestHeaders).toEqual({
+      accept: 'application/json'
+    })
+    expect(pending.has('req-1')).toBe(true)
+  })
+
+  it('skips emission when no requestId is present', () => {
+    const { sinks, networkRequests } = makeSinks()
+    const pending = new Map<string, NetworkRequest>()
+    handleBidiRequestSent({}, pending, sinks, silentLog)
+    expect(networkRequests).toHaveLength(0)
+    expect(pending.size).toBe(0)
+  })
+
+  it('defaults method to GET when not supplied', () => {
+    const { sinks, networkRequests } = makeSinks()
+    handleBidiRequestSent(
+      { request: { request: 'r', url: 'https://x.test/' } },
+      new Map(),
+      sinks,
+      silentLog
+    )
+    expect(networkRequests[0].method).toBe('GET')
+  })
+})
+
+describe('handleBidiResponseCompleted', () => {
+  it('replaces the matching pending entry with status + headers + size', () => {
+    const { sinks, networkRequests, replacements } = makeSinks()
+    const pending = new Map<string, NetworkRequest>()
+    handleBidiRequestSent(
+      {
+        request: {
+          request: 'req-2',
+          url: 'https://api.example.com/x',
+          method: 'POST'
+        },
+        timestamp: 100
+      },
+      pending,
+      sinks,
+      silentLog
+    )
+    handleBidiResponseCompleted(
+      {
+        request: { request: 'req-2' },
+        timestamp: 350,
+        response: {
+          status: 201,
+          statusText: 'Created',
+          headers: [{ name: 'Content-Type', value: 'application/json' }],
+          mimeType: 'application/json',
+          bytesReceived: 1024
+        }
+      },
+      pending,
+      sinks,
+      silentLog
+    )
+    expect(replacements).toHaveLength(1)
+    expect(replacements[0].id).toBe('req-2')
+    expect(replacements[0].entry.status).toBe(201)
+    expect(replacements[0].entry.statusText).toBe('Created')
+    expect(replacements[0].entry.size).toBe(1024)
+    // pending entry is consumed
+    expect(pending.has('req-2')).toBe(false)
+    // pushNetworkRequest fired during requestSent, replaceNetworkRequest on completion
+    expect(networkRequests).toHaveLength(1)
+  })
+
+  it('is a no-op when the requestId is not in the pending map', () => {
+    const { sinks, replacements } = makeSinks()
+    handleBidiResponseCompleted(
+      { request: { request: 'unknown' }, response: {} },
+      new Map(),
+      sinks,
+      silentLog
+    )
+    expect(replacements).toHaveLength(0)
+  })
+})
+
+describe('attachBidiHandlers — graceful degradation', () => {
+  // Two real-world failure modes the function must handle without crashing:
+  //   (a) submodules unresolvable → "not available" notice, returns false
+  //   (b) submodules load but driver is fake / pre-BiDi → attach attempt
+  //       throws inside the factory, caught + logged as "attach failed",
+  //       returns false
+  // selenium-webdriver IS installed in this workspace, so we exercise (b).
+  it('returns false and never throws when the driver is not BiDi-capable', async () => {
+    const sinks: BidiHandlerSinks = {
+      pushConsoleLog: () => {},
+      pushNetworkRequest: () => {},
+      replaceNetworkRequest: () => {}
+    }
+    const logs: Array<[string, string]> = []
+    const ok = await attachBidiHandlers({}, sinks, (lvl, msg) =>
+      logs.push([lvl, msg])
+    )
+    expect(ok).toBe(false)
+    // Either the submodule was missing OR the inspector attach threw —
+    // both produce a notice via the onLog hook.
+    const noticed = logs.some(
+      ([, msg]) =>
+        msg.includes('not available') || msg.includes('attach failed')
+    )
+    expect(noticed).toBe(true)
+  })
+})
diff --git a/packages/core/tests/console-helpers.test.ts b/packages/core/tests/console-helpers.test.ts
new file mode 100644
index 00000000..de3abd6d
--- /dev/null
+++ b/packages/core/tests/console-helpers.test.ts
@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest'
+import {
+  chromeLogLevelToLogLevel,
+  mapChromeBrowserLogs
+} from '../src/console.js'
+
+describe('chromeLogLevelToLogLevel', () => {
+  it('maps Chrome severities (case-insensitively) and falls back to "log"', () => {
+    expect(chromeLogLevelToLogLevel('SEVERE')).toBe('error')
+    expect(chromeLogLevelToLogLevel('warning')).toBe('warn') // case-insensitive
+    expect(chromeLogLevelToLogLevel('INFO')).toBe('info')
+    expect(chromeLogLevelToLogLevel('DEBUG')).toBe('debug')
+    expect(chromeLogLevelToLogLevel('')).toBe('log')
+    expect(chromeLogLevelToLogLevel('GIBBERISH')).toBe('log')
+  })
+
+  it('accepts {name, value} objects (selenium-webdriver Level shape)', () => {
+    expect(chromeLogLevelToLogLevel({ name: 'SEVERE', value: 1000 })).toBe(
+      'error'
+    )
+    expect(chromeLogLevelToLogLevel({ name: undefined })).toBe('log')
+  })
+})
+
+describe('mapChromeBrowserLogs', () => {
+  // One comprehensive test: source-tagging, severity normalization,
+  // timestamp passthrough, message → args wrap.
+  it('produces ConsoleLog entries tagged source="browser" with normalized levels', () => {
+    const out = mapChromeBrowserLogs([
+      { level: 'SEVERE', message: 'oh no', timestamp: 100 },
+      {
+        level: { name: 'WARNING' } as unknown as string,
+        message: 'fyi',
+        timestamp: 200
+      }
+    ])
+    expect(out).toEqual([
+      { source: 'browser', type: 'error', args: ['oh no'], timestamp: 100 },
+      { source: 'browser', type: 'warn', args: ['fyi'], timestamp: 200 }
+    ])
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(mapChromeBrowserLogs([])).toEqual([])
+  })
+})
diff --git a/packages/core/tests/error.test.ts b/packages/core/tests/error.test.ts
new file mode 100644
index 00000000..8101dc88
--- /dev/null
+++ b/packages/core/tests/error.test.ts
@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest'
+import { toError, serializeError, errorMessage } from '../src/error.js'
+
+describe('toError', () => {
+  it('returns the input unchanged when it is already an Error', () => {
+    const err = new Error('boom')
+    expect(toError(err)).toBe(err)
+  })
+
+  it('preserves Error subclass instances', () => {
+    const err = new TypeError('bad type')
+    expect(toError(err)).toBe(err)
+    expect(toError(err) instanceof TypeError).toBe(true)
+  })
+
+  it('wraps a plain object with a .message field into an Error preserving message + name', () => {
+    const out = toError({
+      message: 'nightwatch failed',
+      name: 'AssertionError'
+    })
+    expect(out).toBeInstanceOf(Error)
+    expect(out.message).toBe('nightwatch failed')
+    expect(out.name).toBe('AssertionError')
+  })
+
+  it('falls back to the default Error name when an object has no .name', () => {
+    const out = toError({ message: 'oops' })
+    expect(out.name).toBe('Error')
+  })
+
+  it('stringifies a thrown string', () => {
+    expect(toError('something broke').message).toBe('something broke')
+  })
+
+  it('stringifies thrown numbers/null/undefined safely', () => {
+    expect(toError(42).message).toBe('42')
+    expect(toError(null).message).toBe('null')
+    expect(toError(undefined).message).toBe('undefined')
+  })
+
+  it('ignores a non-string .name field on an object with .message', () => {
+    const out = toError({ message: 'm', name: 123 as unknown as string })
+    expect(out.name).toBe('Error')
+  })
+})
+
+describe('errorMessage', () => {
+  it('reads .message from an Error', () => {
+    expect(errorMessage(new Error('boom'))).toBe('boom')
+  })
+
+  it('reads .message from Error subclasses', () => {
+    expect(errorMessage(new TypeError('bad type'))).toBe('bad type')
+  })
+
+  it('returns a thrown string unchanged', () => {
+    expect(errorMessage('something broke')).toBe('something broke')
+  })
+
+  it('reads .message from a plain object with one', () => {
+    expect(errorMessage({ message: 'nightwatch failed' })).toBe(
+      'nightwatch failed'
+    )
+  })
+
+  it('returns "unknown error" for null/undefined', () => {
+    expect(errorMessage(null)).toBe('unknown error')
+    expect(errorMessage(undefined)).toBe('unknown error')
+  })
+
+  it('stringifies primitives that are neither Error nor string', () => {
+    expect(errorMessage(42)).toBe('42')
+    expect(errorMessage(true)).toBe('true')
+  })
+
+  it('falls back to String() for plain objects without .message', () => {
+    expect(errorMessage({ foo: 'bar' })).toBe('[object Object]')
+  })
+})
+
+describe('serializeError', () => {
+  it('returns undefined for undefined input', () => {
+    expect(serializeError(undefined)).toBeUndefined()
+  })
+
+  it('produces a JSON-safe shape with name/message/stack', () => {
+    const err = new Error('boom')
+    const out = serializeError(err)
+    expect(out).toEqual({
+      name: 'Error',
+      message: 'boom',
+      stack: err.stack
+    })
+  })
+
+  it('preserves the subclass name', () => {
+    const err = new TypeError('bad type')
+    expect(serializeError(err)?.name).toBe('TypeError')
+  })
+})
diff --git a/packages/core/tests/finalize-screencast.test.ts b/packages/core/tests/finalize-screencast.test.ts
new file mode 100644
index 00000000..d0fb2f39
--- /dev/null
+++ b/packages/core/tests/finalize-screencast.test.ts
@@ -0,0 +1,106 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { finalizeScreencast } from '../src/finalize-screencast.js'
+import { ScreencastRecorderBase } from '../src/screencast.js'
+
+// Mock the ffmpeg-bound encoder so tests don't shell out.
+vi.mock('../src/video-encoder.js', () => ({
+  encodeToVideo: vi.fn().mockResolvedValue(undefined)
+}))
+
+class StubRecorder extends ScreencastRecorderBase<{ name: string }> {
+  stopped = false
+  shouldStopThrow = false
+
+  protected override async takeScreenshot() {
+    return null
+  }
+
+  override async stop() {
+    if (this.shouldStopThrow) {
+      throw new Error('stop blew up')
+    }
+    this.stopped = true
+  }
+
+  setFrames(data: string[]) {
+    this.buffer = data.map((d, i) => ({ data: d, timestamp: i * 100 }))
+  }
+}
+
+let r: StubRecorder
+let tmpDir: string
+let sent: Array<{ scope: string; data: unknown }>
+let logs: Array<{ level: string; message: string }>
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  r = new StubRecorder()
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'finalize-screencast-'))
+  sent = []
+  logs = []
+})
+
+const baseOpts = () => ({
+  recorder: r,
+  sessionId: 'sess-abc',
+  filenamePrefix: 'test-video',
+  outputDir: tmpDir,
+  sendUpstream: (scope: string, data: unknown) => sent.push({ scope, data }),
+  onLog: (level: 'info' | 'warn', message: string) =>
+    logs.push({ level, message })
+})
+
+describe('finalizeScreencast', () => {
+  it('stops, encodes, broadcasts a screencast payload with the composed filename', async () => {
+    r.setFrames(['f1', 'f2', 'f3'])
+    await finalizeScreencast({ ...baseOpts(), filenamePrefix: 'my-prefix' })
+    expect(r.stopped).toBe(true)
+    expect(sent).toHaveLength(1)
+    const payload = sent[0].data as Record<string, unknown>
+    expect(payload.sessionId).toBe('sess-abc')
+    expect(payload.frameCount).toBe(3)
+    expect(payload.videoFile).toBe('my-prefix-sess-abc.webm')
+    expect(payload.videoPath).toContain('my-prefix-sess-abc.webm')
+  })
+
+  it('returns early when frames < minFrames (ghost-session guard)', async () => {
+    r.setFrames(['f1', 'f2'])
+    await finalizeScreencast({ ...baseOpts(), minFrames: 5 })
+    expect(sent).toHaveLength(0)
+  })
+
+  it('falls back to os.tmpdir when outputDir is not writable', async () => {
+    r.setFrames(['f1'])
+    await finalizeScreencast({
+      ...baseOpts(),
+      outputDir: '/nonexistent/path/that/does/not/exist'
+    })
+    const payload = sent[0].data as Record<string, string>
+    expect(payload.videoPath.startsWith(os.tmpdir())).toBe(true)
+  })
+
+  it('swallows recorder.stop() errors with a warn log, never broadcasts', async () => {
+    r.shouldStopThrow = true
+    r.setFrames(['f1'])
+    await expect(finalizeScreencast(baseOpts())).resolves.toBeUndefined()
+    expect(sent).toHaveLength(0)
+    expect(
+      logs.find((l) => l.level === 'warn' && l.message.includes('stop failed'))
+    ).toBeDefined()
+  })
+
+  it('swallows encoder rejections with a warn log, returns cleanly', async () => {
+    const { encodeToVideo } = await import('../src/video-encoder.js')
+    vi.mocked(encodeToVideo).mockRejectedValueOnce(new Error('ffmpeg gone'))
+    r.setFrames(['f1', 'f2'])
+    await expect(finalizeScreencast(baseOpts())).resolves.toBeUndefined()
+    expect(
+      logs.find(
+        (l) => l.level === 'warn' && l.message.includes('encode failed')
+      )
+    ).toBeDefined()
+  })
+})
diff --git a/packages/core/tests/output-dir.test.ts b/packages/core/tests/output-dir.test.ts
new file mode 100644
index 00000000..12d80315
--- /dev/null
+++ b/packages/core/tests/output-dir.test.ts
@@ -0,0 +1,91 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { resolveAdapterOutputDir } from '../src/output-dir.js'
+
+describe('resolveAdapterOutputDir', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'output-dir-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('returns userConfiguredDir verbatim when set, even if non-existent', () => {
+    expect(
+      resolveAdapterOutputDir({ userConfiguredDir: '/whatever/path' })
+    ).toBe('/whatever/path')
+  })
+
+  it('prefers testFilePath dir over configPath dir over fallback', () => {
+    const testFile = path.join(tmpDir, 'specs', 'login.test.ts')
+    fs.mkdirSync(path.dirname(testFile), { recursive: true })
+    fs.writeFileSync(testFile, '')
+    const configPath = path.join(tmpDir, 'config', 'nightwatch.conf.cjs')
+    fs.mkdirSync(path.dirname(configPath), { recursive: true })
+    fs.writeFileSync(configPath, '')
+
+    expect(
+      resolveAdapterOutputDir({
+        testFilePath: testFile,
+        configPath,
+        fallbackDir: tmpDir
+      })
+    ).toBe(path.dirname(testFile))
+  })
+
+  it('falls back to configPath dir when testFilePath is missing', () => {
+    const configPath = path.join(tmpDir, 'wdio.conf.ts')
+    fs.writeFileSync(configPath, '')
+    expect(resolveAdapterOutputDir({ configPath, fallbackDir: tmpDir })).toBe(
+      tmpDir
+    )
+  })
+
+  it('skips node_modules dirs and falls through to the next candidate', () => {
+    const nodeModulesDir = path.join(tmpDir, 'node_modules', 'pkg', 'specs')
+    fs.mkdirSync(nodeModulesDir, { recursive: true })
+    const testFile = path.join(nodeModulesDir, 'a.test.ts')
+    fs.writeFileSync(testFile, '')
+    const configPath = path.join(tmpDir, 'wdio.conf.ts')
+    fs.writeFileSync(configPath, '')
+
+    expect(
+      resolveAdapterOutputDir({
+        testFilePath: testFile,
+        configPath
+      })
+    ).toBe(tmpDir)
+  })
+
+  it('falls back to process.cwd() when no inputs are given', () => {
+    expect(resolveAdapterOutputDir()).toBe(process.cwd())
+  })
+
+  it('falls back to fallbackDir when given and none of the candidates are writable', () => {
+    expect(
+      resolveAdapterOutputDir({
+        testFilePath: '/definitely/missing/a.test.ts',
+        fallbackDir: tmpDir
+      })
+    ).toBe(tmpDir)
+  })
+
+  it('userConfiguredDir bypasses node_modules skip (explicit opt-in)', () => {
+    const nm = '/some/node_modules/pkg/dir'
+    expect(resolveAdapterOutputDir({ userConfiguredDir: nm })).toBe(nm)
+  })
+
+  it('returns fallback (cwd) when all candidate dirs are missing', () => {
+    expect(
+      resolveAdapterOutputDir({
+        testFilePath: '/missing/x.test.ts',
+        configPath: '/missing/wdio.conf.ts'
+      })
+    ).toBe(process.cwd())
+  })
+})
diff --git a/packages/core/tests/performance-capture.test.ts b/packages/core/tests/performance-capture.test.ts
new file mode 100644
index 00000000..599a2605
--- /dev/null
+++ b/packages/core/tests/performance-capture.test.ts
@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest'
+import {
+  applyPerformanceData,
+  type CapturedPerformancePayload
+} from '../src/performance-capture.js'
+import type { CommandLog } from '@wdio/devtools-shared'
+
+const freshCommand = (): CommandLog => ({
+  command: 'url',
+  args: ['https://example.com'],
+  result: undefined,
+  timestamp: 1000
+})
+
+describe('applyPerformanceData', () => {
+  it('returns false and mutates nothing when payload is missing or has no navigation', () => {
+    const cmd = freshCommand()
+    expect(applyPerformanceData(cmd, undefined)).toBe(false)
+    expect(applyPerformanceData(cmd, { resources: [] })).toBe(false)
+    expect(cmd.performance).toBeUndefined()
+  })
+
+  it('applies all fields (performance/cookies/documentInfo + synthesized result) when navigation is present', () => {
+    const cmd = freshCommand()
+    const payload: CapturedPerformancePayload = {
+      navigation: {
+        url: 'https://payload.com',
+        timing: { loadTime: 1234 } as unknown as never
+      },
+      resources: [
+        {
+          url: 'a.js',
+          duration: 1,
+          size: 1,
+          type: 'script',
+          startTime: 0,
+          responseEnd: 1
+        }
+      ],
+      cookies: 'session=x',
+      documentInfo: {
+        url: 'https://payload.com',
+        title: 'T',
+        headers: { userAgent: '', language: '', platform: '' },
+        documentInfo: { readyState: 'complete', referrer: '', characterSet: '' }
+      }
+    }
+    expect(applyPerformanceData(cmd, payload, 'https://from-arg.com')).toBe(
+      true
+    )
+    expect(cmd.performance?.navigation?.timing?.loadTime).toBe(1234)
+    expect(cmd.cookies).toBe('session=x')
+    expect(cmd.documentInfo?.title).toBe('T')
+    // result.url comes from the navigatedUrl argument, NOT the payload URL
+    expect((cmd.result as Record<string, unknown>).url).toBe(
+      'https://from-arg.com'
+    )
+    expect((cmd.result as Record<string, unknown>).resourceCount).toBe(1)
+  })
+})
diff --git a/packages/core/tests/retry-tracker.test.ts b/packages/core/tests/retry-tracker.test.ts
new file mode 100644
index 00000000..bd0aaaf9
--- /dev/null
+++ b/packages/core/tests/retry-tracker.test.ts
@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest'
+import { RetryTracker } from '../src/retry-tracker.js'
+
+describe('RetryTracker.signature', () => {
+  it('produces a stable JSON shape for identical inputs', () => {
+    expect(RetryTracker.signature('click', [{ id: 1 }], 'a.ts:5')).toBe(
+      RetryTracker.signature('click', [{ id: 1 }], 'a.ts:5')
+    )
+  })
+
+  it('changes when the command differs', () => {
+    const a = RetryTracker.signature('click', [], 'a.ts:5')
+    const b = RetryTracker.signature('doubleClick', [], 'a.ts:5')
+    expect(a).not.toBe(b)
+  })
+
+  it('changes when the args differ', () => {
+    const a = RetryTracker.signature('click', [{ x: 1 }], 'a.ts:5')
+    const b = RetryTracker.signature('click', [{ x: 2 }], 'a.ts:5')
+    expect(a).not.toBe(b)
+  })
+
+  it('changes when the callSource differs', () => {
+    const a = RetryTracker.signature('click', [], 'a.ts:5')
+    const b = RetryTracker.signature('click', [], 'a.ts:6')
+    expect(a).not.toBe(b)
+  })
+
+  it('treats missing callSource the same regardless of how it was passed', () => {
+    expect(RetryTracker.signature('click', [], undefined)).toBe(
+      RetryTracker.signature('click', [])
+    )
+  })
+})
+
+describe('RetryTracker.isRetry', () => {
+  it('returns false for a fresh tracker (no last capture)', () => {
+    const t = new RetryTracker()
+    expect(t.isRetry(RetryTracker.signature('click', []))).toBe(false)
+  })
+
+  it('returns false when only the signature was staged but no id was recorded', () => {
+    const t = new RetryTracker()
+    const sig = RetryTracker.signature('click', [])
+    t.setLastSig(sig)
+    // No lastId yet → cannot replace, not a retry.
+    expect(t.isRetry(sig)).toBe(false)
+  })
+
+  it('returns true when sig matches AND an id was recorded', () => {
+    const t = new RetryTracker()
+    const sig = RetryTracker.signature('click', [])
+    t.recordCapture(sig, 42)
+    expect(t.isRetry(sig)).toBe(true)
+    expect(t.lastId).toBe(42)
+  })
+
+  it('returns false when the incoming sig differs from the last capture', () => {
+    const t = new RetryTracker()
+    t.recordCapture(RetryTracker.signature('click', []), 1)
+    expect(t.isRetry(RetryTracker.signature('doubleClick', []))).toBe(false)
+  })
+})
+
+describe('RetryTracker.reset', () => {
+  it('clears both the signature and the id', () => {
+    const t = new RetryTracker()
+    const sig = RetryTracker.signature('click', [])
+    t.recordCapture(sig, 1)
+    t.reset()
+    expect(t.isRetry(sig)).toBe(false)
+    expect(t.lastId).toBeNull()
+  })
+})
+
+describe('staged-then-resolved flow (nightwatch pattern)', () => {
+  it('stages sig before async capture; id arrives later; subsequent same-sig command is a retry', () => {
+    const t = new RetryTracker()
+    const sig = RetryTracker.signature('click', [{ x: 1 }], 'a.ts:5')
+
+    // Pre-capture: stage the sig before kicking off the async capture.
+    t.setLastSig(sig)
+    t.setLastId(null)
+    expect(t.isRetry(sig)).toBe(false) // id not set yet — can't replace
+
+    // After capture completes:
+    t.setLastId(7)
+    expect(t.isRetry(sig)).toBe(true) // now a retry of the same call IS detected
+    expect(t.lastId).toBe(7)
+  })
+})
diff --git a/packages/core/tests/screencast.test.ts b/packages/core/tests/screencast.test.ts
new file mode 100644
index 00000000..dc57bdb6
--- /dev/null
+++ b/packages/core/tests/screencast.test.ts
@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { ScreencastRecorderBase } from '../src/screencast.js'
+
+class TestRecorder extends ScreencastRecorderBase<{ name: string }> {
+  shotsTaken = 0
+  shouldFailFirst = false
+  shouldThrowFirst = false
+
+  protected override async takeScreenshot(): Promise<string | null> {
+    this.shotsTaken++
+    if (this.shouldThrowFirst && this.shotsTaken === 1) {
+      throw new Error('first-shot threw')
+    }
+    if (this.shouldFailFirst && this.shotsTaken === 1) {
+      return null
+    }
+    return `frame-${this.shotsTaken}`
+  }
+
+  get bufferLength(): number {
+    return this.buffer.length
+  }
+}
+
+beforeEach(() => {
+  vi.useRealTimers()
+})
+
+describe('ScreencastRecorderBase — polling path', () => {
+  it('start() enters recording state; second start() is a no-op', async () => {
+    const r = new TestRecorder({ pollIntervalMs: 50 })
+    await r.start({ name: 'a' })
+    expect(r.isRecording).toBe(true)
+    const shots = r.shotsTaken
+    await r.start({ name: 'b' }) // ignored — already recording
+    expect(r.shotsTaken).toBe(shots)
+    await r.stop()
+    expect(r.isRecording).toBe(false)
+  })
+
+  it('does not record when the first screenshot returns null or throws', async () => {
+    const nullR = new TestRecorder({ pollIntervalMs: 50 })
+    nullR.shouldFailFirst = true
+    await nullR.start({ name: 'driver' })
+    expect(nullR.isRecording).toBe(false)
+
+    const throwR = new TestRecorder({ pollIntervalMs: 50 })
+    throwR.shouldThrowFirst = true
+    await throwR.start({ name: 'driver' })
+    expect(throwR.isRecording).toBe(false)
+  })
+
+  it('captures multiple frames at the configured interval', async () => {
+    vi.useFakeTimers()
+    const r = new TestRecorder({ pollIntervalMs: 50 })
+    await r.start({ name: 'driver' })
+    expect(r.bufferLength).toBe(1) // initial shot
+    await vi.advanceTimersByTimeAsync(150) // 3 more ticks
+    expect(r.bufferLength).toBeGreaterThanOrEqual(4)
+    await r.stop()
+    vi.useRealTimers()
+  })
+
+  it('stops polling silently when a mid-stream screenshot throws (session-death case)', async () => {
+    vi.useFakeTimers()
+    let n = 0
+    class FailMid extends TestRecorder {
+      protected override async takeScreenshot() {
+        n++
+        if (n > 2) {
+          throw new Error('session gone')
+        }
+        return `f-${n}`
+      }
+    }
+    const r = new FailMid({ pollIntervalMs: 50 })
+    await r.start({ name: 'driver' })
+    await vi.advanceTimersByTimeAsync(50) // shot 2 ok
+    await vi.advanceTimersByTimeAsync(50) // shot 3 throws → loop stops
+    const after = r.bufferLength
+    await vi.advanceTimersByTimeAsync(200) // no more frames
+    expect(r.bufferLength).toBe(after)
+    vi.useRealTimers()
+  })
+})
+
+describe('ScreencastRecorderBase — frames / setStartMarker / duration', () => {
+  it('setStartMarker trims preceding frames from the public getter', async () => {
+    class CdpFlavor extends ScreencastRecorderBase<{ name: string }> {
+      protected override async takeScreenshot() {
+        return null
+      }
+      protected override async tryStartCdp() {
+        return true
+      }
+      push(d: string, t: number) {
+        this.pushCdpFrame(d, t)
+      }
+    }
+    const r = new CdpFlavor()
+    await r.start({ name: 'driver' })
+    r.push('a', 1)
+    r.push('b', 2)
+    r.setStartMarker() // anchor at end of buffer
+    r.push('after', 3)
+    expect(r.frames.length).toBe(1)
+    expect(r.frames[0].data).toBe('after')
+    await r.stop()
+  })
+
+  it('duration is the ms span between first and last frame (CDP-timestamps in seconds → ms)', async () => {
+    class CdpOnly extends ScreencastRecorderBase<{ name: string }> {
+      protected override async takeScreenshot() {
+        return null
+      }
+      protected override async tryStartCdp() {
+        return true
+      }
+      push(d: string, t: number) {
+        this.pushCdpFrame(d, t)
+      }
+    }
+    const r = new CdpOnly()
+    await r.start({ name: 'driver' })
+    r.push('a', 1) // 1000ms
+    r.push('b', 3) // 3000ms
+    expect(r.duration).toBe(2000)
+    await r.stop()
+  })
+})
+
+describe('ScreencastRecorderBase — CDP override path', () => {
+  it('tryStartCdp returning true skips the polling path entirely', async () => {
+    class CdpRecorder extends ScreencastRecorderBase<{ name: string }> {
+      pollAttempted = false
+      protected override async takeScreenshot() {
+        this.pollAttempted = true
+        return null
+      }
+      protected override async tryStartCdp() {
+        return true
+      }
+    }
+    const r = new CdpRecorder()
+    await r.start({ name: 'driver' })
+    expect(r.pollAttempted).toBe(false)
+    expect(r.isRecording).toBe(true)
+    await r.stop()
+  })
+})
diff --git a/packages/core/tests/script-loader.test.ts b/packages/core/tests/script-loader.test.ts
new file mode 100644
index 00000000..5897ee09
--- /dev/null
+++ b/packages/core/tests/script-loader.test.ts
@@ -0,0 +1,67 @@
+import { describe, it, expect, vi } from 'vitest'
+import { loadInjectableScript, pollUntilReady } from '../src/script-loader.js'
+
+/**
+ * `@wdio/devtools-script` is a workspace sibling that gets built before
+ * adapter runtime use. In CI the test job may run before that package is
+ * built, in which case `loadInjectableScript()` throws (resolve or
+ * readFile fails). Probe by attempting the full operation — anything
+ * cheaper risks drifting from what the runtime actually does, and that
+ * drift is exactly what caused the historical CI/local divergence.
+ */
+const scriptPackageAvailable = await loadInjectableScript()
+  .then(() => true)
+  .catch(() => false)
+
+describe('loadInjectableScript', () => {
+  it.skipIf(!scriptPackageAvailable)(
+    'wraps the @wdio/devtools-script payload in an async IIFE',
+    async () => {
+      const wrapped = await loadInjectableScript()
+      expect(wrapped.startsWith('(async function() { ')).toBe(true)
+      expect(wrapped.endsWith(' })()')).toBe(true)
+      // Body must be non-empty — the actual script.js is shipped by the
+      // workspace build; this fails fast if the file is missing or empty.
+      expect(wrapped.length).toBeGreaterThan('(async function() {  })()'.length)
+    }
+  )
+})
+
+describe('pollUntilReady', () => {
+  it('returns true as soon as the check succeeds', async () => {
+    let calls = 0
+    const ok = await pollUntilReady(
+      async () => {
+        calls++
+        return calls === 2
+      },
+      { attempts: 5, intervalMs: 1 }
+    )
+    expect(ok).toBe(true)
+    expect(calls).toBe(2)
+  })
+
+  it('returns false when no attempt succeeds', async () => {
+    const check = vi.fn(async () => false)
+    const ok = await pollUntilReady(check, { attempts: 3, intervalMs: 1 })
+    expect(ok).toBe(false)
+    expect(check).toHaveBeenCalledTimes(3)
+  })
+
+  it('uses default 5 attempts × 200ms when no opts given', async () => {
+    const check = vi.fn(async () => false)
+    const start = process.hrtime.bigint()
+    const ok = await pollUntilReady(check)
+    const elapsedMs = Number(process.hrtime.bigint() - start) / 1_000_000
+    expect(ok).toBe(false)
+    expect(check).toHaveBeenCalledTimes(5)
+    // 5 × 200ms = 1000ms, allow generous slack for CI
+    expect(elapsedMs).toBeGreaterThanOrEqual(950)
+  })
+
+  it('does not call the check before the first interval', async () => {
+    const check = vi.fn(async () => true)
+    await pollUntilReady(check, { attempts: 1, intervalMs: 50 })
+    expect(check).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/packages/core/tests/session-capturer-base.test.ts b/packages/core/tests/session-capturer-base.test.ts
new file mode 100644
index 00000000..d89455ae
--- /dev/null
+++ b/packages/core/tests/session-capturer-base.test.ts
@@ -0,0 +1,154 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { SessionCapturerBase } from '../src/session-capturer.js'
+
+/**
+ * Test subclass that exposes the protected `processTracePayload` and
+ * captures `sendUpstream` calls in-memory. Constructed with no WS opts so
+ * the base skips the network connection entirely — keeps tests offline.
+ */
+class TestSessionCapturer extends SessionCapturerBase {
+  upstream: Array<{ scope: string; data: unknown }> = []
+
+  constructor() {
+    super({})
+  }
+
+  override sendUpstream(event: string, data: unknown): void {
+    this.upstream.push({ scope: event, data })
+  }
+
+  process(
+    payload: {
+      mutations?: unknown
+      traceLogs?: unknown
+      consoleLogs?: unknown
+      networkRequests?: unknown
+      metadata?: unknown
+    },
+    opts?: { skipConsoleLogs?: boolean; skipNetworkRequests?: boolean }
+  ) {
+    // @ts-expect-error — accessing protected method from same-module subclass
+    return this.processTracePayload(payload, opts)
+  }
+}
+
+let cap: TestSessionCapturer
+beforeEach(() => {
+  cap = new TestSessionCapturer()
+})
+
+describe('processTracePayload — metadata merge', () => {
+  it('merges metadata across calls (later writes win on overlap; prior keys preserved)', () => {
+    cap.process({ metadata: { url: 'first', sessionId: 'a' } })
+    cap.process({ metadata: { url: 'second' } })
+    expect(cap.metadata?.url).toBe('second')
+    expect(cap.metadata?.sessionId).toBe('a')
+    // Each metadata call produces one broadcast
+    expect(cap.upstream.filter((u) => u.scope === 'metadata')).toHaveLength(2)
+  })
+})
+
+describe('processTracePayload — BiDi gating (the duplicate-suppression contract)', () => {
+  it('skips consoleLogs/networkRequests entirely when their skip flag is set', () => {
+    cap.process(
+      {
+        consoleLogs: [{ type: 'info', args: ['x'], timestamp: 1 }],
+        networkRequests: [
+          {
+            id: 'r1',
+            url: 'https://x',
+            method: 'GET',
+            timestamp: 1,
+            startTime: 0,
+            type: 'fetch'
+          }
+        ]
+      },
+      { skipConsoleLogs: true, skipNetworkRequests: true }
+    )
+    expect(cap.consoleLogs).toEqual([])
+    expect(cap.networkRequests).toEqual([])
+    expect(
+      cap.upstream.find(
+        (u) => u.scope === 'consoleLogs' || u.scope === 'networkRequests'
+      )
+    ).toBeUndefined()
+  })
+
+  it('still pushes consoleLogs/networkRequests when no gate is set, tagging logs source="browser"', () => {
+    cap.process({
+      consoleLogs: [{ type: 'info', args: ['x'], timestamp: 1, source: 'test' }]
+    })
+    expect(cap.consoleLogs[0].source).toBe('browser') // overridden
+    expect(cap.upstream.find((u) => u.scope === 'consoleLogs')).toBeDefined()
+  })
+})
+
+describe('processTracePayload — mutations + traceLogs', () => {
+  it('ignores non-array values defensively', () => {
+    cap.process({
+      mutations: 'not-an-array' as unknown,
+      traceLogs: { obj: 'not-an-array' } as unknown
+    })
+    expect(cap.mutations).toEqual([])
+    expect(cap.traceLogs).toEqual([])
+  })
+
+  it('pushes valid arrays and broadcasts on their respective scopes', () => {
+    cap.process({
+      mutations: [
+        { type: 'childList', addedNodes: [], removedNodes: [], timestamp: 1 }
+      ],
+      traceLogs: ['first', 'second']
+    })
+    expect(cap.mutations).toHaveLength(1)
+    expect(cap.traceLogs).toEqual(['first', 'second'])
+    expect(cap.upstream.find((u) => u.scope === 'mutations')).toBeDefined()
+    expect(cap.upstream.find((u) => u.scope === 'logs')).toBeDefined()
+  })
+})
+
+describe('captureSource', () => {
+  it('caches by file path — second read is a no-op', async () => {
+    const filePath = new URL(import.meta.url).pathname
+    await cap.captureSource(filePath)
+    await cap.captureSource(filePath)
+    expect(cap.upstream.filter((u) => u.scope === 'sources')).toHaveLength(1)
+    expect(cap.sources.size).toBe(1)
+  })
+
+  it('calls onSourceReadError when the file is missing (no broadcast)', async () => {
+    const errors: Array<{ file: string; err: unknown }> = []
+    class Hooked extends TestSessionCapturer {
+      protected override onSourceReadError(file: string, err: unknown) {
+        errors.push({ file, err })
+      }
+    }
+    const c = new Hooked()
+    await c.captureSource('/totally/missing/path.ts')
+    expect(errors).toHaveLength(1)
+    expect(c.sources.size).toBe(0)
+    expect(c.upstream.find((u) => u.scope === 'sources')).toBeUndefined()
+  })
+})
+
+describe('sendCommand', () => {
+  it('strips internal _id from the broadcast payload', () => {
+    cap.sendCommand({ _id: 42, command: 'click', args: [], timestamp: 1 })
+    const sent = cap.upstream.find((u) => u.scope === 'commands')!
+    const payload = (sent.data as Array<Record<string, unknown>>)[0]
+    expect(payload._id).toBeUndefined()
+    expect(payload.command).toBe('click')
+  })
+
+  it('auto-allocates _id when omitted', () => {
+    const id = cap.sendCommand({ command: 'click', args: [], timestamp: 1 })
+    expect(id).toBe(0)
+  })
+
+  it('de-dupes — second call with same _id is a no-op', () => {
+    cap.sendCommand({ _id: 7, command: 'a', args: [], timestamp: 1 })
+    cap.sendCommand({ _id: 7, command: 'b', args: [], timestamp: 2 })
+    expect(cap.upstream.filter((u) => u.scope === 'commands')).toHaveLength(1)
+  })
+})
diff --git a/packages/core/tests/suite-helpers.test.ts b/packages/core/tests/suite-helpers.test.ts
new file mode 100644
index 00000000..b1114b56
--- /dev/null
+++ b/packages/core/tests/suite-helpers.test.ts
@@ -0,0 +1,199 @@
+import { describe, it, expect } from 'vitest'
+import {
+  computeSuiteFinalStatePermissive,
+  computeSuiteFinalStateStrict,
+  computeSuiteRunningState,
+  createSuiteStats,
+  createTestStats,
+  stampSuiteEnd,
+  stampTestEnd
+} from '../src/suite-helpers.js'
+import type { SuiteStats, TestStats } from '@wdio/devtools-shared'
+import { TEST_STATE } from '@wdio/devtools-shared'
+
+function suiteWith(tests: TestStats[], nested: SuiteStats[] = []): SuiteStats {
+  const s = createSuiteStats({ uid: 's', title: 'S', file: '/f' })
+  s.tests = tests
+  s.suites = nested
+  return s
+}
+
+function test(state: TestStats['state']): TestStats {
+  return createTestStats({
+    uid: 't',
+    title: 't',
+    file: '/f',
+    parent: 's',
+    state
+  })
+}
+
+describe('createSuiteStats', () => {
+  it('applies the standard defaults', () => {
+    const s = createSuiteStats({ uid: 'a', title: 'A', file: '/x' })
+    expect(s).toMatchObject({
+      uid: 'a',
+      cid: '0-0',
+      type: 'suite',
+      state: TEST_STATE.RUNNING,
+      end: null,
+      tests: [],
+      suites: [],
+      hooks: []
+    })
+    expect(s.start).toBeInstanceOf(Date)
+  })
+
+  it('honors callSource / featureFile / parent overrides', () => {
+    const s = createSuiteStats({
+      uid: 'a',
+      title: 'A',
+      file: '/x',
+      callSource: '/x:5',
+      featureFile: '/x.feature',
+      parent: 'root'
+    })
+    expect(s.callSource).toBe('/x:5')
+    expect(s.featureFile).toBe('/x.feature')
+    expect(s.parent).toBe('root')
+  })
+})
+
+describe('createTestStats', () => {
+  it('uses title as fullTitle when not overridden', () => {
+    const t = createTestStats({ uid: 't', title: 'T', file: '/x', parent: 'p' })
+    expect(t.fullTitle).toBe('T')
+    expect(t.type).toBe('test')
+    expect(t.retries).toBe(0)
+  })
+
+  it('honors fullTitle override', () => {
+    const t = createTestStats({
+      uid: 't',
+      title: 'short',
+      fullTitle: 'parent suite > short',
+      file: '/x',
+      parent: 'p'
+    })
+    expect(t.fullTitle).toBe('parent suite > short')
+  })
+})
+
+describe('computeSuiteFinalStatePermissive', () => {
+  it('returns FAILED if any direct test failed', () => {
+    expect(
+      computeSuiteFinalStatePermissive(
+        suiteWith([test(TEST_STATE.PASSED), test(TEST_STATE.FAILED)])
+      )
+    ).toBe(TEST_STATE.FAILED)
+  })
+
+  it('returns FAILED if any nested suite failed', () => {
+    const nested = suiteWith([])
+    nested.state = TEST_STATE.FAILED
+    expect(computeSuiteFinalStatePermissive(suiteWith([], [nested]))).toBe(
+      TEST_STATE.FAILED
+    )
+  })
+
+  it('returns PASSED otherwise — even with RUNNING tests', () => {
+    expect(
+      computeSuiteFinalStatePermissive(
+        suiteWith([test(TEST_STATE.PASSED), test(TEST_STATE.RUNNING)])
+      )
+    ).toBe(TEST_STATE.PASSED)
+  })
+})
+
+describe('computeSuiteFinalStateStrict', () => {
+  it('returns FAILED on any failure', () => {
+    expect(
+      computeSuiteFinalStateStrict(
+        suiteWith([test(TEST_STATE.PASSED), test(TEST_STATE.FAILED)])
+      )
+    ).toBe(TEST_STATE.FAILED)
+  })
+
+  it('returns PASSED for empty suite', () => {
+    expect(computeSuiteFinalStateStrict(suiteWith([]))).toBe(TEST_STATE.PASSED)
+  })
+
+  it('returns FAILED for orphaned RUNNING tests (the strictness)', () => {
+    expect(
+      computeSuiteFinalStateStrict(suiteWith([test(TEST_STATE.RUNNING)]))
+    ).toBe(TEST_STATE.FAILED)
+  })
+
+  it('returns PASSED when all passed/skipped', () => {
+    expect(
+      computeSuiteFinalStateStrict(
+        suiteWith([test(TEST_STATE.PASSED), test(TEST_STATE.SKIPPED)])
+      )
+    ).toBe(TEST_STATE.PASSED)
+  })
+})
+
+describe('computeSuiteRunningState', () => {
+  it('FAILED if any failed', () => {
+    expect(computeSuiteRunningState(suiteWith([test(TEST_STATE.FAILED)]))).toBe(
+      TEST_STATE.FAILED
+    )
+  })
+
+  it('RUNNING if any direct test is RUNNING', () => {
+    expect(
+      computeSuiteRunningState(suiteWith([test(TEST_STATE.RUNNING)]))
+    ).toBe(TEST_STATE.RUNNING)
+  })
+
+  it('RUNNING if any nested suite has no end timestamp', () => {
+    const nested = suiteWith([])
+    nested.state = TEST_STATE.PASSED // state lies; end:null is the signal
+    expect(computeSuiteRunningState(suiteWith([], [nested]))).toBe(
+      TEST_STATE.RUNNING
+    )
+  })
+
+  it('PASSED when everything is finished and nobody failed', () => {
+    const passed = test(TEST_STATE.PASSED)
+    const nested = suiteWith([])
+    nested.state = TEST_STATE.PASSED
+    nested.end = new Date()
+    expect(computeSuiteRunningState(suiteWith([passed], [nested]))).toBe(
+      TEST_STATE.PASSED
+    )
+  })
+})
+
+describe('stampSuiteEnd', () => {
+  it('sets end and _duration relative to start', () => {
+    const start = new Date(1000)
+    const s = createSuiteStats({ uid: 'a', title: 'A', file: '/f', start })
+    stampSuiteEnd(s, new Date(2500))
+    expect(s.end?.getTime()).toBe(2500)
+    expect(s._duration).toBe(1500)
+  })
+
+  it('zero duration when end equals start', () => {
+    const start = new Date(1000)
+    const s = createSuiteStats({ uid: 'a', title: 'A', file: '/f', start })
+    stampSuiteEnd(s, new Date(1000))
+    expect(s._duration).toBe(0)
+  })
+})
+
+describe('stampTestEnd', () => {
+  it('sets end and _duration relative to start', () => {
+    const start = new Date(500)
+    const t = createTestStats({
+      uid: 't',
+      title: 'T',
+      file: '/f',
+      parent: 'p',
+      start
+    })
+    stampTestEnd(t, new Date(800))
+    expect(t.end?.getTime()).toBe(800)
+    expect(t._duration).toBe(300)
+  })
+})
diff --git a/packages/core/tests/test-discovery.test.ts b/packages/core/tests/test-discovery.test.ts
new file mode 100644
index 00000000..715a088c
--- /dev/null
+++ b/packages/core/tests/test-discovery.test.ts
@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import {
+  findTestDefinitions,
+  findTestLineInFile
+} from '../src/test-discovery.js'
+
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'test-discovery-'))
+})
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+function write(filename: string, contents: string): string {
+  const p = path.join(tmpDir, filename)
+  fs.writeFileSync(p, contents, 'utf-8')
+  return p
+}
+
+describe('findTestDefinitions', () => {
+  it('finds describe + it + test + specify with line numbers', () => {
+    const p = write(
+      'a.spec.ts',
+      [
+        '',
+        "describe('outer', () => {",
+        "  it('first', () => {})",
+        "  test('second', () => {})",
+        "  specify('third', () => {})",
+        '})'
+      ].join('\n')
+    )
+    expect(findTestDefinitions(p)).toEqual([
+      { kind: 'suite', title: 'outer', line: 2 },
+      { kind: 'test', title: 'first', line: 3 },
+      { kind: 'test', title: 'second', line: 4 },
+      { kind: 'test', title: 'third', line: 5 }
+    ])
+  })
+
+  it('also accepts suite/context aliases for describe', () => {
+    const p = write(
+      'a.spec.ts',
+      ["suite('s', () => {", "  context('c', () => {})", '})'].join('\n')
+    )
+    expect(findTestDefinitions(p).map((d) => d.kind)).toEqual([
+      'suite',
+      'suite'
+    ])
+  })
+
+  it('returns empty for missing or unreadable files', () => {
+    expect(findTestDefinitions('/nope/missing.ts')).toEqual([])
+  })
+
+  it('skips Nightwatch object-style by default', () => {
+    const p = write(
+      'a.spec.ts',
+      ["'my test': () => {},", "'another': async function () {}"].join('\n')
+    )
+    expect(findTestDefinitions(p)).toEqual([])
+  })
+
+  it('includes Nightwatch object-style when opted in', () => {
+    const p = write(
+      'a.spec.ts',
+      ["'my test': () => {},", "'another': async function () {}"].join('\n')
+    )
+    expect(
+      findTestDefinitions(p, { includeNightwatchObjectStyle: true })
+    ).toEqual([
+      { kind: 'test', title: 'my test', line: 1 },
+      { kind: 'test', title: 'another', line: 2 }
+    ])
+  })
+})
+
+describe('findTestLineInFile', () => {
+  it('returns the line for a matching test', () => {
+    const p = write(
+      'a.spec.ts',
+      ["it('first', () => {})", "it('second', () => {})"].join('\n')
+    )
+    expect(findTestLineInFile(p, 'second')).toBe(2)
+  })
+
+  it('returns the line for a matching suite when kind=suite', () => {
+    const p = write(
+      'a.spec.ts',
+      ["it('hidden', () => {})", "describe('the suite', () => {})"].join('\n')
+    )
+    expect(findTestLineInFile(p, 'the suite', 'suite')).toBe(2)
+  })
+
+  it('returns null when title not found', () => {
+    const p = write('a.spec.ts', "it('only', () => {})")
+    expect(findTestLineInFile(p, 'missing')).toBe(null)
+  })
+})
diff --git a/packages/core/tsconfig.json b/packages/core/tsconfig.json
new file mode 100644
index 00000000..a5cb75c5
--- /dev/null
+++ b/packages/core/tsconfig.json
@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*.ts"]
+}
diff --git a/packages/nightwatch-devtools/ARCHITECTURE.md b/packages/nightwatch-devtools/ARCHITECTURE.md
new file mode 100644
index 00000000..94687b7a
--- /dev/null
+++ b/packages/nightwatch-devtools/ARCHITECTURE.md
@@ -0,0 +1,1355 @@
+# Nightwatch DevTools Plugin - Architecture Documentation
+
+## Overview
+
+The Nightwatch DevTools plugin is a **thin adapter layer** (~490 lines) that integrates Nightwatch with the WebdriverIO DevTools ecosystem. It provides real-time visual debugging capabilities for Nightwatch tests with zero test code changes.
+
+## High-Level Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Nightwatch Test Runner                    │
+└───────────────────────┬─────────────────────────────────────┘
+                        │ Lifecycle Hooks
+                        ↓
+┌─────────────────────────────────────────────────────────────┐
+│          NightwatchDevToolsPlugin (Main Orchestrator)        │
+│  ┌────────────┬────────────┬────────────┬─────────────┐     │
+│  │ Session    │ Test       │ Suite      │ Browser     │     │
+│  │ Capturer   │ Reporter   │ Manager    │ Proxy       │     │
+│  └────────────┴────────────┴────────────┴─────────────┘     │
+└───────────────────────┬─────────────────────────────────────┘
+                        │ WebSocket Protocol
+                        ↓
+┌─────────────────────────────────────────────────────────────┐
+│              @wdio/devtools-backend (Reused)                 │
+│              Fastify Server + WebSocket                      │
+└───────────────────────┬─────────────────────────────────────┘
+                        │ HTTP/WS
+                        ↓
+┌─────────────────────────────────────────────────────────────┐
+│              @wdio/devtools-app (Reused)                     │
+│              Lit-based UI Components                         │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Core Components
+
+### 1. NightwatchDevToolsPlugin (Main Orchestrator)
+
+**Location:** `src/index.ts`
+
+**Responsibilities:**
+- Manages plugin lifecycle through Nightwatch hooks
+- Coordinates all sub-components
+- Opens DevTools UI in separate browser window
+- Handles backend server startup/shutdown
+
+**Key Methods:**
+
+| Method | Purpose |
+|--------|---------|
+| `before()` | Start DevTools backend server, open UI browser window |
+| `beforeEach(browser)` | Initialize session, inject scripts, prepare tests |
+| `afterEach(browser)` | Capture trace data, finalize tests |
+| `after()` | Keep process alive until UI browser closes, cleanup |
+
+**Key Features:**
+- Automatic UI browser window management using WebdriverIO's `remote()` API
+- Process lifecycle management (handles Ctrl+C vs natural exit)
+- Unique user data directory per instance to avoid conflicts
+- Coordinates data flow between all components
+
+**Hook Implementation:**
+
+```javascript
+export default function createNightwatchDevTools(options) {
+  const plugin = new NightwatchDevToolsPlugin(options)
+  
+  return {
+    asyncHookTimeout: 3600000, // 1 hour - allows UI review
+    before: async function() { await plugin.before() },
+    beforeEach: async function(browser) { await plugin.beforeEach(browser) },
+    afterEach: async function(browser) { await plugin.afterEach(browser) },
+    after: async function() { await plugin.after() }
+  }
+}
+```
+
+---
+
+### 2. SessionCapturer
+
+**Location:** `src/session.ts`
+
+**Responsibilities:**
+- WebSocket communication with backend
+- Capture and stream test execution data in real-time
+- Inject browser scripts for runtime capture
+- Console log and terminal output interception
+
+**Key Features:**
+
+#### WebSocket Client
+- Connects to backend at `ws://hostname:port/worker`
+- Sends data upstream to backend in real-time
+- Handles connection failures gracefully
+
+#### Script Injection
+- Injects `@wdio/devtools-script` into browser pages
+- Enables browser-side capture (network, console, mutations)
+- Re-injects on page navigation
+
+#### Console Patching
+- Intercepts `console.log/info/warn/error`
+- Captures test framework logs
+- Filters internal framework messages to reduce noise
+
+#### Process Stream Interception
+- Captures stdout/stderr from test execution
+- Detects log levels from text patterns
+- Strips ANSI escape codes for clean display
+
+**Data Captured:**
+
+| Category | Details |
+|----------|---------|
+| **Commands** | Command name, arguments, results, timestamps, call sources |
+| **Console Logs** | Type, arguments, timestamp, source (browser/test/terminal) |
+| **Network Requests** | Via injected script in browser |
+| **DOM Mutations** | Via MutationObserver in browser |
+| **Performance Metrics** | Navigation timing, resource timing |
+| **Source Files** | Test file contents for display |
+
+**Key Methods:**
+
+```typescript
+class SessionCapturer {
+  // Send data to backend
+  sendUpstream(type: string, data: any): void
+  
+  // Inject capture script into browser
+  async injectScript(browser: NightwatchBrowser): Promise<void>
+  
+  // Capture trace data after test
+  async captureTrace(browser: NightwatchBrowser): Promise<void>
+  
+  // Capture source file contents
+  async captureSource(filePath: string): Promise<void>
+  
+  // Wait for WebSocket connection
+  async waitForConnection(timeoutMs: number): Promise<boolean>
+}
+```
+
+---
+
+### 3. TestReporter
+
+**Location:** `src/reporter.ts`
+
+**Responsibilities:**
+- Track test and suite lifecycle
+- Generate stable UIDs for tests/suites
+- Update UI with test status changes
+- Extract test metadata from source files
+
+**Key Features:**
+
+#### Stable UID Generation
+- Hash-based UIDs using file path + full title
+- Consistent across test runs (no random/sequential IDs)
+- Prevents duplicate test entries in UI
+
+```typescript
+function generateStableUid(item: SuiteStats | TestStats): string {
+  const parts = [item.file, item.fullTitle]
+  const signature = parts.join('::')
+  
+  // Hash for stable, short UIDs
+  const hash = signature.split('').reduce((acc, char) => {
+    return ((acc << 5) - acc + char.charCodeAt(0)) | 0
+  }, 0)
+  
+  return `stable-${Math.abs(hash).toString(36)}`
+}
+```
+
+#### Test Metadata Extraction
+- Parses test files to extract test names before execution
+- Pre-populates suite with pending tests
+- Improves UI responsiveness
+
+#### State Management
+- Tracks test states: `pending` → `running` → `passed/failed/skipped`
+- Updates UI in real-time via callback
+- Handles test state transitions
+
+**Key Methods:**
+
+```typescript
+class TestReporter {
+  // Generate stable UID for test/suite
+  generateStableUid(filePath: string, name: string): string
+  
+  // Suite lifecycle
+  onSuiteStart(suiteStats: SuiteStats): void
+  onSuiteEnd(suiteStats: SuiteStats): void
+  
+  // Test lifecycle
+  onTestStart(testStats: TestStats): void
+  onTestEnd(testStats: TestStats): void
+  onTestPass(testStats: TestStats): void
+  onTestFail(testStats: TestStats): void
+  
+  // Query methods
+  getCurrentSuite(): SuiteStats | undefined
+  updateSuites(): void
+}
+```
+
+---
+
+### 4. TestManager
+
+**Location:** `src/helpers/testManager.ts`
+
+**Responsibilities:**
+- Manage test lifecycle and state transitions
+- Detect test boundaries (when tests change)
+- Prevent duplicate test reporting
+- Finalize incomplete tests
+
+**Key Features:**
+
+#### Test Boundary Detection
+Detects when the current test changes by monitoring `browser.currentTest.name`:
+
+```typescript
+detectTestBoundary(currentNightwatchTest: any): string {
+  const currentTestName = currentNightwatchTest?.name || 'unknown'
+  
+  // If test name changed, finalize previous test
+  if (this.lastKnownTestName && currentTestName !== this.lastKnownTestName) {
+    // Finalize previous test with results
+    this.finalizePreviousTest()
+  }
+  
+  this.lastKnownTestName = currentTestName
+  return currentTestName
+}
+```
+
+#### Duplicate Prevention
+- Tracks processed tests per file using `Map<string, Set<string>>`
+- Prevents reporting the same test multiple times
+- Handles parallel test execution
+
+#### State Transitions
+Manages test state flow:
+
+```
+pending → running → passed/failed/skipped
+   ↑                       ↓
+   └───────────────────────┘
+      (reset for next test)
+```
+
+**Key Methods:**
+
+```typescript
+class TestManager {
+  // Update test state and report to UI
+  updateTestState(test: TestStats, state: string, endTime?: Date, duration?: number): void
+  
+  // Find test in suite by title
+  findTestInSuite(suite: SuiteStats, testTitle: string): TestStats | undefined
+  
+  // Mark test as processed (prevent duplicates)
+  markTestAsProcessed(testFile: string, testTitle: string): void
+  isTestProcessed(testFile: string, testTitle: string): boolean
+  
+  // Detect when current test changes
+  detectTestBoundary(currentNightwatchTest: any): string
+  
+  // Start pending test on first command
+  startTestIfPending(currentTestName: string): void
+  
+  // Finalize all incomplete tests in suite
+  finalizeSuiteTests(suite: SuiteStats, testcases: Record<string, any>): void
+}
+```
+
+---
+
+### 5. SuiteManager
+
+**Location:** `src/helpers/suiteManager.ts`
+
+**Responsibilities:**
+- Create and manage test suites
+- Track suite state and completion
+- Pre-populate test entries for display
+
+**Key Features:**
+
+#### Suite Creation
+- Creates suite on first test encounter for a file
+- Generates stable UID for suite
+- Pre-populates with pending test entries
+
+```typescript
+getOrCreateSuite(testFile: string, suiteTitle: string, fullPath: string, testNames: string[]): SuiteStats {
+  if (!this.currentSuiteByFile.has(testFile)) {
+    const suiteStats = {
+      uid: this.testReporter.generateStableUid(fullPath, suiteTitle),
+      title: suiteTitle,
+      file: fullPath,
+      state: 'pending',
+      tests: [], // Pre-populated with test names
+      // ... other fields
+    }
+    
+    // Create pending test entries
+    for (const testName of testNames) {
+      suiteStats.tests.push(createPendingTest(testName))
+    }
+    
+    this.currentSuiteByFile.set(testFile, suiteStats)
+    this.testReporter.onSuiteStart(suiteStats)
+  }
+  
+  return this.currentSuiteByFile.get(testFile)
+}
+```
+
+#### Suite State Tracking
+- States: `pending` → `running` → `passed/failed`
+- State determined by aggregating test results
+
+#### Result Aggregation
+Determines suite result from test results:
+- **Passed**: All tests passed
+- **Failed**: Any test failed
+- **Skipped**: All tests skipped
+
+**Key Methods:**
+
+```typescript
+class SuiteManager {
+  // Get or create suite for test file
+  getOrCreateSuite(testFile: string, suiteTitle: string, fullPath: string, testNames: string[]): SuiteStats
+  
+  // Get existing suite
+  getSuite(testFile: string): SuiteStats | undefined
+  
+  // Update suite state
+  markSuiteAsRunning(suite: SuiteStats): void
+  
+  // Finalize suite with results
+  finalizeSuite(suite: SuiteStats): void
+  
+  // Get all suites
+  getAllSuites(): Map<string, SuiteStats>
+}
+```
+
+---
+
+### 6. BrowserProxy
+
+**Location:** `src/helpers/browserProxy.ts`
+
+**Responsibilities:**
+- Intercept browser commands
+- Track command execution
+- Wrap `browser.url()` for script injection
+- Prevent command duplication
+
+**Key Features:**
+
+#### Method Wrapping
+Dynamically wraps all browser methods:
+
+```typescript
+wrapBrowserCommands(browser: NightwatchBrowser): void {
+  const allMethods = [
+    ...Object.keys(browser),
+    ...Object.getOwnPropertyNames(Object.getPrototypeOf(browser))
+  ]
+  
+  allMethods.forEach(methodName => {
+    if (shouldWrapMethod(methodName)) {
+      const originalMethod = browser[methodName]
+      
+      browser[methodName] = (...args) => {
+        return this.handleCommandExecution(browser, methodName, originalMethod, args)
+      }
+    }
+  })
+}
+```
+
+#### Command Stack
+- Tracks command execution order
+- Associates results with commands
+- Handles nested/chained commands
+
+#### Deduplication
+Prevents duplicate command capture:
+- Generates signature: `command + args + callSource`
+- Compares with last command signature
+- Skips if duplicate
+
+#### Source Tracking
+Captures call location from stack traces:
+- Extracts file path and line number
+- Shows where command was called from test code
+- Improves debugging experience
+
+**Key Methods:**
+
+```typescript
+class BrowserProxy {
+  // Wrap all browser commands
+  wrapBrowserCommands(browser: NightwatchBrowser): void
+  
+  // Special handling for URL navigation
+  wrapUrlMethod(browser: NightwatchBrowser): void
+  
+  // Handle command execution
+  private handleCommandExecution(browser, methodName, originalMethod, args): any
+  
+  // Capture command result
+  private captureCommandResult(methodName, args, result, callSource): void
+  
+  // Capture command error
+  private captureCommandError(methodName, args, error, callSource): void
+  
+  // Reset tracking for new test
+  resetCommandTracking(): void
+}
+```
+
+---
+
+## Data Flow
+
+### Test Execution Flow
+
+```
+1. before() Hook (Global - Once)
+   ├─ Start @wdio/devtools-backend server
+   ├─ Open DevTools UI in Chrome window (separate session)
+   └─ Wait for UI connection (10 seconds)
+
+2. beforeEach() Hook (Per Test)
+   ├─ Initialize SessionCapturer (first test only)
+   │  └─ Connect WebSocket to backend
+   ├─ Create/Get Suite via SuiteManager
+   │  ├─ Extract test names from source file
+   │  └─ Pre-populate with pending tests
+   ├─ Find next pending test
+   ├─ Start test (mark as running)
+   ├─ Wrap browser commands via BrowserProxy
+   ├─ Wrap browser.url() for script injection
+   └─ Reset command tracking
+
+3. Test Execution
+   ├─ Browser commands intercepted by BrowserProxy
+   │  ├─ Detect test boundaries via TestManager
+   │  ├─ Start pending test on first command
+   │  └─ Capture command + args + result
+   ├─ Commands captured by SessionCapturer
+   ├─ Data streamed to backend via WebSocket
+   ├─ Backend broadcasts to UI clients
+   └─ UI updates in real-time
+
+4. afterEach() Hook (Per Test)
+   ├─ Read Nightwatch test results
+   ├─ Finalize current test via TestManager
+   │  └─ Update state (passed/failed/skipped)
+   ├─ Capture trace data via SessionCapturer
+   │  ├─ Network requests (from browser)
+   │  ├─ Console logs (from browser)
+   │  ├─ DOM mutations (from browser)
+   │  └─ Performance metrics (from browser)
+   ├─ Check if all tests in suite completed
+   └─ Finalize suite if complete
+
+5. after() Hook (Global - Once)
+   ├─ Finalize all incomplete suites
+   ├─ Send final data to UI
+   ├─ Display message: "Close browser to exit"
+   ├─ Poll UI browser until closed
+   │  ├─ If browser closed: cleanup and exit
+   │  └─ If Ctrl+C: exit immediately, keep browser open
+   ├─ Delete browser session (if closed naturally)
+   └─ Stop backend server
+```
+
+### Data Streaming Flow
+
+```
+Test Code → BrowserProxy → SessionCapturer → WebSocket → Backend → UI
+
+Example: browser.click('#submit')
+   ↓
+BrowserProxy intercepts click()
+   ↓
+Captures: { command: 'click', args: ['#submit'], timestamp, callSource }
+   ↓
+SessionCapturer adds to commandsLog
+   ↓
+sendUpstream('commands', [commandLog])
+   ↓
+WebSocket sends to backend
+   ↓
+Backend broadcasts to UI clients
+   ↓
+UI updates Commands panel
+```
+
+---
+
+## Nightwatch Lifecycle Hooks
+
+The plugin implements **4 standard Nightwatch hooks**:
+
+| Hook | Timing | Frequency | Purpose |
+|------|--------|-----------|---------|
+| `before()` | Before all tests | Once | Start backend, open UI |
+| `beforeEach(browser)` | Before each test | Per test | Initialize session, start test |
+| `afterEach(browser)` | After each test | Per test | Capture data, finalize test |
+| `after()` | After all tests | Once | Wait for UI close, cleanup |
+
+**Special Configuration:**
+- `asyncHookTimeout: 3600000` (1 hour) - Allows user to review UI after tests complete
+- Hooks can be async and return promises
+
+---
+
+## Key Design Patterns
+
+### 1. Reuse over Rebuild
+
+**Philosophy:** Don't reinvent the wheel, adapt existing infrastructure.
+
+**What's Reused:**
+- `@wdio/devtools-backend` - Fastify server + WebSocket (100% reused)
+- `@wdio/devtools-app` - Lit-based UI components (100% reused)
+- `@wdio/devtools-script` - Browser-side capture (100% reused)
+
+**What's New:**
+- Nightwatch lifecycle hook integration (~490 lines)
+- Test/suite state management
+- Command interception for Nightwatch API
+
+**Benefits:**
+- Minimal maintenance burden
+- Proven, battle-tested infrastructure
+- Same UI/UX across WDIO and Nightwatch
+- Future improvements benefit both ecosystems
+
+---
+
+### 2. Component Isolation
+
+**Principle:** Each component has a single, well-defined responsibility.
+
+**Benefits:**
+- Testable in isolation
+- Easy to understand and modify
+- Clear interfaces between components
+- Reduced coupling
+
+**Example:**
+```
+TestManager: Test lifecycle only
+SuiteManager: Suite lifecycle only
+BrowserProxy: Command interception only
+SessionCapturer: Data capture and transmission only
+```
+
+---
+
+### 3. Stable Identifiers
+
+**Problem:** Random/sequential IDs cause UI flickering and duplicate entries.
+
+**Solution:** Hash-based UIDs using stable identifiers (file + title).
+
+```typescript
+generateStableUid(filePath: string, name: string): string {
+  const signature = `${filePath}::${name}`
+  const hash = signature.split('').reduce((acc, char) => {
+    return ((acc << 5) - acc + char.charCodeAt(0)) | 0
+  }, 0)
+  return `stable-${Math.abs(hash).toString(36)}`
+}
+```
+
+**Benefits:**
+- Same UID across runs (consistent)
+- No duplicate test entries in UI
+- Proper updates (not additions) when test status changes
+
+---
+
+### 4. Real-time Streaming
+
+**Architecture:** Push-based data flow via WebSocket.
+
+**Flow:**
+```
+Capture → Stream → Display
+(immediate)  (real-time)  (live updates)
+```
+
+**Benefits:**
+- See tests as they execute
+- No need to wait for completion
+- Early detection of issues
+- Better debugging experience
+
+---
+
+### 5. Graceful Degradation
+
+**Philosophy:** Failures in capture should not break tests.
+
+**Examples:**
+- WebSocket connection fails → Log warning, continue without UI
+- Script injection fails → Log error, continue without browser capture
+- Backend start fails → Throw error (fatal, cannot proceed)
+- UI browser fails → Log error, show manual URL, continue
+
+**Implementation:**
+```typescript
+try {
+  await this.sessionCapturer.injectScript(browser)
+} catch (err) {
+  log.error(`Failed to inject script: ${err.message}`)
+  // Continue test execution
+}
+```
+
+---
+
+## Configuration
+
+### Plugin Configuration
+
+**Minimal:**
+```javascript
+// nightwatch.conf.js
+module.exports = {
+  plugins: ['@wdio/nightwatch-devtools']
+}
+```
+
+**With Options:**
+```javascript
+module.exports = {
+  plugins: [
+    ['@wdio/nightwatch-devtools', {
+      port: 3000,           // DevTools server port (default: 3000)
+      hostname: 'localhost' // DevTools server hostname (default: localhost)
+    }]
+  ]
+}
+```
+
+### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `port` | `number` | `3000` | Port for DevTools backend server |
+| `hostname` | `string` | `'localhost'` | Hostname for DevTools backend server |
+
+---
+
+## Browser-Side Capture
+
+The plugin injects `@wdio/devtools-script` into browser pages, which automatically captures:
+
+### Network Requests
+- **Method:** Performance API + Fetch/XHR interception
+- **Data:** URL, method, status, headers, timing, body (optional)
+- **Storage:** Sent to backend via postMessage → WebSocket
+
+### DOM Mutations
+- **Method:** MutationObserver API
+- **Data:** Added/removed/modified nodes
+- **Filtering:** Ignores internal DevTools changes
+
+### Console Logs
+- **Method:** Patch console methods (log, info, warn, error)
+- **Data:** Type, arguments, timestamp
+- **Original:** Calls original console method (non-invasive)
+
+### Performance Metrics
+- **Navigation Timing:** DNS, TCP, request, response, DOM load, page load
+- **Resource Timing:** Per-resource duration, size, type
+- **Data:** Available in command logs for navigation commands
+
+### Injection Points
+
+1. **After `browser.url()` navigation**
+   ```typescript
+   browser.url = function(url) {
+     const result = originalUrl(url)
+     result.perform(async function() {
+       await sessionCapturer.injectScript(this)
+     })
+     return result
+   }
+   ```
+
+2. **Automatic re-injection** on page transitions (clicks, form submits)
+
+---
+
+## Key Metrics Captured
+
+### Test Metrics
+| Metric | Source | When |
+|--------|--------|------|
+| Test title | Nightwatch currentTest | beforeEach |
+| Test status | Nightwatch testcases | afterEach |
+| Test duration | Nightwatch testcase.time | afterEach |
+| Test errors | Nightwatch testcases | afterEach |
+| Stack traces | Nightwatch error objects | afterEach |
+
+### Command Metrics
+| Metric | Source | When |
+|--------|--------|------|
+| Command name | Browser method name | During execution |
+| Arguments | Method arguments | Before execution |
+| Result | Method return value | After execution |
+| Timestamp | Date.now() | During execution |
+| Call source | Stack trace | During execution |
+| Screenshot | Browser screenshot | After page transitions |
+
+### Network Metrics
+| Metric | Source | When |
+|--------|--------|------|
+| Request URL | Performance API | During request |
+| Request method | Fetch/XHR interception | During request |
+| Response status | Fetch/XHR response | After response |
+| Headers | Request/Response objects | During/After request |
+| Timing | Performance API | After response |
+| Body | Fetch/XHR (optional) | During/After request |
+
+### Performance Metrics
+| Metric | Source | When |
+|--------|--------|------|
+| Page load time | Navigation Timing API | After page load |
+| DOM ready time | Navigation Timing API | After DOM ready |
+| Resource timings | Resource Timing API | After resource load |
+| DNS lookup time | Navigation Timing API | After page load |
+| TCP connection time | Navigation Timing API | After page load |
+
+---
+
+## Error Handling
+
+### Error Categories
+
+#### 1. Fatal Errors (Stop Execution)
+- **Backend start failure:** Cannot proceed without backend
+- **Plugin initialization failure:** Cannot proceed without plugin
+
+```typescript
+async before() {
+  try {
+    const { server, port } = await start(this.options)
+  } catch (err) {
+    log.error(`Failed to start backend: ${err.message}`)
+    throw err // Fatal - stop execution
+  }
+}
+```
+
+#### 2. Non-Fatal Errors (Log and Continue)
+- **UI browser failure:** User can open manually
+- **WebSocket connection failure:** Continues without UI updates
+- **Script injection failure:** Continues without browser capture
+- **Command capture errors:** Isolated per command
+
+```typescript
+try {
+  this.#devtoolsBrowser = await remote({ ... })
+} catch (err) {
+  log.error(`Failed to open DevTools UI: ${err.message}`)
+  log.info(`Please manually open: ${url}`)
+  // Continue execution
+}
+```
+
+### Error Recovery
+
+#### WebSocket Reconnection
+- Currently: No automatic reconnection
+- Logs error once, continues without streaming
+- Future: Could implement exponential backoff retry
+
+#### Script Injection Retry
+- Retries on next `browser.url()` call
+- No explicit retry logic (relies on page navigation)
+- Errors logged but don't block test execution
+
+#### Command Capture Isolation
+- Each command wrapped in try-catch
+- Errors in one command don't affect others
+- Test execution continues normally
+
+---
+
+## Process Lifecycle Management
+
+### Normal Exit (Browser Closed)
+
+```
+Tests Complete
+   ↓
+Display message: "Close browser to exit"
+   ↓
+Poll UI browser every 1 second
+   ↓
+Browser window closed by user
+   ↓
+Detect closure (getTitle() throws)
+   ↓
+Delete browser session
+   ↓
+Stop backend server
+   ↓
+Process exits cleanly
+```
+
+**Code:**
+```typescript
+while (true) {
+  try {
+    await this.#devtoolsBrowser.getTitle()
+    await new Promise(res => setTimeout(res, 1000))
+  } catch {
+    log.info('Browser window closed, stopping DevTools')
+    break
+  }
+}
+```
+
+### Ctrl+C Exit (Force Quit)
+
+```
+Tests Running/Complete
+   ↓
+User presses Ctrl+C
+   ↓
+SIGINT handler triggered
+   ↓
+exitBySignal = true
+   ↓
+Process exits immediately
+   ↓
+Browser window remains open
+   ↓
+Backend continues running
+```
+
+**Code:**
+```typescript
+const signalHandler = () => {
+  exitBySignal = true
+  log.info('Exiting... Browser window will remain open')
+  process.exit(0)
+}
+process.once('SIGINT', signalHandler)
+process.once('SIGTERM', signalHandler)
+```
+
+**Benefits:**
+- Allows inspection of UI after force quit
+- User has choice: graceful or force exit
+- Backend survives for post-mortem debugging
+
+---
+
+## Multi-Worker Support
+
+### Challenge
+Nightwatch can run tests in parallel using multiple browser sessions (workers).
+
+### Solution
+Detect session changes and reinitialize:
+
+```typescript
+async beforeEach(browser: NightwatchBrowser) {
+  const currentSessionId = browser.sessionId
+  
+  // Check if browser session changed (parallel workers)
+  if (currentSessionId && this.#lastSessionId && 
+      currentSessionId !== this.#lastSessionId) {
+    log.info('Browser session changed - reinitializing for new worker')
+    this.isScriptInjected = false
+    this.sessionCapturer = null // Reset for new session
+  }
+  
+  this.#lastSessionId = currentSessionId
+  
+  // Initialize for first test OR new session
+  if (!this.sessionCapturer) {
+    this.sessionCapturer = new SessionCapturer(...)
+    // ... initialize other components
+  }
+}
+```
+
+### Features
+- Automatic detection via `sessionId` comparison
+- Per-worker state isolation
+- Prevents cross-worker contamination
+- Handles worker restarts gracefully
+
+---
+
+## Dependencies
+
+### Core Dependencies
+
+| Package | Version | Purpose |
+|---------|---------|---------|
+| `@wdio/devtools-backend` | workspace:* | Server infrastructure (Fastify + WebSocket) |
+| `@wdio/logger` | ^9.6.0 | Logging framework |
+| `webdriverio` | ^9.18.0 | Browser automation (for opening UI) |
+| `ws` | ^8.18.3 | WebSocket client |
+| `import-meta-resolve` | ^4.2.0 | Module resolution |
+| `stacktrace-parser` | ^0.1.10 | Parse stack traces for call sources |
+
+### Dev Dependencies
+
+| Package | Version | Purpose |
+|---------|---------|---------|
+| `nightwatch` | ^3.0.0 | Peer dependency (test framework) |
+| `chromedriver` | ^133.0.0 | Chrome automation driver |
+| `typescript` | ^5.9.2 | Type checking and compilation |
+| `@types/node` | ^22.10.5 | Node.js type definitions |
+| `@types/ws` | ^8.18.1 | WebSocket type definitions |
+
+### Peer Dependencies
+
+```json
+{
+  "peerDependencies": {
+    "nightwatch": ">=3.0.0"
+  }
+}
+```
+
+---
+
+## Constants
+
+### Location
+`src/constants.ts`
+
+### Categories
+
+#### Page Transition Commands
+Commands that trigger page navigation:
+```typescript
+export const PAGE_TRANSITION_COMMANDS = [
+  'url', 'navigateTo', 'click', 'submitForm'
+]
+```
+
+#### Internal Commands to Ignore
+Nightwatch helper commands not relevant to users:
+```typescript
+export const INTERNAL_COMMANDS_TO_IGNORE = [
+  'isAppiumClient', 'isSafari', 'isChrome', 'isFirefox',
+  'session', 'timeouts', 'execute', 'executeAsync', ...
+]
+```
+
+#### Timing Constants (milliseconds)
+```typescript
+export const TIMING = {
+  UI_RENDER_DELAY: 150,           // Delay for UI to render updates
+  TEST_START_DELAY: 100,          // Delay before starting test
+  SUITE_COMPLETE_DELAY: 200,      // Delay after suite completion
+  UI_CONNECTION_WAIT: 10000,      // Wait for UI to connect (10s)
+  BROWSER_CLOSE_WAIT: 2000,       // Wait before browser close
+  INITIAL_CONNECTION_WAIT: 500,   // Initial WebSocket connection wait
+  BROWSER_POLL_INTERVAL: 1000     // Polling interval for browser status
+}
+```
+
+#### Test States
+```typescript
+export const TEST_STATE = {
+  PENDING: 'pending',
+  RUNNING: 'running',
+  PASSED: 'passed',
+  FAILED: 'failed',
+  SKIPPED: 'skipped'
+}
+```
+
+#### Log Sources
+```typescript
+export const LOG_SOURCES = {
+  BROWSER: 'browser',    // From browser console
+  TEST: 'test',          // From test code
+  TERMINAL: 'terminal'   // From terminal output
+}
+```
+
+---
+
+## Type System
+
+### Location
+`src/types.ts`
+
+### Key Types
+
+#### TestStats
+```typescript
+interface TestStats {
+  uid: string                    // Stable unique identifier
+  cid: string                    // Capability ID
+  title: string                  // Test name
+  fullTitle: string              // Full path: "Suite > Test"
+  parent: string                 // Parent suite UID
+  state: 'passed' | 'failed' | 'skipped' | 'pending' | 'running'
+  start: Date                    // Start timestamp
+  end: Date | null               // End timestamp
+  type: 'test'                   // Type discriminator
+  file: string                   // Test file path
+  retries: number                // Number of retries
+  _duration: number              // Duration in milliseconds
+  error?: Error                  // Error object if failed
+  hooks?: any[]                  // Before/after hooks
+}
+```
+
+#### SuiteStats
+```typescript
+interface SuiteStats {
+  uid: string                    // Stable unique identifier
+  cid: string                    // Capability ID
+  title: string                  // Suite name
+  fullTitle: string              // Full path
+  type: 'suite'                  // Type discriminator
+  file: string                   // Test file path
+  start: Date                    // Start timestamp
+  state?: 'pending' | 'running' | 'passed' | 'failed' | 'skipped'
+  end?: Date | null              // End timestamp
+  tests: (string | TestStats)[]  // Child tests
+  suites: SuiteStats[]           // Child suites
+  hooks: any[]                   // Before/after hooks
+  _duration: number              // Duration in milliseconds
+}
+```
+
+#### CommandLog
+```typescript
+interface CommandLog {
+  command: string                // Command name (e.g., 'click')
+  args: any[]                    // Command arguments
+  result?: any                   // Command result
+  error?: Error                  // Error if command failed
+  timestamp: number              // Execution timestamp
+  callSource?: string            // Source location (file:line)
+  screenshot?: string            // Screenshot (base64)
+  testUid?: string               // Associated test UID
+  performance?: PerformanceData  // Performance metrics
+  cookies?: string               // Cookies (JSON)
+  documentInfo?: DocumentInfo    // Document metadata
+}
+```
+
+#### NetworkRequest
+```typescript
+interface NetworkRequest {
+  id: string                     // Request ID
+  url: string                    // Request URL
+  method: string                 // HTTP method
+  headers?: Record<string, string>
+  status?: number                // Response status
+  statusText?: string            // Response status text
+  timestamp: number              // Request timestamp
+  startTime: number              // Request start time
+  endTime?: number               // Request end time
+  time?: number                  // Total duration
+  type: string                   // Resource type
+  response?: {
+    fromCache: boolean
+    headers: Record<string, string>
+    mimeType: string
+    status: number
+  }
+  error?: string                 // Error message
+  size?: number                  // Response size
+}
+```
+
+---
+
+## File Structure
+
+```
+packages/nightwatch-devtools/
+├── src/
+│   ├── index.ts              # Main plugin class (490 lines)
+│   ├── session.ts            # SessionCapturer (574 lines)
+│   ├── reporter.ts           # TestReporter (290 lines)
+│   ├── types.ts              # Type definitions (180 lines)
+│   ├── constants.ts          # Constants (100 lines)
+│   └── helpers/
+│       ├── browserProxy.ts   # BrowserProxy (263 lines)
+│       ├── testManager.ts    # TestManager (150 lines)
+│       ├── suiteManager.ts   # SuiteManager (120 lines)
+│       ├── capturePerformance.ts  # Performance capture script
+│       └── utils.ts          # Utility functions
+├── example/
+│   ├── nightwatch.conf.cjs   # Example configuration
+│   ├── tests/
+│   │   ├── login.test.js     # Sample test
+│   │   └── sample.test.js    # Sample test
+│   └── validate.cjs          # Plugin validation script
+├── package.json              # Package configuration
+├── tsconfig.json             # TypeScript configuration
+├── README.md                 # User documentation
+└── ARCHITECTURE.md           # This file
+```
+
+**Total Lines of Code:** ~2,167 lines (excluding dependencies)
+
+**Plugin Core:** ~490 lines (main orchestrator)
+
+---
+
+## Testing Strategy
+
+### Manual Testing
+```bash
+cd packages/nightwatch-devtools
+pnpm build                    # Compile TypeScript
+pnpm validate                 # Validate plugin structure
+pnpm example                  # Run example tests
+```
+
+### Validation Checklist
+- ✅ Plugin compiled (dist/ exists)
+- ✅ Plugin module loaded
+- ✅ Plugin exports default function
+- ✅ Plugin can be instantiated
+- ✅ All required lifecycle methods present
+- ✅ Backend server starts
+- ✅ UI browser opens
+- ✅ Tests execute successfully
+- ✅ UI updates in real-time
+- ✅ Process exits cleanly
+
+### Future Testing
+- Unit tests for individual components
+- Integration tests for data flow
+- E2E tests for full plugin lifecycle
+- Performance tests for large test suites
+
+---
+
+## Performance Considerations
+
+### Overhead
+- **Command interception:** Minimal (<1ms per command)
+- **WebSocket streaming:** Asynchronous, non-blocking
+- **Browser script injection:** One-time per page load
+- **UI browser:** Separate process, doesn't affect tests
+
+### Optimization Strategies
+- **Lazy initialization:** Components created on first use
+- **Efficient UIDs:** Hash-based, no string concatenation
+- **Minimal serialization:** Only serialize when needed
+- **Filtered logging:** Ignore internal framework logs
+- **Debouncing:** UI updates debounced to reduce noise
+
+### Scalability
+- **Large test suites:** Linear scaling with number of tests
+- **Parallel execution:** Per-worker state isolation
+- **Memory usage:** Bounded by test suite size
+- **Network usage:** WebSocket compression recommended (future)
+
+---
+
+## Future Enhancements
+
+### Short Term
+- [ ] Add unit tests for core components
+- [ ] Improve error messages and debugging info
+- [ ] Add configuration for capture verbosity
+- [ ] Support custom logger configuration
+
+### Medium Term
+- [ ] WebSocket reconnection logic
+- [ ] Performance profiling integration
+- [ ] Screenshot capture on test failure
+- [ ] Video recording support
+
+### Long Term
+- [ ] Multi-browser support (Firefox, Safari)
+- [ ] Remote execution support (Selenium Grid)
+- [ ] Advanced filtering and search in UI
+- [ ] Test replay functionality
+- [ ] Integration with CI/CD platforms
+
+---
+
+## Known Limitations
+
+### Current Limitations
+1. **Chrome Only:** UI browser currently Chrome-only (uses DevTools protocol)
+2. **No Automatic Reconnection:** WebSocket doesn't reconnect on failure
+3. **Single Backend:** One backend per test run (no multi-runner support yet)
+4. **Console Patching:** Currently disabled to prevent infinite loops
+5. **Stream Interception:** Currently disabled to prevent performance issues
+
+### Workarounds
+1. **Manual UI Opening:** If UI browser fails, user can open URL manually
+2. **Restart on Disconnect:** Restart test run if WebSocket disconnects
+3. **Sequential Runs:** Run tests sequentially if parallel causes issues
+4. **Direct Logging:** Use `console.log` in tests if needed (captured in terminal)
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+#### 1. Backend Fails to Start
+**Symptom:** Error message "Failed to start backend"
+
+**Causes:**
+- Port already in use
+- Insufficient permissions
+- Node.js version too old
+
+**Solutions:**
+- Change port in plugin options
+- Kill process using port: `lsof -ti:3000 | xargs kill`
+- Update Node.js to >= 18.0.0
+
+#### 2. UI Browser Doesn't Open
+**Symptom:** Warning "Failed to open DevTools UI"
+
+**Causes:**
+- Chrome/Chromium not installed
+- WebDriver issue
+- User data directory conflict
+
+**Solutions:**
+- Install Chrome/Chromium
+- Manually open URL shown in terminal
+- Clear temporary directories
+
+#### 3. No Data in UI
+**Symptom:** UI opens but shows no tests/commands
+
+**Causes:**
+- WebSocket connection failed
+- Script injection failed
+- Test completed too quickly
+
+**Solutions:**
+- Check browser console for errors
+- Increase connection wait time
+- Add delays in test for verification
+
+#### 4. Tests Hang
+**Symptom:** Tests don't complete, process doesn't exit
+
+**Causes:**
+- Async hook timeout too short
+- Backend server stuck
+- Browser process stuck
+
+**Solutions:**
+- Increase `asyncHookTimeout`
+- Force kill with Ctrl+C
+- Check browser DevTools for errors
+
+---
+
+## Contributing
+
+### Development Setup
+```bash
+# Clone repository
+git clone https://github.com/webdriverio/devtools.git
+cd devtools
+
+# Install dependencies
+pnpm install
+
+# Build all packages
+pnpm build
+
+# Navigate to Nightwatch plugin
+cd packages/nightwatch-devtools
+
+# Build plugin
+pnpm build
+
+# Run example
+pnpm example
+```
+
+### Code Style
+- TypeScript for type safety
+- ESLint for code quality
+- Prettier for formatting
+- JSDoc comments for public APIs
+
+### Testing
+- Add tests for new features
+- Ensure existing tests pass
+- Test with real Nightwatch projects
+- Verify UI updates correctly
+
+---
+
+## References
+
+### Documentation
+- [Nightwatch Plugin API](https://nightwatchjs.org/guide/extending-nightwatch/adding-plugins.html)
+- [WebdriverIO DevTools](https://webdriver.io/docs/devtools-service)
+- [WebSocket API](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)
+
+### Related Packages
+- [@wdio/devtools-backend](../backend/) - Backend server
+- [@wdio/devtools-app](../app/) - UI components
+- [@wdio/devtools-script](../script/) - Browser capture
+- [@wdio/devtools-service](../service/) - WDIO service (reference implementation)
+
+---
+
+## License
+
+MIT License - See [LICENSE](../../LICENSE) file for details.
+
+---
+
+## Maintainers
+
+WebdriverIO Team
+- Repository: https://github.com/webdriverio/devtools
+- Issues: https://github.com/webdriverio/devtools/issues
+- Pull Request: https://github.com/webdriverio/devtools/pull/156
+
+---
+
+**Last Updated:** February 18, 2026
diff --git a/packages/nightwatch-devtools/README.md b/packages/nightwatch-devtools/README.md
index c5a31831..00da385d 100644
--- a/packages/nightwatch-devtools/README.md
+++ b/packages/nightwatch-devtools/README.md
@@ -82,16 +82,53 @@ module.exports = {
 |--------|------|---------|-------------|
 | `port` | `number` | `3000` | Port for the DevTools backend server. Auto-incremented if already in use. |
 | `hostname` | `string` | `'localhost'` | Hostname the backend server binds to. |
+| `screencast` | `ScreencastOptions` | `{ enabled: false }` | Session video recording (see [Screencast](#screencast)). |
+| `bidi` | `boolean` | `false` | Opt into WebDriver BiDi capture for browser console + JS exceptions + network. Requires `webSocketUrl: true` in your capabilities and a BiDi-capable chromedriver. When attached, the per-command Chrome perf-log network path is gated off so requests don't duplicate. |
 
 ```javascript
 globals: nightwatchDevtools({
   port: 3000,
-  hostname: 'localhost'
+  hostname: 'localhost',
+  screencast: { enabled: true }
 })
 ```
 
 ---
 
+## Screencast
+
+Record a continuous `.webm` video of the browser session. The recording starts on the first session the plugin sees and is finalized in Nightwatch's `after()` hook, writing `nightwatch-video-<sessionId>.webm` to the directory of the test file that just ran. Falls back to the directory containing `nightwatch.conf.*` if the test file path isn't known, and to `process.cwd()` as a last resort. Directories under `node_modules/` are skipped.
+
+**Polling mode only.** Nightwatch doesn't expose a stable CDP escape hatch the way WebdriverIO (`browser.getPuppeteer()`) and Selenium (`driver.createCDPConnection`) do, so the screencast captures frames by calling `browser.takeScreenshot()` at a fixed interval. This works on every browser Nightwatch supports.
+
+### Quick start
+
+```javascript
+globals: nightwatchDevtools({
+  port: 3000,
+  screencast: { enabled: true, pollIntervalMs: 200 }
+})
+```
+
+### Options
+
+| Option | Type | Default | Notes |
+|--------|------|---------|-------|
+| `enabled` | `boolean` | `false` | Master switch. |
+| `pollIntervalMs` | `number` | `200` | Screenshot interval (ms). Lower = smoother video, more WebDriver round-trips. 200 ms ≈ 5 fps. |
+| `captureFormat` | `'jpeg' \| 'png'` | `'jpeg'` | Frame format. WebDriver screenshots are always PNG, so this only affects the encoded output. |
+| `maxWidth` / `maxHeight` / `quality` | — | — | CDP-only options, ignored in polling mode. Listed for shape compatibility with the WDIO/Selenium adapters. |
+
+### Prerequisites
+
+`fluent-ffmpeg` (already a runtime dep of this package) plus the `ffmpeg` binary on PATH. macOS: `brew install ffmpeg`. Linux: `apt install ffmpeg`. Without ffmpeg the recorder still runs but the encode step logs a warning and skips writing the file.
+
+### Output
+
+The encoded video is sent to the DevTools dashboard via the `screencast` WS scope and shown in the **Screencast** tab. The absolute path also appears in the Nightwatch log line `📹 Screencast video: <path>`.
+
+---
+
 ## Examples
 
 Working examples are included in this package:
@@ -124,6 +161,33 @@ Nightwatch does not provide the same depth of framework hooks as WebdriverIO, so
 
 Overall feature parity with the WebdriverIO DevTools service is approximately **80–90%**.
 
+### Preserve & Rerun (Compare)
+
+Available for Nightwatch — same dashboard UI as WebdriverIO. The "compare with rerun" flow snapshots the failing run, re-launches the test with `DEVTOOLS_RERUN_LABEL` set (the plugin filters down to just that test name on the rerun), and the dashboard shows the two runs side-by-side aligned by command.
+
+### BiDi capture (opt-in)
+
+Enable WebDriver BiDi capture for browser console messages, JS exceptions, and network requests. Equivalent to the path selenium-devtools uses — both adapters call the same `attachBidiHandlers` in `@wdio/devtools-core`.
+
+```javascript
+globals: nightwatchDevtools({
+  port: 3000,
+  bidi: true
+})
+```
+
+You also need `webSocketUrl: true` in your capabilities so chromedriver actually exposes the BiDi channel:
+
+```javascript
+desiredCapabilities: {
+  browserName: 'chrome',
+  'webSocketUrl': true,                         // ← enables BiDi
+  'goog:chromeOptions': { /* ... */ }
+}
+```
+
+When attached, the per-command Chrome performance-log network capture path is gated off so requests don't appear twice in the dashboard. If `webSocketUrl` is missing or the chromedriver version doesn't expose BiDi, the attach silently fails and the perf-log fallback continues to work.
+
 ## :page_facing_up: License
 
 [MIT](/LICENSE)
diff --git a/packages/nightwatch-devtools/package.json b/packages/nightwatch-devtools/package.json
index f3b7aff0..0a92afb0 100644
--- a/packages/nightwatch-devtools/package.json
+++ b/packages/nightwatch-devtools/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@wdio/nightwatch-devtools",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Nightwatch adapter for WebdriverIO DevTools - reuses existing backend, UI, and capture infrastructure",
   "type": "module",
   "main": "dist/index.js",
@@ -25,11 +25,11 @@
     "plugin": true
   },
   "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
+    "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",
+    "watch": "tsup src/index.ts --format esm --dts --sourcemap --watch",
     "clean": "rm -rf dist",
     "lint": "eslint .",
-    "example": "nightwatch -c example/nightwatch.conf.cjs",
+    "example": "nightwatch -c ../../examples/nightwatch/nightwatch.conf.cjs",
     "prepublishOnly": "pnpm build"
   },
   "keywords": [
@@ -43,18 +43,22 @@
   "dependencies": {
     "@wdio/devtools-backend": "workspace:*",
     "@wdio/devtools-script": "workspace:*",
-    "@wdio/logger": "^9.6.0",
+    "@wdio/logger": "^9.18.0",
+    "fluent-ffmpeg": "^2.1.3",
     "import-meta-resolve": "^4.2.0",
     "stacktrace-parser": "^0.1.11",
-    "webdriverio": "^9.18.0",
-    "ws": "^8.18.3"
+    "webdriverio": "^9.27.2",
+    "ws": "^8.21.0"
   },
   "devDependencies": {
-    "@types/node": "25.5.2",
+    "@types/node": "25.9.1",
     "@types/ws": "^8.18.1",
-    "chromedriver": "^148.0.3",
-    "nightwatch": "^3.0.0",
-    "typescript": "^6.0.2"
+    "@wdio/devtools-core": "workspace:^",
+    "@wdio/devtools-shared": "workspace:^",
+    "chromedriver": "^148.0.4",
+    "nightwatch": "^3.16.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "devtools": "^8.42.0",
diff --git a/packages/nightwatch-devtools/src/bidi.ts b/packages/nightwatch-devtools/src/bidi.ts
new file mode 100644
index 00000000..7c7ecdd6
--- /dev/null
+++ b/packages/nightwatch-devtools/src/bidi.ts
@@ -0,0 +1,56 @@
+import logger from '@wdio/logger'
+import {
+  type BidiHandlerSinks,
+  attachBidiHandlers as attachBidiHandlersCore
+} from '@wdio/devtools-core'
+import type { SessionCapturer } from './session.js'
+
+const log = logger('@wdio/nightwatch-devtools:bidi')
+
+/**
+ * Nightwatch wrapper around the core BiDi attach helper. Nightwatch ships
+ * selenium-webdriver under the hood (via chromedriver), so the same
+ * `selenium-webdriver/bidi` inspectors selenium-devtools uses are available
+ * whenever the user has set `webSocketUrl: true` in their capabilities.
+ *
+ * Opt-in via the plugin's `bidi: true` option. When attached, the per-command
+ * Chrome performance-log network capture is gated off to avoid duplicate
+ * entries in the dashboard.
+ */
+export async function attachBidiHandlers(
+  driver: unknown,
+  sinks: BidiHandlerSinks
+): Promise<boolean> {
+  return attachBidiHandlersCore(driver, sinks, (level, message) =>
+    log[level](message)
+  )
+}
+
+/**
+ * Build sinks that route BiDi events into the SessionCapturer's local arrays
+ * and broadcast them upstream. Mirrors selenium-devtools' `buildBidiSinks` —
+ * separate per-adapter because the SessionCapturer concrete types differ.
+ */
+export function buildBidiSinks(capturer: SessionCapturer): BidiHandlerSinks {
+  return {
+    pushConsoleLog: (entry) => {
+      capturer.consoleLogs.push(entry)
+      capturer.sendUpstream('consoleLogs', [entry])
+    },
+    pushNetworkRequest: (entry) => {
+      capturer.networkRequests.push(entry)
+      capturer.sendUpstream('networkRequests', [entry])
+    },
+    replaceNetworkRequest: (id, entry) => {
+      const idx = capturer.networkRequests.findIndex(
+        (r: { id?: string }) => r.id === id
+      )
+      if (idx !== -1) {
+        capturer.networkRequests[idx] = entry
+      } else {
+        capturer.networkRequests.push(entry)
+      }
+      capturer.sendUpstream('networkRequests', [entry])
+    }
+  }
+}
diff --git a/packages/nightwatch-devtools/src/constants.ts b/packages/nightwatch-devtools/src/constants.ts
index 270070bc..e4888954 100644
--- a/packages/nightwatch-devtools/src/constants.ts
+++ b/packages/nightwatch-devtools/src/constants.ts
@@ -33,53 +33,30 @@ export const INTERNAL_COMMANDS_TO_IGNORE = [
   'end'
 ] as const
 
-export const CONSOLE_METHODS = ['log', 'info', 'warn', 'error'] as const
+// Console capture constants are defined in @wdio/devtools-core; re-exported
+// here so existing imports from ./constants.js continue to work.
+export {
+  ANSI_REGEX,
+  CONSOLE_METHODS,
+  LOG_LEVEL_PATTERNS,
+  LOG_SOURCES
+} from '@wdio/devtools-core'
 
-export const LOG_LEVEL_PATTERNS: ReadonlyArray<{
-  level: 'trace' | 'debug' | 'info' | 'warn' | 'error'
-  pattern: RegExp
-}> = [
-  { level: 'trace', pattern: /\btrace\b/i },
-  { level: 'debug', pattern: /\bdebug\b/i },
-  { level: 'info', pattern: /\binfo\b/i },
-  { level: 'warn', pattern: /\bwarn(ing)?\b/i },
-  { level: 'error', pattern: /\berror\b/i }
-] as const
-
-export const LOG_SOURCES = {
-  BROWSER: 'browser',
-  TEST: 'test',
-  TERMINAL: 'terminal'
-} as const
-
-export const ANSI_REGEX = /\x1b\[[?]?[0-9;]*[A-Za-z]/g
+import { DEFAULTS_BASE, TIMING_BASE } from '@wdio/devtools-shared'
 
 export const DEFAULTS = {
-  CID: '0-0',
+  ...DEFAULTS_BASE,
   TEST_NAME: 'unknown',
-  FILE_NAME: 'unknown',
-  RETRIES: 0,
-  DURATION: 0
+  FILE_NAME: 'unknown'
 } as const
 
-/** Timing constants (in milliseconds) */
 export const TIMING = {
-  UI_RENDER_DELAY: 150,
-  TEST_START_DELAY: 100,
-  SUITE_COMPLETE_DELAY: 200,
-  UI_CONNECTION_WAIT: 10000,
-  BROWSER_CLOSE_WAIT: 2000,
-  INITIAL_CONNECTION_WAIT: 500,
-  BROWSER_POLL_INTERVAL: 1000
+  ...TIMING_BASE,
+  /** Nightwatch boots slower than selenium — give the dashboard 10s. */
+  UI_CONNECTION_WAIT: 10000
 } as const
 
-export const TEST_STATE = {
-  PENDING: 'pending',
-  RUNNING: 'running',
-  PASSED: 'passed',
-  FAILED: 'failed',
-  SKIPPED: 'skipped'
-} as const
+export { TEST_STATE } from '@wdio/devtools-shared'
 
 /**
  * Generic pattern matching Nightwatch commands whose result is a boolean.
@@ -89,11 +66,12 @@ export const BOOLEAN_COMMAND_PATTERN =
 
 export const NAVIGATION_COMMANDS = ['url', 'navigate', 'navigateTo'] as const
 
-/** Spinner progress frames — suppress from UI Console output. */
-export const SPINNER_RE = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/u
+export { SPINNER_RE } from '@wdio/devtools-core'
 
-/** Matches file names that follow the *.test.ts / *.spec.js naming convention. */
-export const TEST_FILE_PATTERN = /\.(?:test|spec)\.[cm]?[jt]sx?$/i
+/** Matches file names that follow the *.test.ts / *.spec.js naming
+ *  convention. Re-exported from @wdio/devtools-shared (single source of
+ *  truth — service uses the same pattern under the name SPEC_FILE_RE). */
+export { SPEC_FILE_RE as TEST_FILE_PATTERN } from '@wdio/devtools-shared'
 
 /** Nightwatch config file names to search for, in priority order. */
 export const CONFIG_FILENAMES = [
diff --git a/packages/nightwatch-devtools/src/cucumber-lifecycle.ts b/packages/nightwatch-devtools/src/cucumber-lifecycle.ts
new file mode 100644
index 00000000..afb8a832
--- /dev/null
+++ b/packages/nightwatch-devtools/src/cucumber-lifecycle.ts
@@ -0,0 +1,307 @@
+/**
+ * Cucumber lifecycle for the Nightwatch plugin.
+ *
+ * Extracted from the plugin class to keep `index.ts` under the file-size cap
+ * and to isolate the cucumber-specific orchestration from the per-test
+ * (Mocha/Jasmine-style) lifecycle.
+ *
+ * The plugin passes itself as a `CucumberLifecycleCtx` — a narrow interface
+ * exposing only the fields and methods this module needs. The lifecycle
+ * helpers mutate the plugin's "current execution" state via the accessors on
+ * the ctx (they can't reach the plugin's private fields directly).
+ */
+
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+import { WS_SCOPE } from '@wdio/devtools-shared'
+
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { TestManager } from './helpers/testManager.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { BrowserProxy } from './helpers/browserProxy.js'
+import type { NightwatchBrowser, SuiteStats, TestStats } from './types.js'
+import { TEST_STATE } from './constants.js'
+import {
+  closeOpenSteps,
+  cucumberResultToTestState
+} from './helpers/cucumberResult.js'
+import { buildCucumberScenarioSuite } from './helpers/cucumberScenarioBuilder.js'
+import { scanFeatureFile } from './helpers/featureFileScan.js'
+import { parseCucumberScenario } from './helpers/utils.js'
+
+const log = logger('@wdio/nightwatch-devtools:cucumber')
+
+/** Minimal shapes for the Cucumber objects we touch. Cucumber's own types
+ *  vary across major versions; we pin only fields we read. */
+export interface CucumberPickleStep {
+  text?: string
+  astNodeIds?: string[]
+  location?: { line?: number }
+}
+export interface CucumberPickle {
+  uri?: string
+  name?: string
+  location?: { line?: number }
+  astNodeIds?: string[]
+  steps?: CucumberPickleStep[]
+}
+export interface CucumberResult {
+  status?: string
+}
+
+export interface CucumberLifecycleCtx {
+  readonly sessionCapturer: SessionCapturer
+  readonly testReporter: TestReporter
+  readonly testManager: TestManager
+  readonly suiteManager: SuiteManager
+  readonly browserProxy: BrowserProxy | undefined
+  setCucumberRunner(v: boolean): void
+  ensureSessionInitialized(browser: NightwatchBrowser): Promise<void>
+  wrapBrowserOnce(browser: NightwatchBrowser): void
+  incrementCount(state: TestStats['state']): void
+  testIcon(state: TestStats['state']): string
+  getCurrentScenarioSuite(): SuiteStats | null
+  setCurrentScenarioSuite(s: SuiteStats | null): void
+  setCurrentStep(s: unknown): void
+  getCurrentStep(): unknown
+  setCurrentTest(t: unknown): void
+}
+
+type MutStep = {
+  title?: string
+  state?: string
+  start?: Date | null
+  end?: Date | null
+  _duration?: number
+}
+
+function attachScenarioToFeature(
+  ctx: CucumberLifecycleCtx,
+  featureSuite: SuiteStats,
+  scenarioSuite: SuiteStats
+): void {
+  // If a suite with this uid already exists, this is a RETRY of the same
+  // scenario — clear execution data so only the latest attempt shows.
+  const existingIdx = featureSuite.suites.findIndex(
+    (s: SuiteStats) => s.uid === scenarioSuite.uid
+  )
+  if (existingIdx !== -1) {
+    featureSuite.suites[existingIdx] = scenarioSuite
+    // Pass the specific scenario uid so only this scenario's execution data
+    // is reset — a uid-less clearExecutionData would mark ALL suites as
+    // running, destroying the previous terminal states of sibling scenarios.
+    ctx.sessionCapturer.sendUpstream(WS_SCOPE.clearExecutionData, {
+      uid: scenarioSuite.uid,
+      entryType: 'suite'
+    })
+  } else {
+    featureSuite.suites.push(scenarioSuite)
+  }
+}
+
+function createFeatureSuite(
+  ctx: CucumberLifecycleCtx,
+  featureUri: string,
+  featureName: string,
+  featureContent: string,
+  featureAbsPath: string,
+  scenarioName: string,
+  steps: Array<{ text: string }>
+): {
+  featureSuite: SuiteStats
+  scenarioLine: number
+  stepLines: number[]
+  stepKeywords: string[]
+} {
+  const featureSuite = ctx.suiteManager.getOrCreateSuite(
+    featureUri,
+    featureName,
+    featureUri,
+    []
+  )
+  ctx.suiteManager.markSuiteAsRunning(featureSuite)
+  const { featureLine, scenarioLine, stepLines, stepKeywords } =
+    parseCucumberScenario(
+      featureContent,
+      scenarioName,
+      steps.map((s) => s.text)
+    )
+  if (featureAbsPath && featureLine > 0) {
+    featureSuite.callSource = `${featureAbsPath}:${featureLine}`
+  }
+  return { featureSuite, scenarioLine, stepLines, stepKeywords }
+}
+
+function normalizeSteps(
+  pickleSteps: CucumberPickleStep[] | undefined
+): Array<{ text: string }> {
+  return (pickleSteps ?? []).map((s) => ({ text: s.text ?? '' }))
+}
+
+export async function initCucumberScenario(
+  ctx: CucumberLifecycleCtx,
+  browser: NightwatchBrowser,
+  pickle: CucumberPickle
+): Promise<void> {
+  await ctx.ensureSessionInitialized(browser)
+  const featureUri: string = pickle.uri ?? 'unknown.feature'
+  const scenarioName: string = pickle.name ?? 'Unknown Scenario'
+  const steps = normalizeSteps(pickle.steps)
+  const {
+    featureName,
+    featureContent,
+    featureAbsPath,
+    stepDefFiles,
+    capturedPaths
+  } = scanFeatureFile(featureUri)
+  for (const p of capturedPaths) {
+    ctx.sessionCapturer.captureSource(p).catch(() => {})
+  }
+  const { featureSuite, scenarioLine, stepLines, stepKeywords } =
+    createFeatureSuite(
+      ctx,
+      featureUri,
+      featureName,
+      featureContent,
+      featureAbsPath,
+      scenarioName,
+      steps
+    )
+  const scenarioSuite = buildCucumberScenarioSuite({
+    featureUri,
+    scenarioName,
+    featureName,
+    featureAbsPath,
+    stepDefFiles,
+    steps,
+    stepLines,
+    stepKeywords,
+    scenarioLine,
+    parentFeatureSuiteUid: featureSuite.uid
+  })
+  attachScenarioToFeature(ctx, featureSuite, scenarioSuite)
+  ctx.setCurrentScenarioSuite(scenarioSuite)
+  ctx.setCurrentStep(null)
+  ctx.setCurrentTest(null)
+  ctx.testReporter.updateSuites()
+  ctx.wrapBrowserOnce(browser)
+  log.info(`🥒 Scenario: ${scenarioName}`)
+}
+
+export async function finalizeCucumberScenario(
+  ctx: CucumberLifecycleCtx,
+  browser: NightwatchBrowser,
+  result: CucumberResult,
+  pickle: CucumberPickle | undefined
+): Promise<void> {
+  try {
+    const scenarioState = cucumberResultToTestState(result)
+    const scenario = ctx.getCurrentScenarioSuite()
+    if (scenario) {
+      const now = new Date()
+      const duration =
+        now.getTime() - (scenario.start?.getTime() ?? now.getTime())
+      scenario.state = scenarioState
+      scenario.end = now
+      scenario._duration = duration
+      closeOpenSteps(scenario, scenarioState, now)
+
+      const featureUri: string = pickle?.uri ?? 'unknown.feature'
+      ctx.testManager.markTestAsProcessed(featureUri, pickle?.name ?? '')
+
+      const featureSuite = ctx.suiteManager.getSuite(featureUri)
+      if (featureSuite) {
+        // Finalize is not called until all scenarios are done — just update state.
+        ctx.suiteManager.finalizeSuiteState(featureSuite)
+      }
+
+      ctx.incrementCount(scenarioState)
+      const icon = ctx.testIcon(scenarioState)
+      log.info(
+        `  ${icon} ${pickle?.name ?? 'Unknown'} (${(duration / 1000).toFixed(2)}s)`
+      )
+
+      ctx.testReporter.updateSuites()
+      ctx.setCurrentScenarioSuite(null)
+      ctx.setCurrentStep(null)
+      ctx.setCurrentTest(null)
+    }
+    await ctx.sessionCapturer.captureTrace(browser)
+  } catch (err) {
+    log.error(`Failed to finalize Cucumber scenario: ${errorMessage(err)}`)
+  }
+}
+
+export async function cucumberBeforeStep(
+  ctx: CucumberLifecycleCtx,
+  _browser: NightwatchBrowser,
+  pickleStep: CucumberPickleStep,
+  _pickle: CucumberPickle
+): Promise<void> {
+  const scenario = ctx.getCurrentScenarioSuite()
+  if (!scenario) {
+    return
+  }
+  // Reset per-step dedup tracking so commands in step N are never
+  // mistaken for retries of identically-signatured commands from step N-1.
+  ctx.browserProxy?.resetCommandTracking()
+
+  const stepText: string = pickleStep?.text ?? ''
+  const step = (scenario.tests as Array<MutStep | string>).find(
+    (t): t is MutStep =>
+      typeof t !== 'string' &&
+      (t.title?.endsWith(stepText) === true || t.title === stepText)
+  )
+  if (step) {
+    step.state = TEST_STATE.RUNNING
+    step.start = new Date()
+    step.end = null
+    ctx.setCurrentStep(step)
+    ctx.testReporter.updateSuites()
+  }
+}
+
+export async function cucumberAfterStep(
+  ctx: CucumberLifecycleCtx,
+  _browser: NightwatchBrowser,
+  result: CucumberResult,
+  pickleStep: CucumberPickleStep,
+  _pickle: CucumberPickle
+): Promise<void> {
+  const step = ctx.getCurrentStep() as MutStep | null
+  if (!step) {
+    return
+  }
+  const status = String(result?.status ?? 'UNKNOWN').toUpperCase()
+  const stepState: TestStats['state'] =
+    status === 'PASSED'
+      ? TEST_STATE.PASSED
+      : status === 'SKIPPED'
+        ? TEST_STATE.SKIPPED
+        : TEST_STATE.FAILED
+  step.state = stepState
+  step.end = new Date()
+  step._duration = Date.now() - (step.start?.getTime() ?? Date.now())
+  ctx.setCurrentStep(null)
+  ctx.testReporter.updateSuites()
+  void pickleStep
+}
+
+export async function cucumberBefore(
+  ctx: CucumberLifecycleCtx,
+  browser: NightwatchBrowser,
+  pickle: CucumberPickle
+): Promise<void> {
+  ctx.setCucumberRunner(true)
+  await initCucumberScenario(ctx, browser, pickle)
+}
+
+export async function cucumberAfter(
+  ctx: CucumberLifecycleCtx,
+  browser: NightwatchBrowser,
+  result: CucumberResult,
+  pickle: CucumberPickle
+): Promise<void> {
+  await finalizeCucumberScenario(ctx, browser, result, pickle)
+}
diff --git a/packages/nightwatch-devtools/src/event-hub.ts b/packages/nightwatch-devtools/src/event-hub.ts
new file mode 100644
index 00000000..d68920c7
--- /dev/null
+++ b/packages/nightwatch-devtools/src/event-hub.ts
@@ -0,0 +1,68 @@
+/**
+ * Nightwatch eventHub integration.
+ *
+ * Extracted from the plugin class so registration stays out of the
+ * file-size cap and the metadata-forwarding behavior is unit-testable
+ * without standing up the whole plugin. The plugin's
+ * `registerEventHandlers(eventHub)` delegates here.
+ */
+
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+import { TraceType } from './types.js'
+import type { SessionCapturer } from './session.js'
+import type { NightwatchEventHub } from './types.js'
+
+const log = logger('@wdio/nightwatch-devtools:event-hub')
+
+export interface EventHubBindings {
+  /** Live session capturer — may be undefined until bringup completes. */
+  getSessionCapturer(): SessionCapturer | undefined
+  /** Builds the `options` field forwarded with the metadata payload. */
+  buildMetadataOptions(): unknown
+  /** Lets the plugin flip the cucumber-runner flag on detection. */
+  setCucumberRunner(value: boolean): void
+}
+
+function makeSessionMetadataHandler(
+  bindings: EventHubBindings
+): (data: unknown) => void {
+  return (data: unknown) => {
+    try {
+      const md =
+        ((data as { metadata?: Record<string, unknown> } | undefined)
+          ?.metadata as Record<string, unknown> | undefined) ?? {}
+      const capturer = bindings.getSessionCapturer()
+      const sessionCapabilities = md.sessionCapabilities
+      const sessionId = md.sessionId as string | undefined
+      if (!capturer || (!sessionCapabilities && !sessionId)) {
+        return
+      }
+      capturer.sendUpstream('metadata', {
+        type: TraceType.Testrunner,
+        capabilities: sessionCapabilities ?? {},
+        sessionId,
+        testEnv: md.testEnv as string | undefined,
+        host: md.host as string | undefined,
+        modulePath: md.modulePath as string | undefined,
+        options: bindings.buildMetadataOptions()
+      })
+    } catch (err) {
+      log.error(`Error in event handler: ${errorMessage(err)}`)
+    }
+  }
+}
+
+export function registerEventHandlers(
+  eventHub: NightwatchEventHub,
+  bindings: EventHubBindings
+): void {
+  bindings.setCucumberRunner(eventHub.runner === 'cucumber')
+  if (eventHub.runner === 'cucumber') {
+    log.info('✓ Cucumber runner detected via NightwatchEventHub')
+  }
+  log.info('✓ NightwatchEventHub registered — enriched metadata enabled')
+  const handler = makeSessionMetadataHandler(bindings)
+  eventHub.on('TestSuiteStarted', handler)
+  eventHub.on('TestRunStarted', handler)
+}
diff --git a/packages/nightwatch-devtools/src/helpers/browserProxy.ts b/packages/nightwatch-devtools/src/helpers/browserProxy.ts
index b7ba167b..06711140 100644
--- a/packages/nightwatch-devtools/src/helpers/browserProxy.ts
+++ b/packages/nightwatch-devtools/src/helpers/browserProxy.ts
@@ -6,13 +6,19 @@
 import logger from '@wdio/logger'
 import {
   INTERNAL_COMMANDS_TO_IGNORE,
-  BOOLEAN_COMMAND_PATTERN,
   NAVIGATION_COMMANDS
 } from '../constants.js'
 import { getCallSourceFromStack } from './utils.js'
+import { serializeCommandResult } from './serializeCommandResult.js'
+import { RetryTracker, toError } from '@wdio/devtools-core'
 import type { SessionCapturer } from '../session.js'
 import type { TestManager } from './testManager.js'
-import type { NightwatchBrowser, CommandStackFrame } from '../types.js'
+import type {
+  CommandLog,
+  NightwatchBrowser,
+  NightwatchCurrentTest,
+  CommandStackFrame
+} from '../types.js'
 
 const log = logger('@wdio/nightwatch-devtools:browserProxy')
 
@@ -27,13 +33,12 @@ export class BrowserProxy {
    * command (e.g. getText inside a waitFor loop) overwrite the previous entry
    * rather than appending, showing only the final execution result.
    */
-  private lastCapturedSig: string | null = null
-  private lastCapturedId: number | null = null
+  private retryTracker = new RetryTracker()
 
   constructor(
     private sessionCapturer: SessionCapturer,
     private testManager: TestManager,
-    private getCurrentTest: () => any
+    private getCurrentTest: () => { uid?: string } | null
   ) {}
 
   /**
@@ -47,8 +52,7 @@ export class BrowserProxy {
   resetCommandTracking(): void {
     this.commandStack = []
     this.lastCommandSig = null
-    this.lastCapturedSig = null
-    this.lastCapturedId = null
+    this.retryTracker.reset()
   }
 
   getCurrentTestFullPath(): string | null {
@@ -70,13 +74,23 @@ export class BrowserProxy {
   wrapUrlMethod(browser: NightwatchBrowser): void {
     const sessionCapturer = this.sessionCapturer
 
+    // Cast once for dynamic method access — Nightwatch's typed surface
+    // doesn't enumerate every command, but they all live on the same object.
+    // Return type is `unknown` because wrapNav has to handle both
+    // Nightwatch's chainable API (returns a chainable with `.perform`) and
+    // Cucumber async/await (returns a Promise) — we narrow at each branch.
+    const b = browser as unknown as Record<
+      string,
+      (...args: unknown[]) => unknown
+    >
+
     const wrapNav = (methodName: string) => {
-      if (typeof (browser as any)[methodName] !== 'function') {
+      if (typeof b[methodName] !== 'function') {
         return
       }
-      const original = (browser as any)[methodName].bind(browser)
+      const original = b[methodName].bind(browser)
 
-      ;(browser as any)[methodName] = function (...args: any[]) {
+      b[methodName] = function (...args: unknown[]) {
         const result = original(...args)
 
         const injectAndCapture = () => {
@@ -85,15 +99,18 @@ export class BrowserProxy {
             .injectScript(browser)
             .then(() => sessionCapturer.captureTrace(browser))
             .catch((err: Error) =>
-              log.error(`Failed to inject script: ${err.message}`)
+              log.error(`Failed to inject script: ${(err as Error).message}`)
             )
         }
 
-        if (result && typeof result.perform === 'function') {
+        const chainable = result as
+          | { perform?: (cb: (done: Function) => void) => void }
+          | undefined
+        if (chainable && typeof chainable.perform === 'function') {
           // Standard Nightwatch (chained API): queue inside perform so it
           // runs after navigation completes.  Always pass `done` so the
           // command queue is unblocked even if injection fails.
-          result.perform((done: Function) => {
+          chainable.perform((done: Function) => {
             injectAndCapture().finally(() => done && done())
           })
           return result
@@ -122,7 +139,13 @@ export class BrowserProxy {
       return
     }
 
-    const browserAny = browser as any
+    // Single widening: Nightwatch's `browser` is a dynamic command bag —
+    // every wrapped lookup below is property-name → function. Casting once
+    // keeps the wrap loop readable.
+    const browserAny = browser as unknown as Record<
+      string,
+      (...args: unknown[]) => unknown
+    >
     const allMethods = new Set([
       ...Object.keys(browser),
       ...Object.getOwnPropertyNames(Object.getPrototypeOf(browser))
@@ -138,7 +161,9 @@ export class BrowserProxy {
       }
 
       if (
-        INTERNAL_COMMANDS_TO_IGNORE.includes(methodName as any) ||
+        (INTERNAL_COMMANDS_TO_IGNORE as readonly string[]).includes(
+          methodName
+        ) ||
         methodName.startsWith('__')
       ) {
         return
@@ -146,7 +171,7 @@ export class BrowserProxy {
 
       const originalMethod = browserAny[methodName].bind(browser)
 
-      browserAny[methodName] = (...args: any[]) => {
+      browserAny[methodName] = (...args: unknown[]) => {
         return this.handleCommandExecution(
           browser,
           browserAny,
@@ -163,219 +188,224 @@ export class BrowserProxy {
     log.info(`✓ Wrapped ${wrappedMethods.length} browser methods`)
   }
 
-  private handleCommandExecution(
+  private handleRetryReplacement(
     browser: NightwatchBrowser,
-    browserAny: any,
     methodName: string,
-    originalMethod: Function,
-    args: any[]
-  ): any {
-    const currentNightwatchTest = browserAny.currentTest
-    const currentTestName = this.testManager.detectTestBoundary(
-      currentNightwatchTest
+    logArgs: unknown[],
+    serializedResult: unknown,
+    effectiveUid: string,
+    callSource: string | undefined,
+    commandTimestamp: number
+  ): void {
+    // Same command fired again (internal retry) — replace the previous
+    // entry so only the final result appears in the UI.
+    const { entry, oldTimestamp } = this.sessionCapturer.replaceCommand(
+      this.retryTracker.lastId!,
+      methodName,
+      logArgs,
+      serializedResult,
+      undefined,
+      effectiveUid,
+      callSource,
+      commandTimestamp
     )
-    this.testManager.startTestIfPending(currentTestName)
+    this.retryTracker.setLastId(entry._id ?? null)
+    this.sessionCapturer.sendReplaceCommand(oldTimestamp, entry)
+    this.attachScreenshot(browser, entry, methodName, ' (retry)')
+  }
 
-    const callInfo = getCallSourceFromStack()
-    if (callInfo.filePath && !this.currentTestFullPath) {
-      this.currentTestFullPath = callInfo.filePath
+  private captureFreshCommand(
+    browser: NightwatchBrowser,
+    methodName: string,
+    logArgs: unknown[],
+    serializedResult: unknown,
+    effectiveUid: string,
+    callSource: string | undefined,
+    commandTimestamp: number,
+    cmdSig: string
+  ): void {
+    // captureCommand() pushes the entry to commandsLog synchronously before
+    // any async work (navigation perf capture), so we can grab the ID
+    // immediately after the call — before any microtask fires. This avoids
+    // the race where a Nightwatch retry callback executes before .then() sets
+    // lastId, causing missed dedup. Stage the sig now, set the id after the
+    // synchronous push lands.
+    this.retryTracker.setLastSig(cmdSig)
+    this.retryTracker.setLastId(null)
+    this.sessionCapturer
+      .captureCommand(
+        methodName,
+        logArgs,
+        serializedResult,
+        undefined,
+        effectiveUid,
+        callSource,
+        commandTimestamp
+      )
+      .catch((err) =>
+        log.error(`Failed to capture ${methodName}: ${(err as Error).message}`)
+      )
+    const lastCommand =
+      this.sessionCapturer.commandsLog[
+        this.sessionCapturer.commandsLog.length - 1
+      ]
+    if (lastCommand) {
+      this.retryTracker.setLastId((lastCommand as { _id?: number })._id ?? null)
+      this.sessionCapturer.sendCommand(lastCommand)
+      log.info(`[command] ${methodName}`)
+      this.attachScreenshot(browser, lastCommand, methodName)
     }
+    this.maybeRepollMutations(browser, methodName)
+  }
 
-    const lastArg = args[args.length - 1]
-    const hasUserCallback = typeof lastArg === 'function'
-    const userCallback: Function | null = hasUserCallback ? lastArg : null
-    const logArgs = hasUserCallback ? args.slice(0, -1) : args
-
-    // Check for duplicate commands (based on method + logical args)
-    const cmdSig = JSON.stringify({
-      command: methodName,
-      args: logArgs,
-      src: callInfo.callSource
-    })
-    const isDuplicate = this.lastCommandSig === cmdSig
-
-    if (!isDuplicate) {
-      this.commandStack.push({
-        command: methodName,
-        callSource: callInfo.callSource,
-        signature: cmdSig
-      })
-      this.lastCommandSig = cmdSig
+  // After DOM-mutating commands, re-poll mutations from the injected script
+  // so the browser preview stays in sync. setTimeout runs OUTSIDE Nightwatch's
+  // current callback stack (safer queue-wise).
+  private maybeRepollMutations(
+    browser: NightwatchBrowser,
+    methodName: string
+  ): void {
+    const isDomMutating =
+      (NAVIGATION_COMMANDS as readonly string[]).includes(methodName) ||
+      [
+        'click',
+        'doubleClick',
+        'rightClick',
+        'setValue',
+        'clearValue',
+        'sendKeys',
+        'submitForm',
+        'back',
+        'forward',
+        'refresh'
+      ].includes(methodName)
+    if (!isDomMutating) {
+      return
     }
+    setTimeout(() => {
+      this.sessionCapturer.captureTrace(browser).catch(() => {})
+    }, 200)
+  }
 
-    const testAtCallTime = this.getCurrentTest()
-    const testUid = testAtCallTime?.uid
-    const callSource = callInfo.callSource
-    const commandTimestamp = Date.now()
-
-    /**
-     * Result-capturing callback — called by Nightwatch's async queue when the
-     * command completes.  This is where we get the *actual* result value.
-     */
-    const captureCallback = (callbackResult: any) => {
-      const stackFrame = this.commandStack[this.commandStack.length - 1]
-      if (
-        stackFrame?.command === methodName &&
-        stackFrame.signature === cmdSig
-      ) {
-        this.commandStack.pop()
-      }
-
-      const isBooleanCommand = BOOLEAN_COMMAND_PATTERN.test(methodName)
-
-      let serializedResult: any = undefined
-      if (callbackResult !== null && callbackResult !== undefined) {
-        if (typeof callbackResult === 'object' && 'passed' in callbackResult) {
-          // Nightwatch assertion object {passed, actual, expected, message}
-          serializedResult = callbackResult.passed
-            ? true
-            : {
-                passed: false,
-                actual: callbackResult.actual,
-                expected: callbackResult.expected,
-                message: callbackResult.message
-              }
-        } else if (
-          typeof callbackResult === 'object' &&
-          'value' in callbackResult
-        ) {
-          const raw = callbackResult.value
-          // Boolean-semantic command returning null → timed out / not found → false
-          serializedResult = raw === null && isBooleanCommand ? false : raw
-        } else if (typeof callbackResult !== 'function') {
-          try {
-            serializedResult = JSON.parse(JSON.stringify(callbackResult))
-          } catch {
-            serializedResult = String(callbackResult)
-          }
-        }
-      }
-
-      const currentTest = this.getCurrentTest()
-      const effectiveUid = currentTest?.uid ?? testUid
+  private popCommandStackIfMatches(methodName: string, cmdSig: string): void {
+    const stackFrame = this.commandStack[this.commandStack.length - 1]
+    if (stackFrame?.command === methodName && stackFrame.signature === cmdSig) {
+      this.commandStack.pop()
+    }
+  }
 
+  // Result-capturing callback factory — called by Nightwatch's async queue
+  // when the command completes. This is where we get the *actual* result.
+  private makeCaptureCallback(
+    browser: NightwatchBrowser,
+    methodName: string,
+    logArgs: unknown[],
+    cmdSig: string,
+    callSource: string | undefined,
+    commandTimestamp: number,
+    testUid: string | undefined,
+    userCallback: Function | null
+  ): (callbackResult: unknown) => unknown {
+    return (callbackResult: unknown) => {
+      this.popCommandStackIfMatches(methodName, cmdSig)
+      const serializedResult = serializeCommandResult(
+        callbackResult,
+        methodName
+      )
+      const effectiveUid = this.getCurrentTest()?.uid ?? testUid
       if (effectiveUid) {
-        const isRetry =
-          cmdSig === this.lastCapturedSig && this.lastCapturedId !== null
-
-        if (isRetry) {
-          // Same command fired again (internal retry) — replace the previous
-          // entry so only the final result appears in the UI.
-          const { entry, oldTimestamp } = this.sessionCapturer.replaceCommand(
-            this.lastCapturedId!,
+        if (this.retryTracker.isRetry(cmdSig)) {
+          this.handleRetryReplacement(
+            browser,
             methodName,
             logArgs,
             serializedResult,
-            undefined,
             effectiveUid,
             callSource,
             commandTimestamp
           )
-          this.lastCapturedId = entry._id ?? null
-          this.sessionCapturer.sendReplaceCommand(oldTimestamp, entry)
-
-          const entryToScreenshot = entry
-          const ts = (entryToScreenshot as any).timestamp
-          this.sessionCapturer
-            .takeScreenshotViaHttp(browser)
-            .then((screenshot) => {
-              if (screenshot) {
-                ;(entryToScreenshot as any).screenshot = screenshot
-                this.sessionCapturer.sendReplaceCommand(ts, entryToScreenshot)
-                log.info(`[screenshot] Attached to ${methodName} (retry)`)
-              }
-            })
-            .catch(() => {})
         } else {
-          // New command — capture and track.
-          // captureCommand() pushes the entry to commandsLog synchronously
-          // before any async work (navigation perf capture), so we can grab
-          // the ID immediately after the call — before any microtask fires.
-          // This avoids the race where a Nightwatch retry callback executes
-          // before .then() sets lastCapturedId, causing missed dedup.
-          this.lastCapturedSig = cmdSig
-          this.lastCapturedId = null
-          this.sessionCapturer
-            .captureCommand(
-              methodName,
-              logArgs,
-              serializedResult,
-              undefined,
-              effectiveUid,
-              callSource,
-              commandTimestamp
-            )
-            .catch((err: any) =>
-              log.error(`Failed to capture ${methodName}: ${err.message}`)
-            )
-          const lastCommand =
-            this.sessionCapturer.commandsLog[
-              this.sessionCapturer.commandsLog.length - 1
-            ]
-          if (lastCommand) {
-            this.lastCapturedId = (lastCommand as any)._id ?? null
-            this.sessionCapturer.sendCommand(lastCommand)
-            log.info(`[command] ${methodName}`)
-          }
-
-          const entryToScreenshot = lastCommand
-          if (entryToScreenshot) {
-            const ts = (entryToScreenshot as any).timestamp
-            this.sessionCapturer
-              .takeScreenshotViaHttp(browser)
-              .then((screenshot) => {
-                if (screenshot) {
-                  ;(entryToScreenshot as any).screenshot = screenshot
-                  this.sessionCapturer.sendReplaceCommand(ts, entryToScreenshot)
-                  log.info(`[screenshot] Attached to ${methodName}`)
-                }
-              })
-              .catch(() => {})
-          }
-
-          // After DOM-mutating commands, re-poll mutations from the injected
-          // script so the browser preview stays in sync. Use setTimeout to
-          // run OUTSIDE Nightwatch's current callback stack (safer queue-wise).
-          const isDomMutating =
-            (NAVIGATION_COMMANDS as readonly string[]).includes(methodName) ||
-            [
-              'click',
-              'doubleClick',
-              'rightClick',
-              'setValue',
-              'clearValue',
-              'sendKeys',
-              'submitForm',
-              'back',
-              'forward',
-              'refresh'
-            ].includes(methodName)
-          if (isDomMutating) {
-            setTimeout(() => {
-              this.sessionCapturer.captureTrace(browser).catch(() => {})
-            }, 200)
-          }
+          this.captureFreshCommand(
+            browser,
+            methodName,
+            logArgs,
+            serializedResult,
+            effectiveUid,
+            callSource,
+            commandTimestamp,
+            cmdSig
+          )
         }
       }
-
       if (userCallback) {
         return userCallback(callbackResult)
       }
     }
+  }
 
-    const modifiedArgs = [...logArgs, captureCallback]
+  private pushCommandStackIfNew(
+    methodName: string,
+    cmdSig: string,
+    callSource: string | undefined
+  ): void {
+    if (this.lastCommandSig === cmdSig) {
+      return
+    }
+    this.commandStack.push({
+      command: methodName,
+      callSource,
+      signature: cmdSig
+    })
+    this.lastCommandSig = cmdSig
+  }
+
+  private handleCommandExecution(
+    browser: NightwatchBrowser,
+    browserAny: Record<string, unknown>,
+    methodName: string,
+    originalMethod: Function,
+    args: unknown[]
+  ): unknown {
+    this.testManager.startTestIfPending(
+      this.testManager.detectTestBoundary(
+        browserAny.currentTest as NightwatchCurrentTest
+      )
+    )
+
+    const callInfo = getCallSourceFromStack()
+    if (callInfo.filePath && !this.currentTestFullPath) {
+      this.currentTestFullPath = callInfo.filePath
+    }
 
+    const lastArg = args[args.length - 1]
+    const hasUserCallback = typeof lastArg === 'function'
+    const userCallback: Function | null = hasUserCallback ? lastArg : null
+    const logArgs = hasUserCallback ? args.slice(0, -1) : args
+
+    const cmdSig = JSON.stringify({
+      command: methodName,
+      args: logArgs,
+      src: callInfo.callSource
+    })
+    this.pushCommandStackIfNew(methodName, cmdSig, callInfo.callSource)
+
+    const callSource = callInfo.callSource
+    const commandTimestamp = Date.now()
+    const captureCallback = this.makeCaptureCallback(
+      browser,
+      methodName,
+      logArgs,
+      cmdSig,
+      callSource,
+      commandTimestamp,
+      this.getCurrentTest()?.uid,
+      userCallback
+    )
+    const modifiedArgs = [...logArgs, captureCallback]
     try {
-      const result = originalMethod(...modifiedArgs)
-      return result
+      return originalMethod(...modifiedArgs)
     } catch (error) {
-      const stackFrame = this.commandStack[this.commandStack.length - 1]
-      if (
-        stackFrame?.command === methodName &&
-        stackFrame.signature === cmdSig
-      ) {
-        this.commandStack.pop()
-      }
+      this.popCommandStackIfMatches(methodName, cmdSig)
       this.captureCommandError(methodName, logArgs, error, callSource)
       throw error
     }
@@ -383,8 +413,8 @@ export class BrowserProxy {
 
   private captureCommandError(
     methodName: string,
-    args: any[],
-    error: any,
+    args: unknown[],
+    error: unknown,
     callSource: string | undefined
   ): void {
     const currentTest = this.getCurrentTest()
@@ -392,20 +422,20 @@ export class BrowserProxy {
       return
     }
 
-    const errMsg = error instanceof Error ? error.message : String(error)
-    log.error(`[command error] ${methodName}: ${errMsg}`)
+    const normalizedError = toError(error)
+    log.error(`[command error] ${methodName}: ${normalizedError.message}`)
 
     this.sessionCapturer
       .captureCommand(
         methodName,
         args,
         undefined,
-        error instanceof Error ? error : new Error(String(error)),
+        normalizedError,
         currentTest.uid,
         callSource
       )
-      .catch((err: any) =>
-        log.error(`Failed to capture ${methodName}: ${err.message}`)
+      .catch((err) =>
+        log.error(`Failed to capture ${methodName}: ${(err as Error).message}`)
       )
 
     const lastCommand =
@@ -420,4 +450,30 @@ export class BrowserProxy {
   isProxied(browser: NightwatchBrowser): boolean {
     return this.proxiedBrowsers.has(browser as object)
   }
+
+  /**
+   * Fire-and-forget: pull a screenshot via the WebDriver HTTP endpoint and
+   * attach it to an already-captured command entry. The `suffix` is appended
+   * to the log line so retried-command screenshots show `(retry)`. Errors
+   * are silently swallowed — screenshots are best-effort and shouldn't fail
+   * the run.
+   */
+  private attachScreenshot(
+    browser: NightwatchBrowser,
+    entry: { timestamp?: number; screenshot?: string | null },
+    methodName: string,
+    suffix = ''
+  ): void {
+    const ts = entry.timestamp ?? 0
+    this.sessionCapturer
+      .takeScreenshotViaHttp(browser)
+      .then((screenshot) => {
+        if (screenshot) {
+          entry.screenshot = screenshot
+          this.sessionCapturer.sendReplaceCommand(ts, entry as CommandLog)
+          log.info(`[screenshot] Attached to ${methodName}${suffix}`)
+        }
+      })
+      .catch(() => {})
+  }
 }
diff --git a/packages/nightwatch-devtools/src/helpers/capturePerformance.ts b/packages/nightwatch-devtools/src/helpers/capturePerformance.ts
deleted file mode 100644
index 1d50248a..00000000
--- a/packages/nightwatch-devtools/src/helpers/capturePerformance.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Script to capture performance data, cookies, and document info from the browser.
- * Passed as a string to browser.execute() so no browser-context @ts-ignore is needed.
- */
-export const CAPTURE_PERFORMANCE_SCRIPT = `
-    (function() {
-      const performance = window.performance;
-      const navigation = performance.getEntriesByType?.('navigation')?.[0];
-      const resources = performance.getEntriesByType?.('resource') || [];
-
-      return {
-        navigation: navigation ? {
-          url: window.location.href,
-          timing: {
-            loadTime: navigation.loadEventEnd - navigation.fetchStart,
-            domReady: navigation.domContentLoadedEventEnd - navigation.fetchStart,
-            responseTime: navigation.responseEnd - navigation.requestStart,
-            dnsLookup: navigation.domainLookupEnd - navigation.domainLookupStart,
-            tcpConnection: navigation.connectEnd - navigation.connectStart,
-            serverResponse: navigation.responseEnd - navigation.responseStart
-          }
-        } : undefined,
-        resources: resources.map(function(resource) {
-          return {
-            url: resource.name,
-            duration: resource.duration,
-            size: resource.transferSize || 0,
-            type: resource.initiatorType,
-            startTime: resource.startTime,
-            responseEnd: resource.responseEnd
-          };
-        }),
-        cookies: (function() {
-          try { return document.cookie; } catch (e) { return ''; }
-        })(),
-        documentInfo: {
-          url: window.location.href,
-          title: document.title,
-          headers: {
-            userAgent: navigator.userAgent,
-            language: navigator.language,
-            platform: navigator.platform
-          },
-          documentInfo: {
-            readyState: document.readyState,
-            referrer: document.referrer,
-            characterSet: document.characterSet
-          }
-        }
-      };
-    })()
-  `
diff --git a/packages/nightwatch-devtools/src/helpers/closePreviousTest.ts b/packages/nightwatch-devtools/src/helpers/closePreviousTest.ts
new file mode 100644
index 00000000..1df57865
--- /dev/null
+++ b/packages/nightwatch-devtools/src/helpers/closePreviousTest.ts
@@ -0,0 +1,72 @@
+import logger from '@wdio/logger'
+import { TIMING, TEST_STATE } from '../constants.js'
+import type { NightwatchTestCase, TestStats } from '../types.js'
+import { determineTestState } from './utils.js'
+import type { TestManager } from './testManager.js'
+
+const log = logger('@wdio/nightwatch-devtools:closePreviousTest')
+
+export interface ClosePreviousTestInput {
+  runningTest: TestStats
+  testFile: string
+  /** `currentTest?.results?.testcases || {}` — Nightwatch's per-suite testcase results. */
+  testcases: Record<string, NightwatchTestCase>
+  testManager: TestManager
+  /** Plugin-side pass/fail/skip counter — called once with the resolved final state. */
+  incrementCount: (state: TestStats['state']) => void
+  /** Plugin-side icon resolver for the log line (✅/❌/⏭ etc.). */
+  testIcon: (state: TestStats['state']) => string
+}
+
+/**
+ * Close out the previously-running test when beforeEach fires for the next
+ * one. Resolves the final state from Nightwatch's testcases bag if available
+ * (preferred — has real timing), otherwise assumes PASSED (the runner only
+ * advances to beforeEach if the prior test didn't throw). Returns nothing —
+ * pure side-effect orchestration over the test, testManager, and the plugin's
+ * counter / icon helpers.
+ *
+ * Extracted from `NightwatchDevToolsPlugin.beforeEach` — the ~37-line block
+ * was the second-densest section of the 142-line method.
+ */
+export async function closePreviousTest(
+  input: ClosePreviousTestInput
+): Promise<void> {
+  const {
+    runningTest,
+    testFile,
+    testcases,
+    testManager,
+    incrementCount,
+    testIcon
+  } = input
+
+  if (testcases[runningTest.title]) {
+    const testcase = testcases[runningTest.title]
+    const testState = determineTestState(testcase)
+    runningTest.state = testState
+    runningTest.end = new Date()
+    runningTest._duration = parseFloat(testcase.time || '0') * 1000
+    testManager.updateTestState(runningTest, testState)
+    testManager.markTestAsProcessed(testFile, runningTest.title)
+    incrementCount(testState)
+    log.info(
+      `  ${testIcon(testState)} ${runningTest.title} (${(runningTest._duration / 1000).toFixed(2)}s)`
+    )
+  } else {
+    const endTime = new Date()
+    const duration = endTime.getTime() - (runningTest.start?.getTime() || 0)
+    testManager.updateTestState(
+      runningTest,
+      TEST_STATE.PASSED as TestStats['state'],
+      endTime,
+      duration
+    )
+    testManager.markTestAsProcessed(testFile, runningTest.title)
+    incrementCount(TEST_STATE.PASSED as TestStats['state'])
+    log.info(`  ✅ ${runningTest.title} (${(duration / 1000).toFixed(2)}s)`)
+  }
+  // Brief settle so the dashboard renders the terminal state before the next
+  // test's "running" update arrives.
+  await new Promise((resolve) => setTimeout(resolve, TIMING.UI_RENDER_DELAY))
+}
diff --git a/packages/nightwatch-devtools/src/helpers/cucumberHooks.cts b/packages/nightwatch-devtools/src/helpers/cucumberHooks.cts
index 2465ba7b..12b379df 100644
--- a/packages/nightwatch-devtools/src/helpers/cucumberHooks.cts
+++ b/packages/nightwatch-devtools/src/helpers/cucumberHooks.cts
@@ -48,28 +48,28 @@ interface CucumberPluginBridge {
 }
 
 Before({ order: 1000 }, async function (this: any, { pickle }: any) {
-  const plugin = (globalThis as any)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
+  const plugin = (globalThis as Record<string, unknown>)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
   if (this.browser && plugin) {
     await plugin.cucumberBefore(this.browser, pickle)
   }
 })
 
 After({ order: -1 }, async function (this: any, { result, pickle }: any) {
-  const plugin = (globalThis as any)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
+  const plugin = (globalThis as Record<string, unknown>)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
   if (this.browser && plugin) {
     await plugin.cucumberAfter(this.browser, result, pickle)
   }
 })
 
 BeforeStep({ order: 1000 }, async function (this: any, { pickleStep, pickle }: any) {
-  const plugin = (globalThis as any)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
+  const plugin = (globalThis as Record<string, unknown>)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
   if (this.browser && plugin) {
     await plugin.cucumberBeforeStep(this.browser, pickleStep, pickle)
   }
 })
 
 AfterStep({ order: 1000 }, async function (this: any, { result, pickleStep, pickle }: any) {
-  const plugin = (globalThis as any)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
+  const plugin = (globalThis as Record<string, unknown>)[PLUGIN_GLOBAL_KEY] as CucumberPluginBridge | undefined
   if (this.browser && plugin) {
     await plugin.cucumberAfterStep(this.browser, result, pickleStep, pickle)
   }
diff --git a/packages/nightwatch-devtools/src/helpers/cucumberResult.ts b/packages/nightwatch-devtools/src/helpers/cucumberResult.ts
new file mode 100644
index 00000000..a9d81934
--- /dev/null
+++ b/packages/nightwatch-devtools/src/helpers/cucumberResult.ts
@@ -0,0 +1,48 @@
+import { TEST_STATE } from '../constants.js'
+import type { SuiteStats, TestStats } from '../types.js'
+
+/**
+ * Map a Cucumber Pickle step result's `status` field (PASSED/FAILED/SKIPPED/
+ * UNKNOWN/PENDING/AMBIGUOUS/UNDEFINED) to the dashboard's TestStats state.
+ * Everything non-passed and non-skipped is treated as FAILED for the UI —
+ * the underlying error/message survives in the pickle for the Compare view.
+ */
+export function cucumberResultToTestState(result: unknown): TestStats['state'] {
+  const status = String(
+    (result as { status?: unknown })?.status ?? 'UNKNOWN'
+  ).toUpperCase()
+  if (status === 'PASSED') {
+    return TEST_STATE.PASSED
+  }
+  if (status === 'SKIPPED') {
+    return TEST_STATE.SKIPPED
+  }
+  return TEST_STATE.FAILED
+}
+
+/**
+ * Cucumber's After hook fires with the scenario's final status, but any
+ * still-running or pending steps (e.g. an early failure short-circuited
+ * the rest) need to be closed too. Mark them PASSED only when the whole
+ * scenario passed; FAILED otherwise. Pure in-place mutation — the suite's
+ * `tests` array references are the same TestStats objects the dashboard
+ * already received via earlier WS broadcasts.
+ */
+export function closeOpenSteps(
+  suite: SuiteStats,
+  scenarioState: TestStats['state'],
+  now: Date = new Date()
+): void {
+  for (const step of suite.tests) {
+    if (typeof step === 'string') {
+      continue
+    }
+    if (step.state === 'running' || step.state === 'pending') {
+      step.state =
+        scenarioState === TEST_STATE.PASSED
+          ? TEST_STATE.PASSED
+          : TEST_STATE.FAILED
+      step.end = now
+    }
+  }
+}
diff --git a/packages/nightwatch-devtools/src/helpers/cucumberScenarioBuilder.ts b/packages/nightwatch-devtools/src/helpers/cucumberScenarioBuilder.ts
new file mode 100644
index 00000000..9ea426e9
--- /dev/null
+++ b/packages/nightwatch-devtools/src/helpers/cucumberScenarioBuilder.ts
@@ -0,0 +1,116 @@
+import { DEFAULTS, TEST_STATE } from '../constants.js'
+import type { SuiteStats } from '../types.js'
+import { deterministicUid, findStepDefinitionLine } from './utils.js'
+
+export interface CucumberScenarioBuildInput {
+  /** Cucumber pickle URI — the .feature path. */
+  featureUri: string
+  scenarioName: string
+  featureName: string
+  /** Absolute file path used for callSource resolution (may be unresolved). */
+  featureAbsPath?: string
+  /** Step-definition files discovered for the feature (passed to find each step's source location). */
+  stepDefFiles: Array<{ filePath: string; content: string }>
+  /** Pickle steps as parsed by Cucumber. */
+  steps: Array<{ text: string }>
+  /** Per-step source line numbers from the .feature file (parsed once by the caller). */
+  stepLines: number[]
+  /** Per-step Gherkin keywords (Given/When/Then/And/But) parsed alongside `stepLines`. */
+  stepKeywords: string[]
+  /** Scenario header line number in the .feature file (0 if unresolvable). */
+  scenarioLine: number
+  /** Parent feature-suite uid — scenarios nest under this. */
+  parentFeatureSuiteUid: string
+}
+
+/**
+ * Build a fully-populated scenario sub-suite (with its `tests` array of step
+ * TestStats entries) for one Cucumber scenario. Pure factory — no side effects;
+ * the caller decides whether to push into the feature suite or replace an
+ * existing entry (retry case).
+ *
+ * Extracted from `NightwatchDevToolsPlugin.#initCucumberScenario` — the
+ * scenario+steps construction was ~70 lines of object-literal building that
+ * doesn't touch plugin state.
+ */
+function buildScenarioStepTest(
+  input: CucumberScenarioBuildInput,
+  scenarioUid: string,
+  i: number
+): SuiteStats['tests'][number] {
+  const {
+    featureUri,
+    scenarioName,
+    featureAbsPath,
+    stepDefFiles,
+    steps,
+    stepLines,
+    stepKeywords
+  } = input
+  const step = steps[i]
+  const keyword = stepKeywords[i] || ''
+  const stepLabel = keyword ? `${keyword} ${step.text}` : step.text
+  const stepDefLoc = findStepDefinitionLine(stepDefFiles, step.text)
+  const callSource = stepDefLoc
+    ? `${stepDefLoc.filePath}:${stepDefLoc.line}`
+    : featureAbsPath && stepLines[i] > 0
+      ? `${featureAbsPath}:${stepLines[i]}`
+      : undefined
+  return {
+    uid: deterministicUid(featureUri, `step:${scenarioName}:${step.text}`),
+    cid: DEFAULTS.CID,
+    title: stepLabel,
+    fullTitle: `${scenarioName} ${stepLabel}`,
+    parent: scenarioUid,
+    state: TEST_STATE.PENDING,
+    start: new Date(),
+    end: null,
+    type: 'test' as const,
+    file: featureUri,
+    retries: 0,
+    _duration: 0,
+    hooks: [],
+    callSource
+  }
+}
+
+export function buildCucumberScenarioSuite(
+  input: CucumberScenarioBuildInput
+): SuiteStats {
+  const {
+    featureUri,
+    scenarioName,
+    featureName,
+    featureAbsPath,
+    steps,
+    scenarioLine,
+    parentFeatureSuiteUid
+  } = input
+  // deterministicUid (no counter) so the SAME scenario gets the SAME uid
+  // across retries — that's what makes retry-coalescing work upstream.
+  const scenarioUid = deterministicUid(featureUri, `scenario:${scenarioName}`)
+  const scenarioSuite: SuiteStats = {
+    uid: scenarioUid,
+    cid: DEFAULTS.CID,
+    title: scenarioName,
+    fullTitle: `${featureName} ${scenarioName}`,
+    parent: parentFeatureSuiteUid,
+    type: 'suite' as const,
+    file: featureUri,
+    start: new Date(),
+    state: TEST_STATE.RUNNING,
+    end: null,
+    tests: [],
+    suites: [],
+    hooks: [],
+    _duration: 0,
+    callSource:
+      featureAbsPath && scenarioLine > 0
+        ? `${featureAbsPath}:${scenarioLine}`
+        : undefined
+  }
+  for (let i = 0; i < steps.length; i++) {
+    scenarioSuite.tests.push(buildScenarioStepTest(input, scenarioUid, i))
+  }
+  return scenarioSuite
+}
diff --git a/packages/nightwatch-devtools/src/helpers/featureFileScan.ts b/packages/nightwatch-devtools/src/helpers/featureFileScan.ts
new file mode 100644
index 00000000..b00fbbd5
--- /dev/null
+++ b/packages/nightwatch-devtools/src/helpers/featureFileScan.ts
@@ -0,0 +1,69 @@
+import fs from 'fs'
+import path from 'node:path'
+
+export interface FeatureFileScan {
+  /** Header `Feature:` value, or the filename basename if unreadable. */
+  featureName: string
+  /** Raw `.feature` file contents (empty when unreadable). */
+  featureContent: string
+  /** Absolute path to the `.feature` file (resolved from cwd + uri). */
+  featureAbsPath: string
+  /** Sibling step-definition files (under `step_definitions`/`steps`/`support`). */
+  stepDefFiles: Array<{ filePath: string; content: string }>
+  /** Paths the caller should feed to `sessionCapturer.captureSource` so the
+   *  dashboard's Source panel can render them. */
+  capturedPaths: string[]
+}
+
+/**
+ * Scan a Cucumber feature file and its sibling step-definitions. Pure I/O —
+ * the caller invokes `sessionCapturer.captureSource` for each path in
+ * `capturedPaths` so this helper stays free of the session capturer.
+ */
+export function scanFeatureFile(featureUri: string): FeatureFileScan {
+  const featureAbsPath = path.resolve(process.cwd(), featureUri)
+  const result: FeatureFileScan = {
+    featureName: path.basename(featureUri, '.feature'),
+    featureContent: '',
+    featureAbsPath,
+    stepDefFiles: [],
+    capturedPaths: []
+  }
+
+  if (featureUri === 'unknown.feature' || !fs.existsSync(featureAbsPath)) {
+    return result
+  }
+
+  result.featureContent = fs.readFileSync(featureAbsPath, 'utf-8')
+  const match = result.featureContent.match(/^\s*Feature:\s*(.+)/m)
+  if (match) {
+    result.featureName = match[1].trim()
+  }
+  result.capturedPaths.push(featureAbsPath)
+
+  const featureDir = path.dirname(featureAbsPath)
+  const stepDirCandidates = ['step_definitions', 'steps', 'support']
+  for (const candidate of stepDirCandidates) {
+    const stepDir = path.join(featureDir, candidate)
+    if (!fs.existsSync(stepDir) || !fs.statSync(stepDir).isDirectory()) {
+      continue
+    }
+    for (const entry of fs.readdirSync(stepDir)) {
+      if (!/\.(js|ts|mjs|cjs)$/.test(entry)) {
+        continue
+      }
+      const stepFilePath = path.join(stepDir, entry)
+      result.capturedPaths.push(stepFilePath)
+      try {
+        result.stepDefFiles.push({
+          filePath: stepFilePath,
+          content: fs.readFileSync(stepFilePath, 'utf-8')
+        })
+      } catch {
+        // skip unreadable files
+      }
+    }
+  }
+
+  return result
+}
diff --git a/packages/nightwatch-devtools/src/helpers/perfLogs.ts b/packages/nightwatch-devtools/src/helpers/perfLogs.ts
new file mode 100644
index 00000000..9987dce5
--- /dev/null
+++ b/packages/nightwatch-devtools/src/helpers/perfLogs.ts
@@ -0,0 +1,210 @@
+import { getRequestType } from './utils.js'
+
+/**
+ * Pure parsers for Chrome's `performance` log (the format `browser.getLog('performance')`
+ * returns). Separated from the SessionCapturer so they're testable and the
+ * capture method stays focused on state + I/O.
+ */
+
+export interface PerfLogEntry {
+  level: string
+  message: string
+  timestamp: number
+}
+
+export interface NetworkEntry {
+  id: string
+  url: string
+  method: string
+  requestHeaders: Record<string, string>
+  timestamp: number
+  startTime: number
+  status?: number
+  statusText?: string
+  responseHeaders?: Record<string, string>
+  mimeType?: string
+  type?: string
+  size?: number
+  endTime?: number
+  time?: number
+  error?: string
+}
+
+/**
+ * Parse CDP `Network.*` events out of Chrome performance log entries into a
+ * flat array of network entries. Builds up a per-requestId pending map as it
+ * sees `requestWillBeSent` → `responseReceived` → `loadingFinished` events,
+ * and emits the completed entry on the terminal event.
+ */
+interface CdpResponse {
+  status?: number
+  statusText?: string
+  headers?: Record<string, unknown>
+  mimeType?: string
+}
+
+interface CdpRequest {
+  url: string
+  method: string
+  headers?: Record<string, string>
+}
+
+interface CdpEventParams {
+  requestId: string
+  request?: CdpRequest
+  response?: CdpResponse
+  timestamp?: number
+  encodedDataLength?: number
+  errorText?: string
+}
+
+function applyResponseReceived(p: NetworkEntry, response: CdpResponse): void {
+  const responseHeaders: Record<string, string> = {}
+  for (const [k, v] of Object.entries(response.headers || {})) {
+    responseHeaders[k.toLowerCase()] = String(v)
+  }
+  p.status = response.status
+  p.statusText = response.statusText
+  p.responseHeaders = responseHeaders
+  p.mimeType = response.mimeType
+  p.type = getRequestType(p.url, response.mimeType)
+}
+
+function startPendingRequest(
+  params: CdpEventParams,
+  entry: PerfLogEntry,
+  pending: Map<string, NetworkEntry>
+): void {
+  const { requestId, request: req, timestamp } = params
+  if (!req || typeof timestamp !== 'number') {
+    return
+  }
+  pending.set(requestId, {
+    id: `${entry.timestamp}-${requestId}`,
+    url: req.url,
+    method: req.method,
+    requestHeaders: req.headers ?? {},
+    timestamp: Math.round(timestamp * 1000),
+    startTime: entry.timestamp
+  })
+}
+
+function handlePerfLogEvent(
+  method: string,
+  params: CdpEventParams,
+  entry: PerfLogEntry,
+  pending: Map<string, NetworkEntry>,
+  completed: NetworkEntry[]
+): void {
+  if (method === 'Network.requestWillBeSent') {
+    startPendingRequest(params, entry, pending)
+    return
+  }
+  if (method === 'Network.responseReceived') {
+    const p = pending.get(params.requestId)
+    if (p && params.response) {
+      applyResponseReceived(p, params.response)
+    }
+    return
+  }
+  if (method === 'Network.loadingFinished') {
+    const p = pending.get(params.requestId)
+    if (p && p.status !== undefined) {
+      p.size = params.encodedDataLength
+      p.endTime = entry.timestamp
+      p.time = entry.timestamp - p.startTime
+      completed.push({ ...p })
+      pending.delete(params.requestId)
+    }
+    return
+  }
+  if (method === 'Network.loadingFailed') {
+    const p = pending.get(params.requestId)
+    if (p) {
+      p.error = params.errorText
+      p.endTime = entry.timestamp
+      p.time = entry.timestamp - p.startTime
+      completed.push({ ...p })
+      pending.delete(params.requestId)
+    }
+  }
+}
+
+export function parseNetworkFromPerfLogs(logs: PerfLogEntry[]): NetworkEntry[] {
+  const pending = new Map<string, NetworkEntry>()
+  const completed: NetworkEntry[] = []
+  for (const entry of logs) {
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(entry.message)
+    } catch {
+      continue
+    }
+    type ParsedShape = {
+      message?: { method?: string; params?: CdpEventParams }
+    }
+    const message = (parsed as ParsedShape | undefined)?.message
+    const method = message?.method
+    const params = message?.params
+    if (!method || !params) {
+      continue
+    }
+    handlePerfLogEvent(method, params, entry, pending, completed)
+  }
+  return completed
+}
+
+/**
+ * Dedupe incoming network entries against ones the session already holds.
+ * Successful requests dedupe by (method, url, timestamp). Failed requests
+ * collapse by (method, origin, pathname) — parallel autocomplete/prefetch
+ * requests to the same path (e.g. `/search?q=W`, `/search?q=We`) otherwise
+ * spam the network panel.
+ */
+export function dedupeNetworkRequests(
+  incoming: NetworkEntry[],
+  existing: NetworkEntry[]
+): NetworkEntry[] {
+  const failedKey = (entry: NetworkEntry): string => {
+    try {
+      const u = new URL(entry.url)
+      return `err:${entry.method}:${u.origin}${u.pathname}`
+    } catch {
+      return `err:${entry.method}:${entry.url}`
+    }
+  }
+
+  const alreadySeen = new Set(
+    existing.map((r) =>
+      r.error !== undefined
+        ? failedKey(r)
+        : `ok:${r.method}:${r.url}:${r.timestamp}`
+    )
+  )
+
+  const deduped: NetworkEntry[] = []
+  const seenFailedInBatch = new Map<string, number>()
+
+  for (const entry of incoming) {
+    if (entry.error !== undefined) {
+      const key = failedKey(entry)
+      if (alreadySeen.has(key)) {
+        continue
+      }
+      const existingIdx = seenFailedInBatch.get(key)
+      if (existingIdx !== undefined) {
+        deduped[existingIdx] = entry // replace with latest failure
+      } else {
+        seenFailedInBatch.set(key, deduped.length)
+        deduped.push(entry)
+      }
+    } else {
+      const key = `ok:${entry.method}:${entry.url}:${entry.timestamp}`
+      if (!alreadySeen.has(key)) {
+        deduped.push(entry)
+      }
+    }
+  }
+
+  return deduped
+}
diff --git a/packages/nightwatch-devtools/src/helpers/serializeCommandResult.ts b/packages/nightwatch-devtools/src/helpers/serializeCommandResult.ts
new file mode 100644
index 00000000..be66721a
--- /dev/null
+++ b/packages/nightwatch-devtools/src/helpers/serializeCommandResult.ts
@@ -0,0 +1,57 @@
+import { BOOLEAN_COMMAND_PATTERN } from '../constants.js'
+
+/**
+ * Convert the raw value Nightwatch's async queue hands back to a
+ * UI-friendly JSON-safe representation. Three special cases:
+ *
+ *  - Nightwatch assertion objects `{ passed, actual, expected, message }`
+ *    collapse to `true` on pass, or the structured failure record on fail.
+ *  - Driver-result wrappers `{ value: <raw> }` unwrap to the inner value.
+ *    `null` on a boolean-semantic command (e.g. `waitForExist`) means
+ *    "timed out / not found" — coerce to `false` so the UI doesn't render
+ *    `null`.
+ *  - Plain objects are deep-cloned via JSON.parse/stringify so the UI can
+ *    safely serialize them; functions and circular references fall back to
+ *    `String(value)`.
+ */
+export function serializeCommandResult(
+  callbackResult: unknown,
+  methodName: string
+): unknown {
+  if (callbackResult === null || callbackResult === undefined) {
+    return undefined
+  }
+
+  const isBooleanCommand = BOOLEAN_COMMAND_PATTERN.test(methodName)
+
+  // After the typeof + null guard above, the value is a non-null object —
+  // safe to widen via `Record<string, unknown>` and probe for the discriminator
+  // properties without per-access `as any`.
+  if (typeof callbackResult === 'object') {
+    const r = callbackResult as Record<string, unknown>
+    if ('passed' in r) {
+      return r.passed
+        ? true
+        : {
+            passed: false,
+            actual: r.actual,
+            expected: r.expected,
+            message: r.message
+          }
+    }
+    if ('value' in r) {
+      const raw = r.value
+      return raw === null && isBooleanCommand ? false : raw
+    }
+  }
+
+  if (typeof callbackResult !== 'function') {
+    try {
+      return JSON.parse(JSON.stringify(callbackResult))
+    } catch {
+      return String(callbackResult)
+    }
+  }
+
+  return undefined
+}
diff --git a/packages/nightwatch-devtools/src/helpers/specFileResolver.ts b/packages/nightwatch-devtools/src/helpers/specFileResolver.ts
new file mode 100644
index 00000000..38363781
--- /dev/null
+++ b/packages/nightwatch-devtools/src/helpers/specFileResolver.ts
@@ -0,0 +1,72 @@
+import fs from 'fs'
+import path from 'node:path'
+import { findTestFileFromStack } from './utils.js'
+
+/**
+ * Resolve a Nightwatch test's `currentTest.module` to an absolute spec-file
+ * path on disk. Priority:
+ *   1. Walk the runtime stack for a user frame.
+ *   2. A cached path from a previous command on the same browser (browserProxy).
+ *   3. Cartesian search across the user's `src_folders` + cwd fallbacks.
+ *
+ * Used by `beforeEach` to find the file that `extractTestMetadata` should
+ * parse for test names + suite/test line numbers. Returns `null` when the
+ * file can't be located on disk (source view falls back to "unavailable").
+ */
+export function resolveSpecFilePath(
+  testFile: string,
+  modulePath: string | undefined,
+  srcFolders: string[],
+  cachedPath: string | undefined
+): string | null {
+  let fullPath: string | null = findTestFileFromStack() || null
+  if (!fullPath && cachedPath && cachedPath.includes(testFile)) {
+    fullPath = cachedPath
+  }
+  if (fullPath) {
+    return fullPath
+  }
+  if (!testFile) {
+    return null
+  }
+
+  const workspaceRoot = process.cwd()
+  // `currentTest.module` is relative to a src_folder, e.g. `basic/ecosia`.
+  // We try each src_folder + cwd-level fallback. Use `path.resolve` (not
+  // `path.join`) so absolute src_folders entries — like
+  // `path.resolve(__dirname, 'tests')` from a nightwatch.conf.cjs living
+  // outside the package — bypass `workspaceRoot` correctly.
+  const normalized = (modulePath || '').replace(/\\/g, '/')
+  const srcFolderPaths = srcFolders.flatMap((sf) =>
+    normalized
+      ? [
+          path.resolve(workspaceRoot, sf, normalized + '.js'),
+          path.resolve(workspaceRoot, sf, normalized + '.ts'),
+          path.resolve(workspaceRoot, sf, normalized + '.cjs'),
+          path.resolve(workspaceRoot, sf, normalized)
+        ]
+      : []
+  )
+  const possiblePaths = [
+    ...srcFolderPaths,
+    // Treat module path as relative to cwd (works when src_folders isn't nested)
+    ...(normalized
+      ? [
+          path.resolve(workspaceRoot, normalized + '.js'),
+          path.resolve(workspaceRoot, normalized + '.ts'),
+          path.resolve(workspaceRoot, normalized + '.cjs'),
+          path.resolve(workspaceRoot, normalized)
+        ]
+      : []),
+    path.resolve(workspaceRoot, 'tests', testFile + '.js'),
+    path.resolve(workspaceRoot, 'test', testFile + '.js'),
+    path.resolve(workspaceRoot, testFile + '.js')
+  ]
+
+  for (const candidate of possiblePaths) {
+    if (fs.existsSync(candidate)) {
+      return candidate
+    }
+  }
+  return null
+}
diff --git a/packages/nightwatch-devtools/src/helpers/suiteManager.ts b/packages/nightwatch-devtools/src/helpers/suiteManager.ts
index 7ab76157..338df1ef 100644
--- a/packages/nightwatch-devtools/src/helpers/suiteManager.ts
+++ b/packages/nightwatch-devtools/src/helpers/suiteManager.ts
@@ -1,8 +1,18 @@
 /**
- * Suite Manager
- * Handles test suite creation and management
+ * Suite Manager — Nightwatch flavor.
+ * Maintains one suite per test file (Nightwatch runs each file independently).
+ * Shares the suite factory + state-computation logic with selenium via
+ * @wdio/devtools-core's suite-helpers; the storage strategy (Map by file)
+ * is Nightwatch-specific and stays here.
  */
 
+import {
+  computeSuiteFinalStateStrict,
+  computeSuiteRunningState,
+  createSuiteStats,
+  createTestStats,
+  stampSuiteEnd
+} from '@wdio/devtools-core'
 import { DEFAULTS, TEST_STATE } from '../constants.js'
 import type { SuiteStats, TestStats } from '../types.js'
 import type { TestReporter } from '../reporter.js'
@@ -33,53 +43,34 @@ export class SuiteManager {
     testLines?: number[]
   ): SuiteStats {
     if (!this.currentSuiteByFile.has(testFile)) {
-      const suiteStats: SuiteStats = {
-        uid: '',
+      const file = fullPath || testFile
+      const suiteStats = createSuiteStats({
+        uid: generateStableUid(file, suiteTitle),
         cid: DEFAULTS.CID,
         title: suiteTitle,
-        fullTitle: suiteTitle,
-        file: fullPath || testFile,
-        type: 'suite' as const,
-        start: new Date(),
-        state: TEST_STATE.PENDING,
-        end: null,
-        tests: [],
-        suites: [],
-        hooks: [],
-        _duration: DEFAULTS.DURATION,
+        file,
+        state: TEST_STATE.PENDING as TestStats['state'],
         callSource:
           suiteLine && fullPath ? `${fullPath}:${suiteLine}` : undefined
-      }
-
-      suiteStats.uid = generateStableUid(suiteStats.file, suiteStats.title)
+      })
 
       // Create test entries with pending state
-      if (testNames.length > 0) {
-        for (let idx = 0; idx < testNames.length; idx++) {
-          const testName = testNames[idx]
-          const testLine = testLines?.[idx]
-          const fullTitle = `${suiteTitle} ${testName}`
-          const testUid = generateStableUid(fullPath || testFile, fullTitle)
-          const testEntry: TestStats = {
-            uid: testUid,
-            cid: DEFAULTS.CID,
-            title: testName,
-            fullTitle: fullTitle,
-            parent: suiteStats.uid,
-            state: TEST_STATE.PENDING as TestStats['state'],
-            start: new Date(),
-            end: null,
-            type: 'test' as const,
-            file: fullPath || testFile,
-            retries: DEFAULTS.RETRIES,
-            _duration: DEFAULTS.DURATION,
-            hooks: [],
-            callSource:
-              testLine && fullPath ? `${fullPath}:${testLine}` : undefined
-          }
-          suiteStats.tests.push(testEntry)
-        }
-        // Don't send updates here - onSuiteStart will send it
+      for (let idx = 0; idx < testNames.length; idx++) {
+        const testName = testNames[idx]
+        const testLine = testLines?.[idx]
+        const fullTitle = `${suiteTitle} ${testName}`
+        const testEntry = createTestStats({
+          uid: generateStableUid(file, fullTitle),
+          cid: DEFAULTS.CID,
+          title: testName,
+          fullTitle,
+          file,
+          parent: suiteStats.uid,
+          state: TEST_STATE.PENDING as TestStats['state'],
+          callSource:
+            testLine && fullPath ? `${fullPath}:${testLine}` : undefined
+        })
+        suiteStats.tests.push(testEntry)
       }
 
       this.currentSuiteByFile.set(testFile, suiteStats)
@@ -112,17 +103,7 @@ export class SuiteManager {
    * Used during Cucumber runs to keep the feature-level suite state fresh.
    */
   finalizeSuiteState(suite: SuiteStats): void {
-    const hasFailures =
-      suite.tests.some((t: any) => t.state === TEST_STATE.FAILED) ||
-      suite.suites.some((s) => s.state === TEST_STATE.FAILED)
-    const hasRunning =
-      suite.tests.some((t: any) => t.state === TEST_STATE.RUNNING) ||
-      suite.suites.some((s) => s.state === TEST_STATE.RUNNING || !s.end)
-    suite.state = hasFailures
-      ? TEST_STATE.FAILED
-      : hasRunning
-        ? TEST_STATE.RUNNING
-        : TEST_STATE.PASSED
+    suite.state = computeSuiteRunningState(suite)
     this.testReporter.updateSuites()
   }
 
@@ -132,38 +113,9 @@ export class SuiteManager {
   finalizeSuite(suite: SuiteStats): void {
     if (suite.end) {
       return
-    } // Already finalized
-
-    suite.end = new Date()
-    suite._duration = suite.end.getTime() - (suite.start?.getTime() || 0)
-
-    // Check direct tests
-    const hasFailures =
-      suite.tests.some((t: any) => t.state === TEST_STATE.FAILED) ||
-      suite.suites.some((s) => s.state === TEST_STATE.FAILED)
-    const allPassed =
-      suite.tests.every(
-        (t: any) =>
-          t.state === TEST_STATE.PASSED || t.state === TEST_STATE.SKIPPED
-      ) &&
-      suite.suites.every(
-        (s) => s.state === TEST_STATE.PASSED || s.state === TEST_STATE.SKIPPED
-      )
-    const hasSkipped = suite.tests.some(
-      (t: any) => t.state === TEST_STATE.SKIPPED
-    )
-    const hasItems = suite.tests.length > 0 || suite.suites.length > 0
-
-    if (hasFailures) {
-      suite.state = TEST_STATE.FAILED
-    } else if (!hasItems || allPassed) {
-      suite.state = TEST_STATE.PASSED
-    } else if (hasSkipped) {
-      suite.state = TEST_STATE.PASSED
-    } else {
-      suite.state = TEST_STATE.FAILED
     }
-
+    stampSuiteEnd(suite)
+    suite.state = computeSuiteFinalStateStrict(suite)
     this.testReporter.onSuiteEnd(suite)
   }
 
diff --git a/packages/nightwatch-devtools/src/helpers/testManager.ts b/packages/nightwatch-devtools/src/helpers/testManager.ts
index 4745f0bb..0edc5ead 100644
--- a/packages/nightwatch-devtools/src/helpers/testManager.ts
+++ b/packages/nightwatch-devtools/src/helpers/testManager.ts
@@ -1,7 +1,9 @@
+import { stampTestEnd } from '@wdio/devtools-core'
 import { TEST_STATE, DEFAULTS } from '../constants.js'
 import {
   type TestStats,
   type SuiteStats,
+  type NightwatchCurrentTest,
   type NightwatchTestCase
 } from '../types.js'
 import { determineTestState } from './utils.js'
@@ -80,7 +82,7 @@ export class TestManager {
    * Detect test boundary and finalize previous test if needed
    * Returns the current test name
    */
-  detectTestBoundary(currentNightwatchTest: any): string {
+  detectTestBoundary(currentNightwatchTest: NightwatchCurrentTest): string {
     const currentTestName = currentNightwatchTest?.name || DEFAULTS.TEST_NAME
 
     // If test name changed, finalize previous test
@@ -155,12 +157,15 @@ export class TestManager {
     suite: SuiteStats,
     testcases: Record<string, NightwatchTestCase>
   ): void {
-    suite.tests.forEach((test: any) => {
+    suite.tests.forEach((entry) => {
+      if (typeof entry === 'string') {
+        return
+      }
+      const test = entry
       if (test.state === TEST_STATE.RUNNING && test.start) {
         // Test was started but never finished - assume passed
         test.state = TEST_STATE.PASSED
-        test.end = new Date()
-        test._duration = test.end.getTime() - (test.start?.getTime() || 0)
+        stampTestEnd(test)
         this.updateTestState(test, TEST_STATE.PASSED as TestStats['state'])
       } else if (test.state === TEST_STATE.PENDING) {
         const testcase = testcases[test.title]
diff --git a/packages/nightwatch-devtools/src/helpers/utils.ts b/packages/nightwatch-devtools/src/helpers/utils.ts
index cc6a408d..0110234a 100644
--- a/packages/nightwatch-devtools/src/helpers/utils.ts
+++ b/packages/nightwatch-devtools/src/helpers/utils.ts
@@ -1,22 +1,29 @@
 import * as fs from 'node:fs'
-import * as net from 'node:net'
 import * as path from 'node:path'
 import { parse as parseStackTrace } from 'stacktrace-parser'
-import logger from '@wdio/logger'
 import {
-  ANSI_REGEX,
-  LOG_LEVEL_PATTERNS,
-  TEST_FILE_PATTERN,
-  CONFIG_FILENAMES
-} from '../constants.js'
+  findTestDefinitions,
+  generateStableUid as generateStableUidByFileName,
+  isUserCodeFrame,
+  normalizeFilePath
+} from '@wdio/devtools-core'
+import { TEST_FILE_PATTERN, CONFIG_FILENAMES } from '../constants.js'
 import type {
-  ConsoleLog,
-  LogLevel,
   NightwatchTestCase,
   TestFileMetadata,
-  StepLocation
+  StepLocation,
+  TestStats
 } from '../types.js'
 
+// These three are pure re-exports — adapters use the core implementations
+// directly, no wrapper logic. Single-line re-exports keep the indirection
+// visible without introducing dummy variables.
+export {
+  deterministicUid,
+  getCallSourceFromStack,
+  resetSignatureCounters
+} from '@wdio/devtools-core'
+
 export function determineTestState(
   testcase: NightwatchTestCase
 ): 'passed' | 'failed' | 'skipped' {
@@ -26,14 +33,50 @@ export function determineTestState(
   return testcase.passed > 0 && testcase.failed === 0 ? 'passed' : 'failed'
 }
 
-// Track test occurrences to generate stable UIDs
-const signatureCounters = new Map<string, number>()
+export function getTestIcon(state: TestStats['state']): string {
+  return state === 'passed' ? '✅' : state === 'skipped' ? '⏭' : '❌'
+}
+
+export function incrementCounters(
+  counters: { passCount: number; failCount: number; skipCount: number },
+  state: TestStats['state']
+): void {
+  if (state === 'passed') {
+    counters.passCount++
+  } else if (state === 'skipped') {
+    counters.skipCount++
+  } else {
+    counters.failCount++
+  }
+}
+
+export function buildPluginMetadataOptions(input: {
+  isCucumberRunner: boolean
+  configPath: string | undefined
+}) {
+  return {
+    framework: input.isCucumberRunner ? 'nightwatch-cucumber' : 'nightwatch',
+    configFile: input.configPath,
+    baseDir: process.cwd(),
+    runCapabilities: {
+      canRunSuites: true,
+      canRunTests: !input.isCucumberRunner,
+      canRunAll: false
+    }
+  }
+}
 
 /**
  * Generate stable UID for test/suite.
  * Accepts either (item: SuiteStats | TestStats) or (file: string, name: string).
+ * Hashing is delegated to @wdio/devtools-core; this wrapper preserves the
+ * dual-signature convenience used by the Nightwatch suite/test managers.
  */
-export function generateStableUid(itemOrFile: any, name?: string): string {
+type StableUidSource = { file?: string; fullTitle?: string; title?: string }
+export function generateStableUid(
+  itemOrFile: string | StableUidSource,
+  name?: string
+): string {
   let file: string, testName: string
   if (
     typeof itemOrFile === 'object' &&
@@ -43,57 +86,10 @@ export function generateStableUid(itemOrFile: any, name?: string): string {
     file = itemOrFile.file || ''
     testName = String(itemOrFile.fullTitle || itemOrFile.title)
   } else {
-    file = itemOrFile || ''
+    file = (itemOrFile as string) || ''
     testName = String(name || '')
   }
-  const signature = `${file}::${testName}`
-  const count = signatureCounters.get(signature) || 0
-  signatureCounters.set(signature, count + 1)
-  const hashInput = count > 0 ? `${signature}::${count}` : signature
-  const hash = hashInput
-    .split('')
-    .reduce((acc, char) => ((acc << 5) - acc + char.charCodeAt(0)) | 0, 0)
-  return `stable-${Math.abs(hash).toString(36)}`
-}
-
-/** Reset counters at the start of each test run. */
-export function resetSignatureCounters() {
-  signatureCounters.clear()
-}
-
-/**
- * Compute a purely deterministic UID from arbitrary string parts.
- * Unlike generateStableUid this NEVER uses the signature counter, so calling
- * it multiple times with the same inputs always returns the same value.
- * Use this wherever the same entity (e.g. a Cucumber scenario) must map to
- * the same UID across retries.
- */
-export function deterministicUid(...parts: string[]): string {
-  const hash = parts
-    .join('::')
-    .split('')
-    .reduce((acc, char) => ((acc << 5) - acc + char.charCodeAt(0)) | 0, 0)
-  return `stable-${Math.abs(hash).toString(36)}`
-}
-
-/** Returns true if a stack frame belongs to user code (not dependencies, internals, or build output). */
-function isUserCodeFrame(frame: {
-  file?: string | null
-}): frame is { file: string } {
-  const { file } = frame
-  return !!(
-    file &&
-    !file.includes('/node_modules/') &&
-    !file.includes('<anonymous>') &&
-    !file.includes('node:internal') &&
-    !file.includes('/dist/') &&
-    !file.includes('/index.js')
-  )
-}
-
-/** Strips the file:// protocol and any trailing :line:col suffix from a file path. */
-function normalizeFilePath(filePath: string): string {
-  return filePath.replace(/^file:\/\//, '').split(':')[0]
+  return generateStableUidByFileName(file, testName)
 }
 
 /**
@@ -129,75 +125,17 @@ export function findTestFileFromStack(): string | undefined {
  * the TestLens eye-icon navigation.
  */
 export function extractTestMetadata(filePath: string): TestFileMetadata {
-  const result: TestFileMetadata = {
-    suiteTitle: null,
-    suiteLine: null,
-    testNames: [],
-    testLines: []
-  }
-  if (!fs.existsSync(filePath)) {
-    return result
-  }
-
-  try {
-    const lines = fs.readFileSync(filePath, 'utf-8').split('\n')
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i]
-      const lineNum = i + 1
-      if (result.suiteTitle === null) {
-        const m = line.match(
-          /(?:describe|suite|context)\s*\(\s*['"`]([^'"`]+)['"`]/
-        )
-        if (m) {
-          result.suiteTitle = m[1]
-          result.suiteLine = lineNum
-        }
-      }
-      // describe/it style: it('name', ...) / test('name', ...) / specify('name', ...)
-      const itMatch = line.match(
-        /(?:it|test|specify)\s*\(\s*['"`]([^'"`]+)['"`]/
-      )
-      if (itMatch) {
-        result.testNames.push(itMatch[1])
-        result.testLines.push(lineNum)
-        continue
-      }
-      // Object-export style (NightwatchTests): 'Test name': () => { / 'Test name': function() {
-      // This is the default format generated by `npx nightwatch --yes`
-      const objMatch = line.match(
-        /^\s*['"`]([^'"`]+)['"`]\s*:\s*(?:async\s+)?(?:\([^)]*\)\s*=>|function\s*\()/
-      )
-      if (objMatch) {
-        result.testNames.push(objMatch[1])
-        result.testLines.push(lineNum)
-      }
-    }
-  } catch {
-    // skip unparseable files
-  }
-  return result
-}
-
-/**
- * Get call source info from stack trace.
- * Returns { filePath, callSource } where callSource has the filename:line format.
- */
-export function getCallSourceFromStack(): {
-  filePath: string | undefined
-  callSource: string
-} {
-  const stack = new Error().stack
-  if (!stack) {
-    return { filePath: undefined, callSource: 'unknown:0' }
-  }
-
-  const frame = parseStackTrace(stack).find(isUserCodeFrame)
-  if (!frame?.file) {
-    return { filePath: undefined, callSource: 'unknown:0' }
+  const defs = findTestDefinitions(filePath, {
+    includeNightwatchObjectStyle: true
+  })
+  const firstSuite = defs.find((d) => d.kind === 'suite')
+  const tests = defs.filter((d) => d.kind === 'test')
+  return {
+    suiteTitle: firstSuite?.title ?? null,
+    suiteLine: firstSuite?.line ?? null,
+    testNames: tests.map((t) => t.title),
+    testLines: tests.map((t) => t.line)
   }
-
-  const filePath = normalizeFilePath(frame.file)
-  return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` }
 }
 
 /**
@@ -246,100 +184,18 @@ export function findTestFileByName(
 // Console / log helpers (used by SessionCapturer)
 // ---------------------------------------------------------------------------
 
-/**
- * Strip ANSI escape codes from a string.
- */
-export const stripAnsiCodes = (text: string): string =>
-  text.replace(ANSI_REGEX, '')
+// Console helpers come from @wdio/devtools-core. `stripAnsiCodes` is the
+// local name kept for backwards compatibility with existing import sites.
+export {
+  stripAnsi as stripAnsiCodes,
+  detectLogLevel,
+  createConsoleLogEntry
+} from '@wdio/devtools-core'
 
-/** Infer a log level from the text content of a line. */
-export function detectLogLevel(text: string): LogLevel {
-  const normalised = stripAnsiCodes(text).toLowerCase()
-  for (const { level, pattern } of LOG_LEVEL_PATTERNS) {
-    if (pattern.test(normalised)) {
-      return level
-    }
-  }
-  return 'log'
-}
-
-/**
- * Build a ConsoleLog entry.
- */
-export function createConsoleLogEntry(
-  type: LogLevel,
-  args: any[],
-  source: string
-): ConsoleLog {
-  return { timestamp: Date.now(), type, args, source }
-}
-
-/** Map a Chrome DevTools log level string to our LogLevel union. */
-export function chromeLogLevelToLogLevel(
-  level: string | { value?: number; name?: string }
-): LogLevel {
-  const levelName = (
-    typeof level === 'object' ? (level?.name ?? '') : (level ?? '')
-  ).toUpperCase()
-  switch (levelName) {
-    case 'SEVERE':
-      return 'error'
-    case 'WARNING':
-      return 'warn'
-    case 'INFO':
-      return 'info'
-    case 'DEBUG':
-      return 'debug'
-    default:
-      return 'log'
-  }
-}
+export { chromeLogLevelToLogLevel } from '@wdio/devtools-core'
 
 /** Derive a human-readable request type from URL and MIME type. */
-export function getRequestType(url: string, mimeType?: string): string {
-  const contentType = mimeType?.toLowerCase() ?? ''
-  const urlLower = url.toLowerCase()
-
-  if (contentType.includes('text/html')) {
-    return 'document'
-  }
-  if (contentType.includes('text/css')) {
-    return 'stylesheet'
-  }
-  if (
-    contentType.includes('javascript') ||
-    contentType.includes('ecmascript')
-  ) {
-    return 'script'
-  }
-  if (contentType.includes('image/')) {
-    return 'image'
-  }
-  if (contentType.includes('font/') || contentType.includes('woff')) {
-    return 'font'
-  }
-  if (contentType.includes('application/json')) {
-    return 'fetch'
-  }
-
-  if (urlLower.endsWith('.html') || urlLower.endsWith('.htm')) {
-    return 'document'
-  }
-  if (urlLower.endsWith('.css')) {
-    return 'stylesheet'
-  }
-  if (urlLower.endsWith('.js') || urlLower.endsWith('.mjs')) {
-    return 'script'
-  }
-  if (/\.(png|jpg|jpeg|gif|svg|webp|ico)$/.test(urlLower)) {
-    return 'image'
-  }
-  if (/\.(woff|woff2|ttf|eot|otf)$/.test(urlLower)) {
-    return 'font'
-  }
-
-  return 'xhr'
-}
+export { getRequestType } from '@wdio/devtools-core'
 
 // ---------------------------------------------------------------------------
 // Cucumber helpers
@@ -352,6 +208,31 @@ export function getRequestType(url: string, mimeType?: string): string {
  *  - `stepLines`    — 1-based line numbers for each step (for TestLens navigation)
  *  - `stepKeywords` — BDD keyword (Given/When/Then/And/But) for each step (for labels)
  */
+function collectStepsAfterScenario(
+  lines: string[],
+  scenarioIndex: number,
+  stepCount: number
+): { stepLines: number[]; stepKeywords: string[] } {
+  const stepRe = /^\s*(Given|When|Then|And|But)\s+/i
+  const stepLines: number[] = []
+  const stepKeywords: string[] = []
+  for (
+    let j = scenarioIndex + 1;
+    j < lines.length && stepLines.length < stepCount;
+    j++
+  ) {
+    if (/^\s*(?:Scenario:|Feature:)/i.test(lines[j])) {
+      break
+    }
+    const m = stepRe.exec(lines[j])
+    if (m) {
+      stepLines.push(j + 1)
+      stepKeywords.push(m[1])
+    }
+  }
+  return { stepLines, stepKeywords }
+}
+
 export function parseCucumberScenario(
   featureContent: string,
   scenarioName: string,
@@ -371,43 +252,26 @@ export function parseCucumberScenario(
       stepKeywords: Array<string>(stepCount).fill('')
     }
   }
-
   const lines = featureContent.split('\n')
-  const stepRe = /^\s*(Given|When|Then|And|But)\s+/i
   let featureLine = 1
   let scenarioLine = 1
-  const stepLines: number[] = []
-  const stepKeywords: string[] = []
-
+  let stepLines: number[] = []
+  let stepKeywords: string[] = []
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i]
     const lineNum = i + 1
-
     if (featureLine === 1 && /^\s*Feature:/i.test(line)) {
       featureLine = lineNum
       continue
     }
-
     if (/^\s*Scenario:/i.test(line) && line.includes(scenarioName)) {
       scenarioLine = lineNum
-      for (
-        let j = i + 1;
-        j < lines.length && stepLines.length < stepCount;
-        j++
-      ) {
-        if (/^\s*(?:Scenario:|Feature:)/i.test(lines[j])) {
-          break
-        }
-        const m = stepRe.exec(lines[j])
-        if (m) {
-          stepLines.push(j + 1)
-          stepKeywords.push(m[1])
-        }
-      }
+      const collected = collectStepsAfterScenario(lines, i, stepCount)
+      stepLines = collected.stepLines
+      stepKeywords = collected.stepKeywords
       break
     }
   }
-
   while (stepKeywords.length < stepCount) {
     stepKeywords.push('')
   }
@@ -496,32 +360,7 @@ export function findStepDefinitionLine(
   return null
 }
 
-// ---------------------------------------------------------------------------
-// Port / network helpers (used by the plugin startup)
-// ---------------------------------------------------------------------------
-
-const log = logger('@wdio/nightwatch-devtools')
-
-export function isPortInUse(port: number, hostname: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const server = net.createServer()
-    server.once('error', () => resolve(true))
-    server.once('listening', () => server.close(() => resolve(false)))
-    server.listen(port, hostname)
-  })
-}
-
-export async function findFreePort(
-  startPort: number,
-  hostname: string
-): Promise<number> {
-  let port = startPort
-  while (await isPortInUse(port, hostname)) {
-    log.warn(`Port ${port} is in use, trying ${port + 1}...`)
-    port++
-  }
-  return port
-}
+export { isPortInUse, findFreePort } from '@wdio/devtools-core'
 
 export function resolveNightwatchConfig(): string | undefined {
   // Prefer the config explicitly passed via -c / --config to avoid picking up
diff --git a/packages/nightwatch-devtools/src/index.ts b/packages/nightwatch-devtools/src/index.ts
index 59ca246c..395e4a77 100644
--- a/packages/nightwatch-devtools/src/index.ts
+++ b/packages/nightwatch-devtools/src/index.ts
@@ -5,35 +5,62 @@
  * Captures commands, network requests, and console logs during test execution in real-time.
  */
 
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
 import { fileURLToPath } from 'node:url'
-import { start, stop } from '@wdio/devtools-backend'
+import { errorMessage } from '@wdio/devtools-core'
+import { REUSE_ENV, SCREENCAST_DEFAULTS } from '@wdio/devtools-shared'
 import logger from '@wdio/logger'
-import { remote } from 'webdriverio'
-import { SessionCapturer } from './session.js'
-import { TestReporter } from './reporter.js'
-import { TestManager } from './helpers/testManager.js'
-import { SuiteManager } from './helpers/suiteManager.js'
-import { BrowserProxy } from './helpers/browserProxy.js'
 import {
-  TraceType,
-  type DevToolsOptions,
-  type NightwatchBrowser,
-  type TestStats
+  handleReuseMode,
+  openDevtoolsBrowser,
+  finalizeAllSuites,
+  logRunSummary,
+  waitForDevtoolsBrowserClose,
+  runPluginBefore,
+  type PluginBeforeCtx
+} from './run-lifecycle.js'
+import type { PluginInternals } from './plugin-internals.js'
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { ScreencastRecorder } from './screencast.js'
+import type { TestManager } from './helpers/testManager.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { BrowserProxy } from './helpers/browserProxy.js'
+import type {
+  DevToolsOptions,
+  NightwatchBrowser,
+  NightwatchCurrentTest,
+  NightwatchEventHub,
+  ScreencastOptions,
+  SuiteStats,
+  TestStats
 } from './types.js'
+import { registerEventHandlers as registerEventHandlersImpl } from './event-hub.js'
 import {
-  determineTestState,
-  findTestFileFromStack,
-  deterministicUid,
-  extractTestMetadata,
-  parseCucumberScenario,
-  findStepDefinitionLine,
-  findFreePort,
-  resolveNightwatchConfig
+  cucumberBefore as cucumberLifecycleBefore,
+  cucumberAfter as cucumberLifecycleAfter,
+  cucumberBeforeStep as cucumberLifecycleBeforeStep,
+  cucumberAfterStep as cucumberLifecycleAfterStep,
+  type CucumberPickle,
+  type CucumberPickleStep,
+  type CucumberResult
+} from './cucumber-lifecycle.js'
+import {
+  resolveSuiteMetadata,
+  pickCurrentTestName,
+  startNextTest,
+  closePreviousRunningTest,
+  wrapBrowserOnce,
+  closeOutTestcases
+} from './test-lifecycle.js'
+import {
+  ensureSessionInitialized,
+  finalizeCurrentScreencast
+} from './session-init.js'
+import {
+  getTestIcon,
+  incrementCounters,
+  buildPluginMetadataOptions
 } from './helpers/utils.js'
-import { DEFAULTS, TIMING, TEST_STATE, PLUGIN_GLOBAL_KEY } from './constants.js'
 
 const log = logger('@wdio/nightwatch-devtools')
 
@@ -45,9 +72,9 @@ class NightwatchDevToolsPlugin {
   private suiteManager!: SuiteManager
   private browserProxy!: BrowserProxy
   private isScriptInjected = false
-  #currentTest: any = null
-  #currentScenarioSuite: any = null
-  #currentStep: any = null
+  #currentTest: unknown = null
+  #currentScenarioSuite: SuiteStats | null = null
+  #currentStep: unknown = null
   #lastSessionId: string | null = null
   #devtoolsBrowser?: WebdriverIO.Browser
   #userDataDir?: string
@@ -59,615 +86,310 @@ class NightwatchDevToolsPlugin {
   #srcFolders: string[] = []
 
   #getRerunLabel() {
-    return process.env.DEVTOOLS_RERUN_ENTRY_TYPE === 'test'
-      ? process.env.DEVTOOLS_RERUN_LABEL?.trim()
+    return process.env[REUSE_ENV.RERUN_ENTRY_TYPE] === 'test'
+      ? process.env[REUSE_ENV.RERUN_LABEL]?.trim()
       : undefined
   }
 
+  #screencastOptions: ScreencastOptions
+  #screencastRecorder?: ScreencastRecorder
+  #screencastSessionId?: string
+  #bidiEnabled = false
+  #bidiAttachAttempted = false
+
   constructor(options: DevToolsOptions = {}) {
     this.options = {
       port: options.port ?? 3000,
-      hostname: options.hostname ?? 'localhost'
-    }
-  }
-
-  async before() {
-    // When relaunched by the DevTools UI rerun button the backend is already
-    // running — skip startup and just connect the WebSocket worker.
-    const isReuse =
-      process.env.DEVTOOLS_APP_REUSE === '1' &&
-      process.env.DEVTOOLS_APP_HOST &&
-      process.env.DEVTOOLS_APP_PORT
-
-    if (isReuse) {
-      this.options.hostname = process.env.DEVTOOLS_APP_HOST!
-      this.options.port = Number(process.env.DEVTOOLS_APP_PORT)
-      log.info(
-        `♻  Reusing DevTools backend at ${this.options.hostname}:${this.options.port}`
-      )
-      // Clear execution data from the previous run when rerunning
-      // This ensures test names cache and suites are fresh for the new run
-      if (this.testReporter) {
-        this.testReporter.clearExecutionData()
-        this.suiteManager.clearExecutionData()
-        // Reset counters for fresh run
-        this.#passCount = 0
-        this.#failCount = 0
-        this.#skipCount = 0
-        log.info('Cleared execution data for rerun')
-      }
-    }
-
-    this.#configPath = resolveNightwatchConfig()
-    if (this.#configPath) {
-      log.info(`✓ Config: ${this.#configPath}`)
-    } else {
-      log.warn(
-        'Could not find nightwatch config — test rerun will be unavailable'
-      )
+      hostname: options.hostname ?? 'localhost',
+      screencast: options.screencast ?? {},
+      bidi: options.bidi ?? false
     }
-
-    if (isReuse) {
-      // Register the plugin instance so Cucumber hooks can call back into it.
-      ;(globalThis as any)[PLUGIN_GLOBAL_KEY] = this
-      return
+    this.#screencastOptions = {
+      ...SCREENCAST_DEFAULTS,
+      ...(options.screencast ?? {})
     }
+    this.#bidiEnabled = options.bidi === true
+  }
 
-    try {
-      this.options.port = await findFreePort(
-        this.options.port,
-        this.options.hostname
-      )
-      log.info('🚀 Starting DevTools backend...')
-      const { port } = await start(this.options)
-      this.options.port = port
-      const url = `http://${this.options.hostname}:${this.options.port}`
-      log.info(`✓ Backend started on port ${this.options.port}`)
-      log.info(`  DevTools UI: ${url}`)
-
-      try {
-        // Create unique user data directory for this instance to prevent conflicts
-        this.#userDataDir = path.join(
-          os.tmpdir(),
-          `nightwatch-devtools-${this.options.port}-${Date.now()}`
-        )
-
-        if (!fs.existsSync(this.#userDataDir)) {
-          fs.mkdirSync(this.#userDataDir, { recursive: true })
-        }
+  // Single internals "bag" — structurally satisfies all 4 lifecycle ctx
+  // interfaces. Lifecycle modules cast it to their narrow type at call time.
+  #internals: PluginInternals | undefined
+  // Declarative accessor map — splitting this purely to satisfy the
+  // line-count rule hurts readability; the body is mechanical wiring.
+  // eslint-disable-next-line max-lines-per-function
+  #getInternals(): PluginInternals {
+    if (this.#internals) {
+      return this.#internals
+    }
+    const self = this
+    this.#internals = {
+      get options() {
+        return self.options
+      },
+      get hostname() {
+        return self.options.hostname
+      },
+      get port() {
+        return self.options.port
+      },
+      get screencastOptions() {
+        return self.#screencastOptions
+      },
+      get bidiEnabled() {
+        return self.#bidiEnabled
+      },
+      get sessionCapturer() {
+        return self.sessionCapturer
+      },
+      set sessionCapturer(v) {
+        self.sessionCapturer = v
+      },
+      get testReporter() {
+        return self.testReporter
+      },
+      set testReporter(v) {
+        self.testReporter = v
+      },
+      get testManager() {
+        return self.testManager
+      },
+      set testManager(v) {
+        self.testManager = v
+      },
+      get suiteManager() {
+        return self.suiteManager
+      },
+      set suiteManager(v) {
+        self.suiteManager = v
+      },
+      get browserProxy() {
+        return self.browserProxy
+      },
+      set browserProxy(v) {
+        self.browserProxy = v
+      },
+      get isScriptInjected() {
+        return self.isScriptInjected
+      },
+      set isScriptInjected(v) {
+        self.isScriptInjected = v
+      },
+      get devtoolsBrowser() {
+        return self.#devtoolsBrowser
+      },
+      set devtoolsBrowser(v) {
+        self.#devtoolsBrowser = v
+      },
+      get userDataDir() {
+        return self.#userDataDir
+      },
+      set userDataDir(v) {
+        self.#userDataDir = v
+      },
+      get passCount() {
+        return self.#passCount
+      },
+      set passCount(v) {
+        self.#passCount = v
+      },
+      get failCount() {
+        return self.#failCount
+      },
+      set failCount(v) {
+        self.#failCount = v
+      },
+      get skipCount() {
+        return self.#skipCount
+      },
+      set skipCount(v) {
+        self.#skipCount = v
+      },
+      get lastSessionId() {
+        return self.#lastSessionId
+      },
+      set lastSessionId(v) {
+        self.#lastSessionId = v
+      },
+      get bidiAttachAttempted() {
+        return self.#bidiAttachAttempted
+      },
+      set bidiAttachAttempted(v) {
+        self.#bidiAttachAttempted = v
+      },
+      get srcFolders() {
+        return self.#srcFolders
+      },
+      set srcFolders(v) {
+        self.#srcFolders = v
+      },
+      get screencastRecorder() {
+        return self.#screencastRecorder
+      },
+      set screencastRecorder(v) {
+        self.#screencastRecorder = v
+      },
+      get screencastSessionId() {
+        return self.#screencastSessionId
+      },
+      set screencastSessionId(v) {
+        self.#screencastSessionId = v
+      },
+      get configPath() {
+        return self.#configPath
+      },
+      getCurrentTest: () => self.#currentTest,
+      getCurrentScenarioSuite: () => self.#currentScenarioSuite,
+      getCurrentStep: () => self.#currentStep,
+      setCurrentTest: (t) => {
+        self.#currentTest = t
+      },
+      setCurrentScenarioSuite: (s) => {
+        self.#currentScenarioSuite = s
+      },
+      setCurrentStep: (s) => {
+        self.#currentStep = s
+      },
+      clearExecutionData: () => {
+        self.testReporter.clearExecutionData()
+        self.suiteManager.clearExecutionData()
+      },
+      buildMetadataOptions: () => self.#buildMetadataOptions(),
+      ensureSessionInitialized: (b) => self.#ensureSessionInitialized(b),
+      wrapBrowserOnce: (b) => self.#wrapBrowserOnce(b),
+      incrementCount: (s) => self.#incrementCount(s),
+      testIcon: (s) => self.#testIcon(s),
+      setCucumberRunner: (v) => {
+        self.#isCucumberRunner = v
+      },
+      getRerunLabel: () => self.#getRerunLabel()
+    }
+    return this.#internals
+  }
 
-        this.#devtoolsBrowser = await remote({
-          logLevel: 'info',
-          automationProtocol: 'devtools',
-          capabilities: {
-            browserName: 'chrome',
-            'goog:chromeOptions': {
-              args: [
-                '--window-size=1600,1200',
-                `--user-data-dir=${this.#userDataDir}`,
-                '--no-first-run',
-                '--no-default-browser-check'
-              ]
-            }
-          }
-        })
+  #handleReuseMode(): void {
+    handleReuseMode(this.#getInternals())
+  }
 
-        await this.#devtoolsBrowser.url(url)
-      } catch (err) {
-        log.error(`Failed to open DevTools UI: ${(err as Error).message}`)
-        log.info(`Please manually open: ${url}`)
-      }
+  async #openDevtoolsBrowser(url: string): Promise<void> {
+    await openDevtoolsBrowser(this.#getInternals(), url)
+  }
 
-      await new Promise((resolve) =>
-        setTimeout(resolve, TIMING.UI_CONNECTION_WAIT)
-      )
-      ;(globalThis as any)[PLUGIN_GLOBAL_KEY] = this
-    } catch (err) {
-      log.error(`Failed to start backend: ${(err as Error).message}`)
-      throw err
-    }
+  async before() {
+    const internals = this.#getInternals() as unknown as PluginBeforeCtx
+    internals.setConfigPath = (v) => {
+      this.#configPath = v
+    }
+    internals.openDevtoolsBrowserAt = (url) => this.#openDevtoolsBrowser(url)
+    internals.handleReuse = () => this.#handleReuseMode()
+    internals.plugin = this
+    await runPluginBefore(internals)
   }
 
   async #ensureSessionInitialized(browser: NightwatchBrowser) {
-    const currentSessionId = browser.sessionId
-    const isSessionChange =
-      currentSessionId &&
-      this.#lastSessionId &&
-      currentSessionId !== this.#lastSessionId
-
-    if (isSessionChange) {
-      log.info('Browser session changed — reconnecting WebSocket only')
-      this.isScriptInjected = false
-      this.sessionCapturer?.cleanup()
-      this.sessionCapturer = null as any
-    }
-    this.#lastSessionId = currentSessionId ?? null
-
-    if (this.sessionCapturer) {
-      return
-    }
-
-    await new Promise((resolve) =>
-      setTimeout(resolve, TIMING.INITIAL_CONNECTION_WAIT)
+    await ensureSessionInitialized(this.#getInternals(), browser, () =>
+      this.#finalizeCurrentScreencast()
     )
-
-    this.sessionCapturer = new SessionCapturer(
-      { port: this.options.port, hostname: this.options.hostname },
-      browser
-    )
-
-    const connected = await this.sessionCapturer.waitForConnection(3000)
-    if (!connected) {
-      log.error('❌ Worker WebSocket failed to connect!')
-    }
-
-    if (!this.testReporter) {
-      // First-time setup: create reporter chain once for the entire run.
-      // These must NOT be recreated on session change — doing so generates a
-      // new feature suite with a fresh start timestamp, which DataManager sees
-      // as a new run and wipes all accumulated commands.
-      this.testReporter = new TestReporter((suitesData: any) => {
-        if (this.sessionCapturer) {
-          this.sessionCapturer.sendUpstream('suites', suitesData)
-        }
-      })
-      this.testManager = new TestManager(this.testReporter)
-      this.suiteManager = new SuiteManager(this.testReporter)
-      this.browserProxy = new BrowserProxy(
-        this.sessionCapturer,
-        this.testManager,
-        () => this.#currentTest ?? this.#currentScenarioSuite
-      )
-    } else {
-      // Session change: update the reporter's upstream callback to use the new
-      // WebSocket, update the proxy's capturer reference (avoids re-wrapping
-      // already-wrapped browser methods which would double-capture commands),
-      // then replay current suite state to the newly-connected UI.
-      this.testReporter.updateUpstream((suitesData: any) => {
-        if (this.sessionCapturer) {
-          this.sessionCapturer.sendUpstream('suites', suitesData)
-        }
-      })
-      this.browserProxy.updateSessionCapturer(this.sessionCapturer)
-      this.testReporter.updateSuites()
-    }
-
-    const capabilities = browser.capabilities || {}
-    const desiredCapabilities = browser.desiredCapabilities || {}
-    const sessionId = browser.sessionId
-    const opts = browser.options || {}
-
-    // Capture src_folders once so beforeEach can resolve test file paths
-    if (this.#srcFolders.length === 0) {
-      const sf = (opts as any).src_folders
-      this.#srcFolders = Array.isArray(sf) ? sf : sf ? [sf] : []
-    }
-
-    this.sessionCapturer.sendUpstream('metadata', {
-      type: TraceType.Testrunner,
-      capabilities,
-      desiredCapabilities,
-      sessionId,
-      testEnv: opts.testEnv,
-      host: opts.webdriver?.host,
-      options: this.#buildMetadataOptions(),
-      url: ''
-    })
-
-    const browserName =
-      capabilities.browserName || desiredCapabilities.browserName || 'unknown'
-    const browserVersion =
-      capabilities.browserVersion || (capabilities as any).version || ''
-    log.info(
-      `✓ Browser: ${browserName}${browserVersion ? ' ' + browserVersion : ''} (session: ${sessionId})`
-    )
-
-    const loggingPrefs =
-      (capabilities as any)['goog:loggingPrefs'] ||
-      (desiredCapabilities as any)['goog:loggingPrefs'] ||
-      {}
-    if (!loggingPrefs.performance) {
-      log.warn(
-        "⚠  Network tab will be empty — add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities"
-      )
-    }
   }
 
-  async cucumberBefore(browser: NightwatchBrowser, pickle: any) {
-    this.#isCucumberRunner = true
-    await this.#initCucumberScenario(browser, pickle)
+  async #finalizeCurrentScreencast(): Promise<void> {
+    await finalizeCurrentScreencast(this.#getInternals())
   }
 
-  async cucumberAfter(browser: NightwatchBrowser, result: any, pickle: any) {
-    await this.#finalizeCucumberScenario(browser, result, pickle)
+  async cucumberBefore(browser: NightwatchBrowser, pickle: CucumberPickle) {
+    await cucumberLifecycleBefore(this.#getInternals(), browser, pickle)
   }
 
-  /** Called from Cucumber Before hook (order:1000) — one call per scenario. */
-  async #initCucumberScenario(browser: NightwatchBrowser, pickle: any) {
-    await this.#ensureSessionInitialized(browser)
-
-    const featureUri: string = pickle.uri ?? 'unknown.feature'
-    const scenarioName: string = pickle.name ?? 'Unknown Scenario'
-
-    // Derive the feature name from the "Feature: <name>" header in the file,
-    // falling back to the filename (e.g. "login") only if the file can't be read.
-    let featureName: string = path.basename(featureUri, '.feature')
-    let featureContent = ''
-    const featureAbsPath = path.resolve(process.cwd(), featureUri)
-    const stepDefFiles: Array<{ filePath: string; content: string }> = []
-    if (featureUri !== 'unknown.feature' && fs.existsSync(featureAbsPath)) {
-      featureContent = fs.readFileSync(featureAbsPath, 'utf-8')
-      const match = featureContent.match(/^\s*Feature:\s*(.+)/m)
-      if (match) {
-        featureName = match[1].trim()
-      }
-
-      this.sessionCapturer.captureSource(featureAbsPath).catch(() => {})
-
-      // Capture step definitions from sibling directories
-      const featureDir = path.dirname(featureAbsPath)
-      const stepDirCandidates = ['step_definitions', 'steps', 'support']
-      for (const candidate of stepDirCandidates) {
-        const stepDir = path.join(featureDir, candidate)
-        if (fs.existsSync(stepDir) && fs.statSync(stepDir).isDirectory()) {
-          for (const entry of fs.readdirSync(stepDir)) {
-            if (/\.(js|ts|mjs|cjs)$/.test(entry)) {
-              const stepFilePath = path.join(stepDir, entry)
-              this.sessionCapturer.captureSource(stepFilePath).catch(() => {})
-              try {
-                stepDefFiles.push({
-                  filePath: stepFilePath,
-                  content: fs.readFileSync(stepFilePath, 'utf-8')
-                })
-              } catch {
-                // skip unreadable files
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // Get or create the feature-level suite (no individual test names — scenarios go into suites[])
-    const featureSuite = this.suiteManager.getOrCreateSuite(
-      featureUri,
-      featureName,
-      featureUri,
-      []
-    )
-    this.suiteManager.markSuiteAsRunning(featureSuite)
-
-    // Parse step keywords from the feature file
-    const steps: Array<{ text: string }> = pickle.steps ?? []
-
-    // Parse line numbers and keywords for TestLens navigation and step labels
-    const { featureLine, scenarioLine, stepLines, stepKeywords } =
-      parseCucumberScenario(
-        featureContent,
-        scenarioName,
-        steps.map((s) => s.text)
-      )
-    if (featureAbsPath && featureLine > 0) {
-      featureSuite.callSource = `${featureAbsPath}:${featureLine}`
-    }
-
-    // Create a scenario sub-suite (child of feature suite).
-    // Use deterministicUid (no counter) so the SAME scenario always maps to the
-    // SAME uid across retries, enabling correct retry detection below.
-    const scenarioUid = deterministicUid(featureUri, `scenario:${scenarioName}`)
-
-    const scenarioSuite: any = {
-      uid: scenarioUid,
-      cid: DEFAULTS.CID,
-      title: scenarioName,
-      fullTitle: `${featureName} ${scenarioName}`,
-      parent: featureSuite.uid,
-      type: 'suite' as const,
-      file: featureUri,
-      start: new Date(),
-      state: 'running',
-      end: null,
-      tests: [],
-      suites: [],
-      hooks: [],
-      _duration: 0,
-      callSource:
-        featureAbsPath && scenarioLine > 0
-          ? `${featureAbsPath}:${scenarioLine}`
-          : undefined
-    }
-
-    // Create a TestStats entry for each step
-    steps.forEach((step, i) => {
-      const keyword = stepKeywords[i] || ''
-      const stepLabel = keyword ? `${keyword} ${step.text}` : step.text
-      const stepUid = deterministicUid(
-        featureUri,
-        `step:${scenarioName}:${step.text}`
-      )
-      scenarioSuite.tests.push({
-        uid: stepUid,
-        cid: DEFAULTS.CID,
-        title: stepLabel,
-        fullTitle: `${scenarioName} ${stepLabel}`,
-        parent: scenarioUid,
-        state: 'pending',
-        start: new Date(),
-        end: null,
-        type: 'test' as const,
-        file: featureUri,
-        retries: 0,
-        _duration: 0,
-        hooks: [],
-        callSource: (() => {
-          const loc = findStepDefinitionLine(stepDefFiles, step.text)
-          if (loc) {
-            return `${loc.filePath}:${loc.line}`
-          }
-          if (featureAbsPath && stepLines[i] > 0) {
-            return `${featureAbsPath}:${stepLines[i]}`
-          }
-          return undefined
-        })()
-      })
-    })
+  async cucumberAfter(
+    browser: NightwatchBrowser,
+    result: CucumberResult,
+    pickle: CucumberPickle
+  ) {
+    await cucumberLifecycleAfter(this.#getInternals(), browser, result, pickle)
+  }
 
-    // Add scenario sub-suite to the feature suite.
-    // If a suite with this uid already exists it means this is a RETRY of the same
-    // scenario — clear execution data so only the latest attempt's commands are shown.
-    const existingIdx = featureSuite.suites.findIndex(
-      (s: any) => s.uid === scenarioUid
+  async cucumberBeforeStep(
+    browser: NightwatchBrowser,
+    pickleStep: CucumberPickleStep,
+    pickle: CucumberPickle
+  ) {
+    await cucumberLifecycleBeforeStep(
+      this.#getInternals(),
+      browser,
+      pickleStep,
+      pickle
     )
-    const isRetry = existingIdx !== -1
-    if (isRetry) {
-      featureSuite.suites[existingIdx] = scenarioSuite
-      // Pass the specific scenario uid so only this scenario's execution data
-      // is reset — a uid-less clearExecutionData would mark ALL suites as
-      // running, destroying the previous terminal states of sibling scenarios.
-      this.sessionCapturer.sendUpstream('clearExecutionData', {
-        uid: scenarioUid,
-        entryType: 'suite'
-      })
-    } else {
-      featureSuite.suites.push(scenarioSuite)
-    }
-
-    this.#currentScenarioSuite = scenarioSuite
-    this.#currentStep = null
-    this.#currentTest = null
-
-    this.testReporter.updateSuites()
-
-    if (!this.isScriptInjected) {
-      this.browserProxy.wrapUrlMethod(browser)
-      this.isScriptInjected = true
-    }
-    this.browserProxy.wrapBrowserCommands(browser)
-    this.browserProxy.resetCommandTracking()
-
-    log.info(`🥒 Scenario: ${scenarioName}`)
   }
 
-  /** Called from Cucumber After hook (order:1000) — one call per scenario. */
-  async #finalizeCucumberScenario(
+  async cucumberAfterStep(
     browser: NightwatchBrowser,
-    result: any,
-    pickle: any
+    result: CucumberResult,
+    pickleStep: CucumberPickleStep,
+    pickle: CucumberPickle
   ) {
-    try {
-      const status = String(result?.status ?? 'UNKNOWN').toUpperCase()
-      const scenarioState: TestStats['state'] =
-        status === 'PASSED'
-          ? TEST_STATE.PASSED
-          : status === 'SKIPPED'
-            ? TEST_STATE.SKIPPED
-            : TEST_STATE.FAILED
-
-      if (this.#currentScenarioSuite) {
-        const duration =
-          Date.now() -
-          (this.#currentScenarioSuite.start?.getTime() ?? Date.now())
-        this.#currentScenarioSuite.state = scenarioState
-        this.#currentScenarioSuite.end = new Date()
-        this.#currentScenarioSuite._duration = duration
-
-        // Ensure any still-running or pending steps are marked appropriately
-        for (const step of this.#currentScenarioSuite.tests) {
-          if (
-            typeof step !== 'string' &&
-            (step.state === 'running' || step.state === 'pending')
-          ) {
-            step.state =
-              scenarioState === TEST_STATE.PASSED
-                ? TEST_STATE.PASSED
-                : TEST_STATE.FAILED
-            step.end = new Date()
-          }
-        }
-
-        const featureUri: string = pickle?.uri ?? 'unknown.feature'
-        this.testManager.markTestAsProcessed(featureUri, pickle?.name ?? '')
-
-        const featureSuite = this.suiteManager.getSuite(featureUri)
-        if (featureSuite) {
-          // Finalize is not called until all scenarios are done — just update state
-          this.suiteManager.finalizeSuiteState(featureSuite)
-        }
-
-        this.#incrementCount(scenarioState)
-        const icon = this.#testIcon(scenarioState)
-        const durationSec = (duration / 1000).toFixed(2)
-        log.info(`  ${icon} ${pickle?.name ?? 'Unknown'} (${durationSec}s)`)
-
-        this.testReporter.updateSuites()
-        this.#currentScenarioSuite = null
-        this.#currentStep = null
-        this.#currentTest = null
-      }
+    await cucumberLifecycleAfterStep(
+      this.#getInternals(),
+      browser,
+      result,
+      pickleStep,
+      pickle
+    )
+  }
 
-      await this.sessionCapturer.captureTrace(browser)
-    } catch (err) {
-      log.error(
-        `Failed to finalize Cucumber scenario: ${(err as Error).message}`
-      )
-    }
+  #resolveSuiteMetadata(currentTest: NightwatchCurrentTest) {
+    return resolveSuiteMetadata(this.#getInternals(), currentTest)
   }
 
-  /** Called from Cucumber BeforeStep hook — marks the step as running. */
-  async cucumberBeforeStep(
-    browser: NightwatchBrowser,
-    pickleStep: any,
-    _pickle: any
-  ) {
-    if (!this.#currentScenarioSuite) {
-      return
-    }
+  #pickCurrentTestName(
+    currentTest: NightwatchCurrentTest,
+    testNames: string[],
+    processedTests: Set<string>
+  ): string | undefined {
+    return pickCurrentTestName(currentTest, testNames, processedTests)
+  }
 
-    // Reset per-step dedup tracking so commands in step N are never
-    // mistaken for retries of identically-signatured commands from step N-1.
-    this.browserProxy?.resetCommandTracking()
+  async #startNextTest(
+    currentSuite: SuiteStats,
+    currentTestName: string,
+    processedTests: Set<string>
+  ): Promise<void> {
+    await startNextTest(
+      this.#getInternals(),
+      currentSuite,
+      currentTestName,
+      processedTests
+    )
+  }
 
-    const stepText: string = pickleStep?.text ?? ''
-    const step = (this.#currentScenarioSuite.tests as any[]).find(
-      (t: any) =>
-        typeof t !== 'string' &&
-        (t.title.endsWith(stepText) || t.title === stepText)
+  async #closePreviousRunningTest(
+    currentSuite: SuiteStats,
+    testFile: string,
+    currentTest: NightwatchCurrentTest
+  ): Promise<void> {
+    await closePreviousRunningTest(
+      this.#getInternals(),
+      currentSuite,
+      testFile,
+      currentTest
     )
-    if (step) {
-      step.state = TEST_STATE.RUNNING
-      step.start = new Date()
-      step.end = null
-      this.#currentStep = step
-      this.testReporter.updateSuites()
-    }
   }
 
-  /** Called from Cucumber AfterStep hook — records the step result. */
-  async cucumberAfterStep(
-    _browser: NightwatchBrowser,
-    result: any,
-    pickleStep: any,
-    _pickle: any
-  ) {
-    const step = this.#currentStep
-    if (!step) {
-      return
-    }
-    const status = String(result?.status ?? 'UNKNOWN').toUpperCase()
-    const stepState: TestStats['state'] =
-      status === 'PASSED'
-        ? TEST_STATE.PASSED
-        : status === 'SKIPPED'
-          ? TEST_STATE.SKIPPED
-          : TEST_STATE.FAILED
-    step.state = stepState
-    step.end = new Date()
-    step._duration = Date.now() - (step.start?.getTime() ?? Date.now())
-    this.#currentStep = null
-    this.testReporter.updateSuites()
-    void pickleStep // used by BeforeStep to find the step
+  #wrapBrowserOnce(browser: NightwatchBrowser): void {
+    wrapBrowserOnce(this.#getInternals(), browser)
   }
 
   async beforeEach(browser: NightwatchBrowser) {
     if (this.#isCucumberRunner) {
       return
     }
-
     await this.#ensureSessionInitialized(browser)
 
-    const currentTest = (browser as any).currentTest
+    const currentTest = browser.currentTest as NightwatchCurrentTest | undefined
     if (!currentTest) {
       return
     }
 
-    const testFile =
-      (currentTest.module || '').split('/').pop() ||
-      currentTest.module ||
-      DEFAULTS.FILE_NAME
-
-    let fullPath: string | null = findTestFileFromStack() || null
-    const cachedPath = this.browserProxy.getCurrentTestFullPath()
-    if (!fullPath && cachedPath && cachedPath.includes(testFile)) {
-      fullPath = cachedPath
-    }
-
-    if (!fullPath && testFile) {
-      const workspaceRoot = process.cwd()
-      // currentTest.module is the path relative to a src_folder, e.g. "basic/ecosia"
-      // So we must try: path.join(cwd, srcFolder, module + '.js') for each src_folder
-      const modulePath = (currentTest.module || '').replace(/\\/g, '/')
-      const srcFolderPaths = this.#srcFolders.flatMap((sf) =>
-        modulePath
-          ? [
-              path.join(workspaceRoot, sf, modulePath + '.js'),
-              path.join(workspaceRoot, sf, modulePath + '.ts'),
-              path.join(workspaceRoot, sf, modulePath + '.cjs'),
-              path.join(workspaceRoot, sf, modulePath)
-            ]
-          : []
-      )
-      const possiblePaths = [
-        // Highest priority: expand module path via each configured src_folder
-        ...srcFolderPaths,
-        // Fallback: treat module path as relative to cwd (works when src_folders isn't nested)
-        ...(modulePath
-          ? [
-              path.join(workspaceRoot, modulePath + '.js'),
-              path.join(workspaceRoot, modulePath + '.ts'),
-              path.join(workspaceRoot, modulePath + '.cjs'),
-              path.join(workspaceRoot, modulePath)
-            ]
-          : []),
-        path.join(workspaceRoot, 'example/tests', testFile + '.js'),
-        path.join(workspaceRoot, 'example/tests', testFile),
-        path.join(workspaceRoot, 'tests', testFile + '.js'),
-        path.join(workspaceRoot, 'test', testFile + '.js'),
-        path.join(workspaceRoot, testFile + '.js')
-      ]
-
-      for (const possiblePath of possiblePaths) {
-        if (fs.existsSync(possiblePath)) {
-          fullPath = possiblePath
-          break
-        }
-      }
-    }
-
-    // Extract suite title and test metadata
-    let suiteTitle = testFile
-    if (!fullPath) {
-      log.warn(
-        `[beforeEach] Could not resolve file path for "${testFile}" — source view will be unavailable`
-      )
-    }
-    let testNames: string[] = []
-    let suiteLine: number | null = null
-    let testLines: number[] = []
-    if (fullPath) {
-      const {
-        suiteTitle: parsedTitle,
-        testNames: parsedNames,
-        suiteLine: parsedSuiteLine,
-        testLines: parsedTestLines
-      } = extractTestMetadata(fullPath)
-      if (parsedTitle) {
-        suiteTitle = parsedTitle
-      }
-      testNames = parsedNames
-      suiteLine = parsedSuiteLine
-      testLines = parsedTestLines
-    }
-
-    const rerunLabel = this.#getRerunLabel()
-    if (rerunLabel) {
-      const targetIndex = testNames.findIndex((name) => name === rerunLabel)
-      if (targetIndex !== -1) {
-        testNames = [testNames[targetIndex]]
-        testLines = testLines[targetIndex] ? [testLines[targetIndex]] : []
-      }
-    }
-
-    // Get or create suite for this test file
+    const { testFile, fullPath, suiteTitle, testNames, suiteLine, testLines } =
+      this.#resolveSuiteMetadata(currentTest)
     const currentSuite = this.suiteManager.getOrCreateSuite(
       testFile,
       suiteTitle,
@@ -676,98 +398,22 @@ class NightwatchDevToolsPlugin {
       suiteLine,
       testLines
     )
-
-    // Capture source file for display
     if (fullPath && fullPath.includes('/')) {
       this.sessionCapturer.captureSource(fullPath).catch(() => {})
     }
 
-    const runningTest = currentSuite.tests.find(
-      (t: any) => typeof t !== 'string' && t.state === TEST_STATE.RUNNING
-    ) as TestStats | undefined
-
-    if (runningTest) {
-      const testcases = currentTest?.results?.testcases || {}
-
-      if (testcases[runningTest.title]) {
-        const testcase = testcases[runningTest.title]
-        const testState = determineTestState(testcase)
-        runningTest.state = testState
-        runningTest.end = new Date()
-        runningTest._duration = parseFloat(testcase.time || '0') * 1000
-        this.testManager.updateTestState(runningTest, testState)
-        this.testManager.markTestAsProcessed(testFile, runningTest.title)
-        this.#incrementCount(testState)
-        const prevIcon = this.#testIcon(testState)
-        log.info(
-          `  ${prevIcon} ${runningTest.title} (${(runningTest._duration / 1000).toFixed(2)}s)`
-        )
-      } else {
-        const endTime = new Date()
-        const duration = endTime.getTime() - (runningTest.start?.getTime() || 0)
-        this.testManager.updateTestState(
-          runningTest,
-          TEST_STATE.PASSED as TestStats['state'],
-          endTime,
-          duration
-        )
-        this.testManager.markTestAsProcessed(testFile, runningTest.title)
-        this.#passCount++
-        log.info(`  ✅ ${runningTest.title} (${(duration / 1000).toFixed(2)}s)`)
-      }
-      await new Promise((resolve) =>
-        setTimeout(resolve, TIMING.UI_RENDER_DELAY)
-      )
-    }
+    await this.#closePreviousRunningTest(currentSuite, testFile, currentTest)
 
     const processedTests = this.testManager.getProcessedTests(testFile)
-    const runtimeTestName =
-      typeof currentTest?.name === 'string'
-        ? currentTest.name.trim()
-        : undefined
-    const matchedRuntimeTestName = runtimeTestName
-      ? testNames.find(
-          (name) =>
-            runtimeTestName === name || runtimeTestName.endsWith(` ${name}`)
-        )
-      : undefined
-    const currentTestName =
-      matchedRuntimeTestName ||
-      testNames.find((name) => !processedTests.has(name))
-
+    const currentTestName = this.#pickCurrentTestName(
+      currentTest,
+      testNames,
+      processedTests
+    )
     if (currentTestName) {
-      if (processedTests.size === 0) {
-        this.suiteManager.markSuiteAsRunning(currentSuite)
-      }
-
-      const test = this.testManager.findTestInSuite(
-        currentSuite,
-        currentTestName
-      )
-      if (test) {
-        test.state = TEST_STATE.RUNNING as TestStats['state']
-        test.start = new Date()
-        test.end = null
-        this.testReporter.onTestStart(test)
-        this.#currentTest = test
-        log.info(`  ▶ ${currentTestName}`)
-        await new Promise((resolve) =>
-          setTimeout(resolve, TIMING.TEST_START_DELAY)
-        )
-      } else {
-        log.warn(
-          `Test "${currentTestName}" not found in suite "${currentSuite.title}"`
-        )
-        this.#currentTest = null
-      }
-    }
-
-    if (!this.isScriptInjected) {
-      this.browserProxy.wrapUrlMethod(browser)
-      this.isScriptInjected = true
+      await this.#startNextTest(currentSuite, currentTestName, processedTests)
     }
-    this.browserProxy.resetCommandTracking()
-    this.browserProxy.wrapBrowserCommands(browser)
+    this.#wrapBrowserOnce(browser)
   }
 
   async afterEach(browser: NightwatchBrowser) {
@@ -778,125 +424,23 @@ class NightwatchDevToolsPlugin {
 
     if (browser && this.sessionCapturer) {
       try {
-        const currentTest = (browser as any).currentTest
-        const results = currentTest?.results || {}
-        const testFile =
-          (currentTest.module || '').split('/').pop() || DEFAULTS.FILE_NAME
-        const testcases = results.testcases || {}
-        const testcaseNames = Object.keys(testcases)
-
-        const currentSuite = this.suiteManager.getSuite(testFile)
-        if (currentSuite) {
-          const processedTests = this.testManager.getProcessedTests(testFile)
-
-          if (testcaseNames.length === 0) {
-            const runningTest = currentSuite.tests.find(
-              (t: any) =>
-                typeof t !== 'string' && t.state === TEST_STATE.RUNNING
-            ) as TestStats | undefined
-
-            if (runningTest && !processedTests.has(runningTest.title)) {
-              const testState: TestStats['state'] =
-                results.errors > 0 || results.failed > 0
-                  ? TEST_STATE.FAILED
-                  : TEST_STATE.PASSED
-              const endTime = new Date()
-              const duration =
-                endTime.getTime() - (runningTest.start?.getTime() || 0)
-
-              this.testManager.updateTestState(
-                runningTest,
-                testState,
-                endTime,
-                duration
-              )
-              this.testManager.markTestAsProcessed(testFile, runningTest.title)
-              this.#incrementCount(testState)
-              const icon = this.#testIcon(testState)
-              log.info(
-                `  ${icon} ${runningTest.title} (${(duration / 1000).toFixed(2)}s)`
-              )
-            }
-          } else {
-            const unprocessedTests = testcaseNames.filter(
-              (name) => !processedTests.has(name)
-            )
-
-            for (const currentTestName of unprocessedTests) {
-              const testcase = testcases[currentTestName]
-              const testState = determineTestState(testcase)
-
-              const test = this.testManager.findTestInSuite(
-                currentSuite,
-                currentTestName
-              )
-              if (test) {
-                const dur = parseFloat(testcase.time || '0') * 1000
-                this.testManager.updateTestState(
-                  test,
-                  testState,
-                  new Date(),
-                  dur
-                )
-                this.#incrementCount(testState)
-                const icon = this.#testIcon(testState)
-                log.info(
-                  `  ${icon} ${currentTestName} (${(dur / 1000).toFixed(2)}s)`
-                )
-              }
-
-              this.testManager.markTestAsProcessed(testFile, currentTestName)
-            }
-
-            if (processedTests.size === testcaseNames.length) {
-              this.suiteManager.finalizeSuite(currentSuite)
-              await new Promise((resolve) =>
-                setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY)
-              )
-            }
-          }
-        }
-
+        await this.#closeOutTestcases(browser)
         await this.sessionCapturer.captureTrace(browser)
       } catch (err) {
-        log.error(`Failed to capture trace: ${(err as Error).message}`)
+        log.error(`Failed to capture trace: ${errorMessage(err)}`)
       }
     }
   }
 
+  async #closeOutTestcases(browser: NightwatchBrowser): Promise<void> {
+    await closeOutTestcases(this.#getInternals(), browser)
+  }
+
   async after(browser?: NightwatchBrowser) {
+    await this.#finalizeCurrentScreencast()
     try {
-      const currentTest = (browser as any)?.currentTest
-      const testcases = currentTest?.results?.testcases || {}
-
-      for (const [, suite] of (
-        this.suiteManager?.getAllSuites() ?? new Map()
-      ).entries()) {
-        this.testManager.finalizeSuiteTests(suite, testcases)
-        await new Promise((resolve) =>
-          setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY)
-        )
-        this.suiteManager.finalizeSuite(suite)
-      }
-
-      await new Promise((resolve) =>
-        setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY)
-      )
-
-      const summary = [
-        this.#passCount > 0 ? `${this.#passCount} passed` : null,
-        this.#failCount > 0 ? `${this.#failCount} failed` : null,
-        this.#skipCount > 0 ? `${this.#skipCount} skipped` : null
-      ]
-        .filter(Boolean)
-        .join('  ')
-      const totalFailed = this.#failCount
-
-      log.info(`${totalFailed > 0 ? '❌' : '✅'} Tests complete!  ${summary}`)
-      log.info(
-        `   DevTools UI: http://${this.options.hostname}:${this.options.port}`
-      )
-
+      await this.#finalizeAllSuites(browser)
+      this.#logRunSummary()
       if (!this.#devtoolsBrowser) {
         // Reuse mode: force one final suites broadcast so the UI reflects the
         // actual outcome before the process exits.
@@ -905,114 +449,56 @@ class NightwatchDevToolsPlugin {
         await this.sessionCapturer?.closeWebSocket()
         return
       }
-
       log.info('💡 Please close the DevTools browser window to finish...')
+      await this.#waitForDevtoolsBrowserClose()
+    } catch (err) {
+      log.error(`Failed to stop backend: ${errorMessage(err)}`)
+    }
+  }
 
-      if (this.#devtoolsBrowser) {
-        ;(logger as any).setLevel('devtools', 'warn')
-        let exitBySignal = false
-
-        const signalHandler = () => {
-          exitBySignal = true
-          log.info('\n✓ Exiting... Browser window will remain open')
-          process.exit(0)
-        }
-        process.once('SIGINT', signalHandler)
-        process.once('SIGTERM', signalHandler)
+  async #finalizeAllSuites(browser?: NightwatchBrowser): Promise<void> {
+    await finalizeAllSuites(this.#getInternals(), browser)
+  }
 
-        while (true) {
-          try {
-            await this.#devtoolsBrowser.getTitle()
-            await new Promise((res) =>
-              setTimeout(res, TIMING.BROWSER_POLL_INTERVAL)
-            )
-          } catch {
-            if (!exitBySignal) {
-              log.info('Browser window closed, stopping DevTools app')
-              break
-            }
-          }
-        }
+  #logRunSummary(): void {
+    logRunSummary(this.#getInternals())
+  }
 
-        if (!exitBySignal) {
-          process.removeListener('SIGINT', signalHandler)
-          process.removeListener('SIGTERM', signalHandler)
-          ;(logger as any).setLevel('devtools', 'info')
-          try {
-            await this.#devtoolsBrowser.deleteSession()
-          } catch {
-            // session already closed
-          }
-          await stop()
-          process.exit(0)
-        }
-      }
-    } catch (err) {
-      log.error(`Failed to stop backend: ${(err as Error).message}`)
-    }
+  async #waitForDevtoolsBrowserClose(): Promise<void> {
+    await waitForDevtoolsBrowserClose(this.#getInternals())
   }
 
   #buildMetadataOptions() {
-    return {
-      framework: this.#isCucumberRunner ? 'nightwatch-cucumber' : 'nightwatch',
-      configFile: this.#configPath,
-      baseDir: process.cwd(),
-      runCapabilities: {
-        canRunSuites: true,
-        canRunTests: !this.#isCucumberRunner,
-        canRunAll: false
-      }
-    }
+    return buildPluginMetadataOptions({
+      isCucumberRunner: this.#isCucumberRunner,
+      configPath: this.#configPath
+    })
   }
 
   #incrementCount(state: TestStats['state']): void {
-    if (state === TEST_STATE.PASSED) {
-      this.#passCount++
-    } else if (state === TEST_STATE.SKIPPED) {
-      this.#skipCount++
-    } else {
-      this.#failCount++
-    }
+    const counters = {
+      passCount: this.#passCount,
+      failCount: this.#failCount,
+      skipCount: this.#skipCount
+    }
+    incrementCounters(counters, state)
+    this.#passCount = counters.passCount
+    this.#failCount = counters.failCount
+    this.#skipCount = counters.skipCount
   }
 
   #testIcon(state: TestStats['state']): string {
-    return state === TEST_STATE.PASSED
-      ? '✅'
-      : state === TEST_STATE.SKIPPED
-        ? '⏭'
-        : '❌'
+    return getTestIcon(state)
   }
 
-  registerEventHandlers(eventHub: any): void {
-    this.#isCucumberRunner = eventHub.runner === 'cucumber'
-    if (this.#isCucumberRunner) {
-      log.info('✓ Cucumber runner detected via NightwatchEventHub')
-    }
-    log.info('✓ NightwatchEventHub registered — enriched metadata enabled')
-
-    const handleSessionMetadata = (data: any) => {
-      try {
-        const { sessionCapabilities, sessionId, testEnv, host, modulePath } =
-          data?.metadata ?? {}
-
-        if (this.sessionCapturer && (sessionCapabilities || sessionId)) {
-          this.sessionCapturer.sendUpstream('metadata', {
-            type: TraceType.Testrunner,
-            capabilities: sessionCapabilities ?? {},
-            sessionId,
-            testEnv,
-            host,
-            modulePath,
-            options: this.#buildMetadataOptions()
-          })
-        }
-      } catch (err) {
-        log.error(`Error in event handler: ${(err as Error).message}`)
+  registerEventHandlers(eventHub: NightwatchEventHub): void {
+    registerEventHandlersImpl(eventHub, {
+      getSessionCapturer: () => this.sessionCapturer,
+      buildMetadataOptions: () => this.#buildMetadataOptions(),
+      setCucumberRunner: (v: boolean) => {
+        this.#isCucumberRunner = v
       }
-    }
-
-    eventHub.on('TestSuiteStarted', handleSessionMetadata)
-    eventHub.on('TestRunStarted', handleSessionMetadata)
+    })
   }
 }
 
@@ -1028,20 +514,20 @@ export default function createNightwatchDevTools(options?: DevToolsOptions) {
     // The after() hook waits for the browser window to be closed
     asyncHookTimeout: 3600000,
 
-    before: async function (this: any) {
+    before: async function (this: unknown) {
       await plugin.before()
     },
-    beforeEach: async function (this: any, browser: NightwatchBrowser) {
+    beforeEach: async function (this: unknown, browser: NightwatchBrowser) {
       await plugin.beforeEach(browser)
     },
-    afterEach: async function (this: any, browser: NightwatchBrowser) {
+    afterEach: async function (this: unknown, browser: NightwatchBrowser) {
       await plugin.afterEach(browser)
     },
-    after: async function (this: any) {
+    after: async function (this: unknown) {
       await plugin.after()
     },
 
-    registerEventHandlers: function (eventHub: any) {
+    registerEventHandlers: function (eventHub: NightwatchEventHub) {
       plugin.registerEventHandlers(eventHub)
     }
   }
diff --git a/packages/nightwatch-devtools/src/plugin-internals.ts b/packages/nightwatch-devtools/src/plugin-internals.ts
new file mode 100644
index 00000000..06c75f22
--- /dev/null
+++ b/packages/nightwatch-devtools/src/plugin-internals.ts
@@ -0,0 +1,74 @@
+/**
+ * Single internals "bag" the plugin exposes to its lifecycle modules.
+ *
+ * Each lifecycle module declares its own narrow `Ctx` interface; the plugin
+ * builds ONE `PluginInternals` object that structurally satisfies all of
+ * them. This keeps the plugin file compact (one accessor block instead of
+ * four) while still letting each lifecycle module narrow its dependencies.
+ */
+
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { ScreencastRecorder } from './screencast.js'
+import type { TestManager } from './helpers/testManager.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { BrowserProxy } from './helpers/browserProxy.js'
+import type {
+  NightwatchBrowser,
+  ScreencastOptions,
+  SuiteStats,
+  TestStats
+} from './types.js'
+
+export interface PluginInternals {
+  // Config + options
+  options: { hostname: string; port: number }
+  readonly hostname: string
+  readonly port: number
+  readonly screencastOptions: ScreencastOptions
+  readonly bidiEnabled: boolean
+
+  // Runtime instances (mutable — bringup/session-change replaces them)
+  sessionCapturer: SessionCapturer
+  testReporter: TestReporter
+  testManager: TestManager
+  suiteManager: SuiteManager
+  browserProxy: BrowserProxy
+  isScriptInjected: boolean
+  devtoolsBrowser: WebdriverIO.Browser | undefined
+  userDataDir: string | undefined
+
+  // Run state
+  passCount: number
+  failCount: number
+  skipCount: number
+
+  // Session state
+  lastSessionId: string | null
+  bidiAttachAttempted: boolean
+  srcFolders: string[]
+  screencastRecorder: ScreencastRecorder | undefined
+  screencastSessionId: string | undefined
+
+  /** Absolute path to the resolved Nightwatch config file, if known. Used as
+   *  a fallback directory for screencast video output. */
+  configPath: string | undefined
+
+  // Current execution (set by lifecycle, read across modules)
+  getCurrentTest(): unknown
+  getCurrentScenarioSuite(): SuiteStats | null
+  getCurrentStep(): unknown
+  setCurrentTest(t: unknown): void
+  setCurrentScenarioSuite(s: SuiteStats | null): void
+  setCurrentStep(s: unknown): void
+
+  // Plugin-side delegates
+  clearExecutionData(): void
+  buildMetadataOptions(): unknown
+  ensureSessionInitialized(b: NightwatchBrowser): Promise<void>
+  wrapBrowserOnce(b: NightwatchBrowser): void
+  incrementCount(state: TestStats['state']): void
+  testIcon(state: TestStats['state']): string
+  setCucumberRunner(v: boolean): void
+  getRerunLabel(): string | undefined
+}
diff --git a/packages/nightwatch-devtools/src/reporter.ts b/packages/nightwatch-devtools/src/reporter.ts
index 087933cf..a6e8282e 100644
--- a/packages/nightwatch-devtools/src/reporter.ts
+++ b/packages/nightwatch-devtools/src/reporter.ts
@@ -1,43 +1,29 @@
 import logger from '@wdio/logger'
+import { TestReporterBase } from '@wdio/devtools-core'
+import { REUSE_ENV } from '@wdio/devtools-shared'
 import { DEFAULTS } from './constants.js'
-import {
-  extractTestMetadata,
-  generateStableUid,
-  resetSignatureCounters
-} from './helpers/utils.js'
+import { extractTestMetadata, generateStableUid } from './helpers/utils.js'
 import type { SuiteStats, TestStats } from './types.js'
 
 const log = logger('@wdio/nightwatch-devtools:Reporter')
 
-export class TestReporter {
-  #report: (data: any) => void
+export class TestReporter extends TestReporterBase {
   #currentSpecFile?: string
   #testNamesCache = new Map<string, string[]>()
   #currentSuite?: SuiteStats
-  #allSuites: SuiteStats[] = []
 
-  constructor(report: (data: any) => void) {
-    this.#report = report
-    resetSignatureCounters()
-  }
-
-  /**
-   * Called when a suite starts
-   */
   onSuiteStart(suiteStats: SuiteStats) {
     this.#currentSpecFile = suiteStats.file
     this.#currentSuite = suiteStats
     const rerunLabel =
-      process.env.DEVTOOLS_RERUN_ENTRY_TYPE === 'test'
-        ? process.env.DEVTOOLS_RERUN_LABEL?.trim()
+      process.env[REUSE_ENV.RERUN_ENTRY_TYPE] === 'test'
+        ? process.env[REUSE_ENV.RERUN_LABEL]?.trim()
         : undefined
 
-    // Generate stable UID only if not already set
     if (!suiteStats.uid) {
       suiteStats.uid = generateStableUid(suiteStats)
     }
 
-    // Extract test names from source file
     if (
       this.#currentSpecFile &&
       !this.#testNamesCache.has(this.#currentSpecFile)
@@ -54,101 +40,49 @@ export class TestReporter {
       }
     }
 
-    this.#allSuites.push(suiteStats)
-    this.#sendUpstream()
+    this.allSuites.push(suiteStats)
+    this.sendUpstream()
   }
 
-  /**
-   * Clear execution data when a rerun starts.
-   * Resets test name cache and suites so they're repopulated fresh during the new run.
-   */
-  clearExecutionData() {
+  override clearExecutionData() {
+    super.clearExecutionData()
     this.#testNamesCache.clear()
-    this.#allSuites = []
     this.#currentSuite = undefined
     this.#currentSpecFile = undefined
-    resetSignatureCounters()
-  }
-
-  /**
-   * Update the upstream reporter callback (used after a WebDriver session change
-   * so suite data is sent over the new WebSocket without rebuilding the reporter).
-   */
-  updateUpstream(report: (data: any) => void) {
-    this.#report = report
-  }
-
-  /**
-   * Update the suites data (send to UI)
-   */
-  updateSuites() {
-    this.#sendUpstream()
   }
 
-  /**
-   * Get the current suite
-   */
   getCurrentSuite(): SuiteStats | undefined {
     return this.#currentSuite
   }
 
-  /**
-   * Called when a test starts
-   */
+  /** Find by title within parent suite — Nightwatch retries reuse the title slot. */
   onTestStart(testStats: TestStats) {
-    // Generate stable UID (hashed, so consistent even if called multiple times)
     if (!testStats.uid || testStats.uid.includes('temp-')) {
       testStats.uid = generateStableUid(testStats)
     }
 
-    // Search for test by title within parent suite
-    for (const suite of this.#allSuites) {
+    for (const suite of this.allSuites) {
       const testIndex = suite.tests.findIndex((t) => {
         if (typeof t === 'string') {
           return false
         }
-        // Match by title and parent suite
         return t.title === testStats.title && t.parent === suite.uid
       })
       if (testIndex !== -1) {
-        // Update existing test
         suite.tests[testIndex] = testStats
-        this.#sendUpstream()
+        this.sendUpstream()
         return
       }
     }
 
-    // Test not found in any suite, add it to current suite (legacy behavior)
     if (this.#currentSuite) {
       this.#currentSuite.tests.push(testStats)
     }
-
-    this.#sendUpstream()
-  }
-
-  /**
-   * Called when a test ends
-   */
-  onTestEnd(testStats: TestStats) {
-    // Search all suites for this test (not just current suite)
-    for (const suite of this.#allSuites) {
-      const testIndex = suite.tests.findIndex(
-        (t) => (typeof t === 'string' ? t : t.uid) === testStats.uid
-      )
-      if (testIndex !== -1) {
-        suite.tests[testIndex] = testStats
-        break
-      }
-    }
-
-    this.#sendUpstream()
+    this.sendUpstream()
   }
 
-  /**
-   * Called when a suite ends - create skipped tests
-   */
-  onSuiteEnd(suiteStats: SuiteStats) {
-    // Get all test names from cache
+  /** Synthesize `skipped` entries for tests that never executed. */
+  override onSuiteEnd(suiteStats: SuiteStats) {
     const cachedNames = this.#testNamesCache.get(suiteStats.file) || []
     const processedTestNames = new Set(
       suiteStats.tests
@@ -156,7 +90,6 @@ export class TestReporter {
         .filter((title): title is string => Boolean(title))
     )
 
-    // Create skipped tests for tests that didn't run
     cachedNames.forEach((testName) => {
       if (!processedTestNames.has(testName)) {
         const skippedTest: TestStats = {
@@ -177,48 +110,22 @@ export class TestReporter {
           _duration: DEFAULTS.DURATION,
           hooks: []
         }
-
         suiteStats.tests.push(skippedTest)
         log.info(`Created skipped test "${testName}" (never executed)`)
       }
     })
 
-    this.#sendUpstream()
+    this.sendUpstream()
   }
 
-  /**
-   * Update a specific suite and send to UI (used when updating suite title)
-   */
+  /** Replace a suite when its UID changes mid-run (after spec rescan). */
   updateSuite(suiteStats: SuiteStats) {
-    // Find and remove the old suite by file
-    const index = this.#allSuites.findIndex((s) => s.file === suiteStats.file)
+    const index = this.allSuites.findIndex((s) => s.file === suiteStats.file)
     if (index !== -1) {
-      // Remove the old suite entry (with old UID)
-      this.#allSuites.splice(index, 1)
+      this.allSuites.splice(index, 1)
     }
-    // Add the updated suite with new UID
-    this.#allSuites.push(suiteStats)
-    // Update current suite reference
+    this.allSuites.push(suiteStats)
     this.#currentSuite = suiteStats
-    this.#sendUpstream()
-  }
-
-  #sendUpstream() {
-    const payload: Record<string, SuiteStats>[] = []
-
-    for (const suite of this.#allSuites) {
-      if (suite && suite.uid) {
-        // Each suite becomes an object with its UID as the key
-        payload.push({ [suite.uid]: suite })
-      }
-    }
-
-    if (payload.length > 0) {
-      this.#report(payload)
-    }
-  }
-
-  get report() {
-    return this.#allSuites
+    this.sendUpstream()
   }
 }
diff --git a/packages/nightwatch-devtools/src/run-lifecycle.ts b/packages/nightwatch-devtools/src/run-lifecycle.ts
new file mode 100644
index 00000000..a6d7e246
--- /dev/null
+++ b/packages/nightwatch-devtools/src/run-lifecycle.ts
@@ -0,0 +1,224 @@
+/**
+ * Run-level lifecycle helpers for the Nightwatch plugin — reuse-mode setup,
+ * DevTools-browser spawning, end-of-run summary, and the post-run "wait for
+ * browser close" loop.
+ *
+ * Extracted from `index.ts` to keep that file under the file-size cap.
+ */
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as os from 'node:os'
+import logger from '@wdio/logger'
+import { remote } from 'webdriverio'
+import { errorMessage } from '@wdio/devtools-core'
+import { REUSE_ENV } from '@wdio/devtools-shared'
+import { start, stop } from '@wdio/devtools-backend'
+
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { TestManager } from './helpers/testManager.js'
+import type { NightwatchBrowser, NightwatchCurrentTest } from './types.js'
+import { TIMING, PLUGIN_GLOBAL_KEY } from './constants.js'
+import { findFreePort, resolveNightwatchConfig } from './helpers/utils.js'
+
+const log = logger('@wdio/nightwatch-devtools:run-lifecycle')
+
+export interface RunLifecycleCtx {
+  options: { hostname: string; port: number }
+  readonly testReporter: TestReporter | undefined
+  readonly suiteManager: SuiteManager | undefined
+  readonly testManager: TestManager
+  readonly sessionCapturer: SessionCapturer | undefined
+  devtoolsBrowser: WebdriverIO.Browser | undefined
+  userDataDir: string | undefined
+  passCount: number
+  failCount: number
+  skipCount: number
+  clearExecutionData(): void
+}
+
+export function handleReuseMode(ctx: RunLifecycleCtx): void {
+  ctx.options.hostname = process.env[REUSE_ENV.HOST]!
+  ctx.options.port = Number(process.env[REUSE_ENV.PORT])
+  log.info(
+    `♻  Reusing DevTools backend at ${ctx.options.hostname}:${ctx.options.port}`
+  )
+  // Clear execution data from the previous run when rerunning so test-name
+  // caches and suites are fresh for the new run.
+  if (ctx.testReporter) {
+    ctx.clearExecutionData()
+    ctx.passCount = 0
+    ctx.failCount = 0
+    ctx.skipCount = 0
+    log.info('Cleared execution data for rerun')
+  }
+}
+
+export interface PluginBeforeCtx extends RunLifecycleCtx {
+  setConfigPath(v: string | undefined): void
+  openDevtoolsBrowserAt(url: string): Promise<void>
+  handleReuse(): void
+  // The plugin instance to assign to the global slot for cucumber hooks.
+  plugin: unknown
+}
+
+export async function runPluginBefore(ctx: PluginBeforeCtx): Promise<void> {
+  // When relaunched by the DevTools UI rerun button the backend is already
+  // running — skip startup and just connect the WebSocket worker.
+  const isReuse =
+    process.env[REUSE_ENV.REUSE] === '1' &&
+    !!process.env[REUSE_ENV.HOST] &&
+    !!process.env[REUSE_ENV.PORT]
+  if (isReuse) {
+    ctx.handleReuse()
+  }
+  const configPath = resolveNightwatchConfig()
+  ctx.setConfigPath(configPath)
+  if (configPath) {
+    log.info(`✓ Config: ${configPath}`)
+  } else {
+    log.warn(
+      'Could not find nightwatch config — test rerun will be unavailable'
+    )
+  }
+  if (isReuse) {
+    ;(globalThis as Record<string, unknown>)[PLUGIN_GLOBAL_KEY] = ctx.plugin
+    return
+  }
+  try {
+    ctx.options.port = await findFreePort(
+      ctx.options.port,
+      ctx.options.hostname
+    )
+    log.info('🚀 Starting DevTools backend...')
+    const { port } = await start(ctx.options)
+    ctx.options.port = port
+    const url = `http://${ctx.options.hostname}:${ctx.options.port}`
+    log.info(`✓ Backend started on port ${ctx.options.port}`)
+    log.info(`  DevTools UI: ${url}`)
+    await ctx.openDevtoolsBrowserAt(url)
+    await new Promise((resolve) =>
+      setTimeout(resolve, TIMING.UI_CONNECTION_WAIT)
+    )
+    ;(globalThis as Record<string, unknown>)[PLUGIN_GLOBAL_KEY] = ctx.plugin
+  } catch (err) {
+    log.error(`Failed to start backend: ${errorMessage(err)}`)
+    throw err
+  }
+}
+
+export async function openDevtoolsBrowser(
+  ctx: RunLifecycleCtx,
+  url: string
+): Promise<void> {
+  try {
+    // Unique user data directory per instance to prevent conflicts.
+    ctx.userDataDir = path.join(
+      os.tmpdir(),
+      `nightwatch-devtools-${ctx.options.port}-${Date.now()}`
+    )
+    if (!fs.existsSync(ctx.userDataDir)) {
+      fs.mkdirSync(ctx.userDataDir, { recursive: true })
+    }
+    ctx.devtoolsBrowser = await remote({
+      logLevel: 'info',
+      automationProtocol: 'devtools',
+      capabilities: {
+        browserName: 'chrome',
+        'goog:chromeOptions': {
+          args: [
+            '--window-size=1600,1200',
+            `--user-data-dir=${ctx.userDataDir}`,
+            '--no-first-run',
+            '--no-default-browser-check'
+          ]
+        }
+      }
+    })
+    await ctx.devtoolsBrowser.url(url)
+  } catch (err) {
+    log.error(`Failed to open DevTools UI: ${errorMessage(err)}`)
+    log.info(`Please manually open: ${url}`)
+  }
+}
+
+export async function finalizeAllSuites(
+  ctx: RunLifecycleCtx,
+  browser?: NightwatchBrowser
+): Promise<void> {
+  const currentTest = browser?.currentTest as NightwatchCurrentTest | undefined
+  const testcases = currentTest?.results?.testcases ?? {}
+  for (const [, suite] of (
+    ctx.suiteManager?.getAllSuites() ?? new Map()
+  ).entries()) {
+    ctx.testManager.finalizeSuiteTests(suite, testcases)
+    await new Promise((resolve) =>
+      setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY)
+    )
+    ctx.suiteManager?.finalizeSuite(suite)
+  }
+  await new Promise((resolve) =>
+    setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY)
+  )
+}
+
+export function logRunSummary(ctx: RunLifecycleCtx): void {
+  const summary = [
+    ctx.passCount > 0 ? `${ctx.passCount} passed` : null,
+    ctx.failCount > 0 ? `${ctx.failCount} failed` : null,
+    ctx.skipCount > 0 ? `${ctx.skipCount} skipped` : null
+  ]
+    .filter(Boolean)
+    .join('  ')
+  log.info(`${ctx.failCount > 0 ? '❌' : '✅'} Tests complete!  ${summary}`)
+  log.info(`   DevTools UI: http://${ctx.options.hostname}:${ctx.options.port}`)
+}
+
+export async function waitForDevtoolsBrowserClose(
+  ctx: RunLifecycleCtx
+): Promise<void> {
+  if (!ctx.devtoolsBrowser) {
+    return
+  }
+  ;(logger as { setLevel: (ns: string, lvl: string) => void }).setLevel(
+    'devtools',
+    'warn'
+  )
+  let exitBySignal = false
+  const signalHandler = () => {
+    exitBySignal = true
+    log.info('\n✓ Exiting... Browser window will remain open')
+    process.exit(0)
+  }
+  process.once('SIGINT', signalHandler)
+  process.once('SIGTERM', signalHandler)
+  while (true) {
+    try {
+      await ctx.devtoolsBrowser.getTitle()
+      await new Promise((res) => setTimeout(res, TIMING.BROWSER_POLL_INTERVAL))
+    } catch {
+      if (!exitBySignal) {
+        log.info('Browser window closed, stopping DevTools app')
+        break
+      }
+    }
+  }
+  if (exitBySignal) {
+    return
+  }
+  process.removeListener('SIGINT', signalHandler)
+  process.removeListener('SIGTERM', signalHandler)
+  ;(logger as { setLevel: (ns: string, lvl: string) => void }).setLevel(
+    'devtools',
+    'info'
+  )
+  try {
+    await ctx.devtoolsBrowser.deleteSession()
+  } catch {
+    /* session already closed */
+  }
+  await stop()
+  process.exit(0)
+}
diff --git a/packages/nightwatch-devtools/src/screencast.ts b/packages/nightwatch-devtools/src/screencast.ts
new file mode 100644
index 00000000..26c7a2f5
--- /dev/null
+++ b/packages/nightwatch-devtools/src/screencast.ts
@@ -0,0 +1,50 @@
+import logger from '@wdio/logger'
+import { ScreencastRecorderBase, errorMessage } from '@wdio/devtools-core'
+import type { ScreencastOptions } from '@wdio/devtools-shared'
+import type { SessionCapturer } from './session.js'
+import type { NightwatchBrowser } from './types.js'
+
+const log = logger('@wdio/nightwatch-devtools:ScreencastRecorder')
+
+/**
+ * Nightwatch screencast recorder. Polling-only — Nightwatch doesn't expose a
+ * stable CDP escape hatch the way WDIO (getPuppeteer) and Selenium
+ * (createCDPConnection) do.
+ *
+ * `browser.takeScreenshot()` goes through Nightwatch's command queue and is
+ * unreliable for polling (the existing code has `takeScreenshotViaHttp` for
+ * the same reason — see session.ts). The recorder delegates to that helper
+ * instead so screenshots fire directly over the WebDriver HTTP transport.
+ */
+export class ScreencastRecorder extends ScreencastRecorderBase<NightwatchBrowser> {
+  readonly #sessionCapturer: SessionCapturer
+
+  constructor(sessionCapturer: SessionCapturer, options: ScreencastOptions) {
+    super(options)
+    this.#sessionCapturer = sessionCapturer
+  }
+
+  protected override onPollingStarted(intervalMs: number): void {
+    log.info(
+      `✓ Screencast recording started (polling mode, ${intervalMs} ms interval)`
+    )
+  }
+
+  protected override onPollingStopped(frameCount: number): void {
+    log.info(`✓ Screencast stopped — ${frameCount} frame(s) collected`)
+  }
+
+  protected override onUnavailable(err: unknown): void {
+    log.warn(
+      `Screencast unavailable (${errorMessage(err)}). Recording skipped.`
+    )
+  }
+
+  protected override async takeScreenshot(): Promise<string | null> {
+    const browser = this.driver
+    if (!browser) {
+      return null
+    }
+    return this.#sessionCapturer.takeScreenshotViaHttp(browser)
+  }
+}
diff --git a/packages/nightwatch-devtools/src/session-init.ts b/packages/nightwatch-devtools/src/session-init.ts
new file mode 100644
index 00000000..5b7b29c9
--- /dev/null
+++ b/packages/nightwatch-devtools/src/session-init.ts
@@ -0,0 +1,268 @@
+/**
+ * Session-initialization lifecycle helpers for the Nightwatch plugin.
+ *
+ * Extracted from the plugin class to keep `index.ts` under the file-size
+ * cap. The plugin passes itself as a `SessionInitCtx` — a narrow interface
+ * exposing only the fields and methods these helpers need.
+ *
+ * Includes:
+ *   - Per-session bringup (capturer + reporter chain + metadata + BiDi + screencast)
+ *   - Session-change cleanup
+ *   - Screencast finalize-and-clear
+ */
+
+import logger from '@wdio/logger'
+import {
+  finalizeScreencast,
+  resolveAdapterOutputDir
+} from '@wdio/devtools-core'
+import { TraceType } from './types.js'
+import { TIMING } from './constants.js'
+import { SessionCapturer } from './session.js'
+import { TestReporter } from './reporter.js'
+import { TestManager } from './helpers/testManager.js'
+import { SuiteManager } from './helpers/suiteManager.js'
+import { BrowserProxy } from './helpers/browserProxy.js'
+import { ScreencastRecorder } from './screencast.js'
+import type {
+  NightwatchBrowser,
+  ScreencastOptions,
+  SuiteStats
+} from './types.js'
+
+const log = logger('@wdio/nightwatch-devtools:session-init')
+
+export interface SessionInitCtx {
+  readonly hostname: string
+  readonly port: number
+  readonly screencastOptions: ScreencastOptions
+  readonly bidiEnabled: boolean
+
+  sessionCapturer: SessionCapturer
+  testReporter: TestReporter
+  testManager: TestManager
+  suiteManager: SuiteManager
+  browserProxy: BrowserProxy
+  isScriptInjected: boolean
+
+  lastSessionId: string | null
+  bidiAttachAttempted: boolean
+  srcFolders: string[]
+  screencastRecorder: ScreencastRecorder | undefined
+  screencastSessionId: string | undefined
+  configPath: string | undefined
+
+  getCurrentTest(): unknown
+  getCurrentScenarioSuite(): SuiteStats | null
+  buildMetadataOptions(): unknown
+}
+
+async function handleSessionChange(
+  ctx: SessionInitCtx,
+  finalizeCurrent: () => Promise<void>
+): Promise<void> {
+  log.info('Browser session changed — reconnecting WebSocket only')
+  ctx.isScriptInjected = false
+  // Reset BiDi-attach state so the new session gets its own attach —
+  // inspectors are bound to a specific driver instance and don't carry
+  // across sessions. Without this, only the first session captures via
+  // BiDi and the rest silently fall back to the perf-log path.
+  ctx.bidiAttachAttempted = false
+  // Finalize the previous session's screencast BEFORE we tear down its
+  // capturer — encode + broadcast use the existing WS connection.
+  await finalizeCurrent()
+  ctx.sessionCapturer?.cleanup()
+  // Intentional null-out — the next call to ensureSessionInitialized
+  // reassigns. Cast through unknown so the strict field type passes.
+  ctx.sessionCapturer = null as unknown as SessionCapturer
+}
+
+function initReporterChain(ctx: SessionInitCtx): void {
+  // First-time setup: create reporter chain once for the entire run.
+  // These must NOT be recreated on session change — doing so generates a
+  // new feature suite with a fresh start timestamp, which DataManager sees
+  // as a new run and wipes all accumulated commands.
+  ctx.testReporter = new TestReporter((suitesData) => {
+    if (ctx.sessionCapturer) {
+      ctx.sessionCapturer.sendUpstream('suites', suitesData)
+    }
+  })
+  ctx.testManager = new TestManager(ctx.testReporter)
+  ctx.suiteManager = new SuiteManager(ctx.testReporter)
+  ctx.browserProxy = new BrowserProxy(
+    ctx.sessionCapturer,
+    ctx.testManager,
+    () => ctx.getCurrentTest() ?? ctx.getCurrentScenarioSuite()
+  )
+}
+
+function rebindReporterToNewSession(ctx: SessionInitCtx): void {
+  // Session change: update the reporter's upstream callback to use the new
+  // WebSocket, update the proxy's capturer reference (avoids re-wrapping
+  // already-wrapped browser methods which would double-capture commands),
+  // then replay current suite state to the newly-connected UI.
+  ctx.testReporter.updateUpstream((suitesData) => {
+    if (ctx.sessionCapturer) {
+      ctx.sessionCapturer.sendUpstream('suites', suitesData)
+    }
+  })
+  ctx.browserProxy.updateSessionCapturer(ctx.sessionCapturer)
+  ctx.testReporter.updateSuites()
+}
+
+function broadcastSessionMetadata(
+  ctx: SessionInitCtx,
+  browser: NightwatchBrowser
+): void {
+  const capabilities = browser.capabilities || {}
+  const desiredCapabilities = browser.desiredCapabilities || {}
+  const sessionId = browser.sessionId
+  const opts = browser.options || {}
+
+  if (ctx.srcFolders.length === 0) {
+    const sf = (opts as { src_folders?: string | string[] }).src_folders
+    ctx.srcFolders = Array.isArray(sf) ? sf : sf ? [sf] : []
+  }
+
+  ctx.sessionCapturer.sendUpstream('metadata', {
+    type: TraceType.Testrunner,
+    capabilities,
+    desiredCapabilities,
+    sessionId,
+    testEnv: opts.testEnv,
+    host: opts.webdriver?.host,
+    options: ctx.buildMetadataOptions(),
+    url: ''
+  })
+
+  const browserName =
+    capabilities.browserName || desiredCapabilities.browserName || 'unknown'
+  const browserVersion =
+    capabilities.browserVersion ||
+    (capabilities as { version?: string }).version ||
+    ''
+  log.info(
+    `✓ Browser: ${browserName}${browserVersion ? ' ' + browserVersion : ''} (session: ${sessionId})`
+  )
+
+  const loggingPrefs = ((capabilities as Record<string, unknown>)[
+    'goog:loggingPrefs'
+  ] ||
+    (desiredCapabilities as Record<string, unknown>)['goog:loggingPrefs'] ||
+    {}) as { performance?: string }
+  if (!loggingPrefs.performance && !ctx.bidiEnabled) {
+    log.warn(
+      "⚠  Network tab will be empty — add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities (or enable bidi:true)"
+    )
+  }
+}
+
+// BiDi: opt-in. Requires `webSocketUrl: true` capability + a BiDi-capable
+// chromedriver. We attempt once per session; on failure or unavailability
+// the perf-log fallback path continues to work.
+async function tryAttachBidi(
+  ctx: SessionInitCtx,
+  browser: NightwatchBrowser
+): Promise<void> {
+  if (!ctx.bidiEnabled || ctx.bidiAttachAttempted) {
+    return
+  }
+  ctx.bidiAttachAttempted = true
+  const driver = (browser as { driver?: unknown }).driver
+  if (!driver) {
+    log.warn('bidi:true set but browser.driver unavailable — skipping')
+    return
+  }
+  const { attachBidiHandlers, buildBidiSinks } = await import('./bidi.js')
+  const ok = await attachBidiHandlers(
+    driver,
+    buildBidiSinks(ctx.sessionCapturer)
+  )
+  if (ok) {
+    ctx.sessionCapturer.bidiActive = true
+    log.info('✓ BiDi attached — perf-log network capture disabled')
+  }
+}
+
+// Screencast: start a fresh recorder per browser session — every
+// reloadSession / per-test browser produces its own .webm, matching
+// the WDIO service behavior. Polling mode only (Nightwatch has no
+// stable CDP escape hatch). Finalized when the next session change
+// fires or when after() runs.
+async function tryStartScreencast(
+  ctx: SessionInitCtx,
+  browser: NightwatchBrowser,
+  sessionId: string | undefined
+): Promise<void> {
+  if (!ctx.screencastOptions.enabled || ctx.screencastRecorder || !sessionId) {
+    return
+  }
+  ctx.screencastRecorder = new ScreencastRecorder(
+    ctx.sessionCapturer,
+    ctx.screencastOptions
+  )
+  ctx.screencastSessionId = sessionId
+  log.info(`🎬 Starting screencast for session ${sessionId}`)
+  await ctx.screencastRecorder.start(browser)
+}
+
+export async function ensureSessionInitialized(
+  ctx: SessionInitCtx,
+  browser: NightwatchBrowser,
+  finalizeCurrentScreencast: () => Promise<void>
+): Promise<void> {
+  const currentSessionId = browser.sessionId
+  const isSessionChange =
+    currentSessionId &&
+    ctx.lastSessionId &&
+    currentSessionId !== ctx.lastSessionId
+  if (isSessionChange) {
+    await handleSessionChange(ctx, finalizeCurrentScreencast)
+  }
+  ctx.lastSessionId = currentSessionId ?? null
+  if (ctx.sessionCapturer) {
+    return
+  }
+  await new Promise((resolve) =>
+    setTimeout(resolve, TIMING.INITIAL_CONNECTION_WAIT)
+  )
+  ctx.sessionCapturer = new SessionCapturer(
+    { port: ctx.port, hostname: ctx.hostname },
+    browser
+  )
+  const connected = await ctx.sessionCapturer.waitForConnection(3000)
+  if (!connected) {
+    log.error('❌ Worker WebSocket failed to connect!')
+  }
+  if (!ctx.testReporter) {
+    initReporterChain(ctx)
+  } else {
+    rebindReporterToNewSession(ctx)
+  }
+  broadcastSessionMetadata(ctx, browser)
+  await tryAttachBidi(ctx, browser)
+  await tryStartScreencast(ctx, browser, browser.sessionId)
+}
+
+export async function finalizeCurrentScreencast(
+  ctx: SessionInitCtx
+): Promise<void> {
+  if (!ctx.screencastRecorder || !ctx.screencastSessionId) {
+    return
+  }
+  await finalizeScreencast({
+    recorder: ctx.screencastRecorder,
+    sessionId: ctx.screencastSessionId,
+    filenamePrefix: 'nightwatch-video',
+    outputDir: resolveAdapterOutputDir({
+      testFilePath: ctx.browserProxy?.getCurrentTestFullPath?.() ?? undefined,
+      configPath: ctx.configPath
+    }),
+    captureFormat: ctx.screencastOptions.captureFormat,
+    sendUpstream: (scope, data) =>
+      ctx.sessionCapturer?.sendUpstream(scope, data),
+    onLog: (level, message) => log[level](message)
+  })
+  ctx.screencastRecorder = undefined
+  ctx.screencastSessionId = undefined
+}
diff --git a/packages/nightwatch-devtools/src/session.ts b/packages/nightwatch-devtools/src/session.ts
index e00fada3..d316f95e 100644
--- a/packages/nightwatch-devtools/src/session.ts
+++ b/packages/nightwatch-devtools/src/session.ts
@@ -1,287 +1,165 @@
-import fs from 'node:fs/promises'
 import http from 'node:http'
-import path from 'node:path'
-import { createRequire } from 'node:module'
 import logger from '@wdio/logger'
-import { WebSocket } from 'ws'
 import {
-  CONSOLE_METHODS,
-  LOG_SOURCES,
-  NAVIGATION_COMMANDS,
-  SPINNER_RE
-} from './constants.js'
-import {
-  stripAnsiCodes,
-  detectLogLevel,
+  SessionCapturerBase,
   createConsoleLogEntry,
-  chromeLogLevelToLogLevel,
-  getRequestType
-} from './helpers/utils.js'
-import { CAPTURE_PERFORMANCE_SCRIPT } from './helpers/capturePerformance.js'
-import type {
-  CommandLog,
-  ConsoleLog,
-  LogLevel,
-  NightwatchBrowser
-} from './types.js'
-
-const require = createRequire(import.meta.url)
+  errorMessage,
+  loadInjectableScript,
+  mapChromeBrowserLogs,
+  pollUntilReady,
+  serializeError,
+  type LogSource
+} from '@wdio/devtools-core'
+import { NAVIGATION_COMMANDS } from './constants.js'
+import {
+  parseNetworkFromPerfLogs,
+  dedupeNetworkRequests,
+  type NetworkEntry,
+  type PerfLogEntry
+} from './helpers/perfLogs.js'
+import {
+  CAPTURE_PERFORMANCE_SCRIPT,
+  type CapturedPerformancePayload,
+  applyPerformanceData
+} from '@wdio/devtools-core'
+import type { CommandLog, LogLevel, NightwatchBrowser } from './types.js'
+
 const log = logger('@wdio/nightwatch-devtools:SessionCapturer')
 
-export class SessionCapturer {
-  #ws: WebSocket | undefined
-  #originalConsoleMethods: Record<
-    (typeof CONSOLE_METHODS)[number],
-    typeof console.log
-  >
-  #originalProcessMethods: {
-    stdoutWrite: typeof process.stdout.write
-    stderrWrite: typeof process.stderr.write
+/**
+ * WebDriver responses are sometimes wrapped as `{ value: T }` (the W3C
+ * protocol shape) and sometimes flat. This helper unwraps the value field
+ * if present, otherwise returns the input as-is.
+ */
+function unwrapDriverValue<T = unknown>(result: unknown): T {
+  if (result && typeof result === 'object' && 'value' in result) {
+    return (result as { value: T }).value
   }
-  #isCapturingConsole = false
+  return result as T
+}
+
+type LooseRec = Record<string, unknown>
+const getProp = (obj: unknown, key: string): unknown =>
+  obj && typeof obj === 'object' ? (obj as LooseRec)[key] : undefined
+const getPath = (obj: unknown, ...path: string[]): unknown =>
+  path.reduce<unknown>((acc, k) => getProp(acc, k), obj)
+const firstDefined = (obj: unknown, ...keys: string[]): unknown => {
+  if (!obj || typeof obj !== 'object') {
+    return undefined
+  }
+  const rec = obj as LooseRec
+  for (const k of keys) {
+    const v = rec[k]
+    if (v !== undefined && v !== null) {
+      return v
+    }
+  }
+  return undefined
+}
+
+/**
+ * Walks Nightwatch's internal config (transport / queue.transport /
+ * nightwatchInstance — none of which are on the public NightwatchBrowser
+ * type) to find the underlying WebDriver host+port for direct screenshot
+ * fetches that bypass the command queue.
+ */
+function resolveWebDriverAddress(browser: NightwatchBrowser): {
+  driverHost: string
+  driverPort: number
+} {
+  const transportSettings =
+    getPath(browser, 'transport', 'settings', 'webdriver') ||
+    getPath(browser, 'queue', 'transport', 'settings', 'webdriver') ||
+    getPath(
+      browser,
+      'nightwatchInstance',
+      'transport',
+      'settings',
+      'webdriver'
+    ) ||
+    {}
+  const opts = getProp(browser, 'options') ?? {}
+  const nightwatchSettings =
+    getPath(browser, 'nightwatchInstance', 'settings') ||
+    getPath(browser, 'globals', 'nightwatchInstance', 'settings') ||
+    {}
+  const driverHost = String(
+    firstDefined(transportSettings, 'host', 'server_address') ||
+      firstDefined(getProp(opts, 'webdriver'), 'host') ||
+      firstDefined(getProp(nightwatchSettings, 'webdriver'), 'host') ||
+      'localhost'
+  )
+  const driverPort = Number(
+    firstDefined(transportSettings, 'port') ||
+      firstDefined(getProp(opts, 'webdriver'), 'port') ||
+      firstDefined(getProp(nightwatchSettings, 'webdriver'), 'port') ||
+      9515
+  )
+  return { driverHost, driverPort }
+}
+
+export class SessionCapturer extends SessionCapturerBase {
   #browser: NightwatchBrowser | undefined
-  #commandCounter = 0
-  #sentCommandIds = new Set<number>()
 
-  commandsLog: CommandLog[] = []
-  sources = new Map<string, string>()
-  consoleLogs: ConsoleLog[] = []
-  mutations: any[] = []
-  traceLogs: string[] = []
-  networkRequests: any[] = []
-  metadata?: any
+  // True once BiDi inspectors are attached — the per-command perf-log network
+  // capture path skips when set, so we don't double-emit network requests.
+  bidiActive = false
 
   constructor(
     devtoolsOptions: { hostname?: string; port?: number } = {},
     browser?: NightwatchBrowser
   ) {
-    const { port, hostname } = devtoolsOptions
+    super(devtoolsOptions)
     this.#browser = browser
-    if (hostname && port) {
-      this.#ws = new WebSocket(`ws://${hostname}:${port}/worker`)
-
-      this.#ws.on('open', () => {
-        this.#hasConnected = true
-        log.info('✓ Worker WebSocket connected to backend')
-      })
-
-      this.#ws.on('error', (err: unknown) =>
-        log.error(
-          `Couldn't connect to devtools backend: ${(err as Error).message}`
-        )
-      )
-
-      this.#ws.on('close', () => {
-        log.info('Worker WebSocket disconnected')
-      })
-    }
-
-    this.#originalConsoleMethods = {
-      log: console.log,
-      info: console.info,
-      warn: console.warn,
-      error: console.error
-    }
-
-    this.#originalProcessMethods = {
-      stdoutWrite: process.stdout.write.bind(process.stdout),
-      stderrWrite: process.stderr.write.bind(process.stderr)
-    }
-
-    this.#patchConsole()
-    this.#interceptProcessStreams()
+    this.patchConsole()
+    this.patchStreams()
   }
 
-  #patchConsole() {
-    CONSOLE_METHODS.forEach((method) => {
-      const originalMethod = this.#originalConsoleMethods[method]
-      console[method] = (...consoleArgs: any[]) => {
-        this.#isCapturingConsole = true
-        const result = originalMethod.apply(console, consoleArgs)
-        this.#isCapturingConsole = false
-
-        // Capture all console output; strip ANSI codes for clean display in UI
-        const rawText = consoleArgs
-          .map((a) =>
-            typeof a === 'object' && a !== null ? JSON.stringify(a) : String(a)
-          )
-          .join(' ')
-        const cleanText = stripAnsiCodes(rawText).trim()
-        if (!cleanText) {
-          return result
-        }
-
-        const logEntry = createConsoleLogEntry(
-          method as LogLevel,
-          [cleanText],
-          LOG_SOURCES.TEST
-        )
-        this.consoleLogs.push(logEntry)
-        this.sendUpstream('consoleLogs', [logEntry])
-
-        return result
-      }
-    })
+  protected override onWsOpen(): void {
+    log.info('✓ Worker WebSocket connected to backend')
   }
 
-  #isInternalStreamLine(line: string): boolean {
-    const t = line.trim()
-    return (
-      t.startsWith('{"') ||
-      t.includes('@wdio/devtools-backend') ||
-      t.startsWith('[SESSION]')
-    )
+  protected override onWsError(err: unknown): void {
+    log.error(`Couldn't connect to devtools backend: ${errorMessage(err)}`)
   }
 
-  #hasConnected = false
-  #isCapturingStream = false
-
-  #interceptProcessStreams() {
-    const captureTerminalOutput = (outputData: string | Uint8Array) => {
-      if (this.#isCapturingStream) {
-        return
-      }
-      const outputText =
-        typeof outputData === 'string' ? outputData : outputData.toString()
-      if (!outputText?.trim()) {
-        return
-      }
-
-      this.#isCapturingStream = true
-      try {
-        const linesToCapture: string[] = []
-
-        for (const rawLine of outputText.split('\n')) {
-          const segments = rawLine.split('\r').filter((s) => s.trim())
-          const lastSegment = segments[segments.length - 1] ?? rawLine
-          const clean = stripAnsiCodes(lastSegment).trim()
-          if (
-            !clean ||
-            this.#isInternalStreamLine(clean) ||
-            SPINNER_RE.test(clean)
-          ) {
-            continue
-          }
-          linesToCapture.push(clean)
-        }
-
-        for (const clean of linesToCapture) {
-          const logEntry = createConsoleLogEntry(
-            detectLogLevel(clean),
-            [clean],
-            LOG_SOURCES.TERMINAL
-          )
-          this.consoleLogs.push(logEntry)
-          this.sendUpstream('consoleLogs', [logEntry])
-        }
-      } finally {
-        this.#isCapturingStream = false
-      }
-    }
-
-    const interceptStreamWrite = (
-      stream: NodeJS.WriteStream,
-      originalWriteMethod: (...args: any[]) => boolean
-    ) => {
-      const capturer = this
-      stream.write = function (chunk: any, ...additionalArgs: any[]): boolean {
-        const writeResult = originalWriteMethod.call(
-          stream,
-          chunk,
-          ...additionalArgs
-        )
-        if (chunk && !capturer.#isCapturingConsole) {
-          captureTerminalOutput(chunk)
-        }
-        return writeResult
-      } as any
-    }
-
-    interceptStreamWrite(
-      process.stdout,
-      this.#originalProcessMethods.stdoutWrite
-    )
-    interceptStreamWrite(
-      process.stderr,
-      this.#originalProcessMethods.stderrWrite
-    )
-  }
-
-  #restoreConsole() {
-    CONSOLE_METHODS.forEach((method) => {
-      console[method] = this.#originalConsoleMethods[method]
-    })
-  }
-
-  #restoreProcessStreams() {
-    process.stdout.write = this.#originalProcessMethods.stdoutWrite as any
-    process.stderr.write = this.#originalProcessMethods.stderrWrite as any
-  }
-
-  cleanup() {
-    this.#restoreConsole()
-    this.#restoreProcessStreams()
-  }
-
-  get isReportingUpstream() {
-    return Boolean(this.#ws) && this.#ws?.readyState === WebSocket.OPEN
+  protected override onWsClose(): void {
+    log.info('Worker WebSocket disconnected')
   }
 
   /**
-   * Wait for WebSocket to connect
+   * Push every captured line into the local `consoleLogs` array so it ends up
+   * in any future trace export, in addition to the live WS broadcast.
    */
-  async waitForConnection(timeoutMs: number = 5000): Promise<boolean> {
-    if (!this.#ws) {
-      return false
-    }
-
-    if (this.#ws.readyState === WebSocket.OPEN) {
-      return true
-    }
-
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        log.warn(`WebSocket connection timeout after ${timeoutMs}ms`)
-        resolve(false)
-      }, timeoutMs)
-
-      this.#ws!.once('open', () => {
-        clearTimeout(timeout)
-        resolve(true)
-      })
-
-      this.#ws!.once('error', () => {
-        clearTimeout(timeout)
-        resolve(false)
-      })
-    })
-  }
-
-  #serializeError(error: Error | undefined) {
-    return error
-      ? { name: error.name, message: error.message, stack: error.stack }
-      : undefined
+  protected override onLine(
+    type: LogLevel,
+    args: string[],
+    source: LogSource
+  ): void {
+    const entry = createConsoleLogEntry(type, args, source)
+    this.consoleLogs.push(entry)
+    this.sendUpstream('consoleLogs', [entry])
   }
 
   async captureCommand(
     command: string,
-    args: any[],
-    result: any,
+    args: unknown[],
+    result: unknown,
     error: Error | undefined,
     testUid?: string,
     callSource?: string,
     timestamp?: number
   ): Promise<boolean> {
     // Serialize error properly (Error objects don't JSON.stringify well)
-    const serializedError = this.#serializeError(error)
+    const serializedError = serializeError(error)
 
-    const commandId = this.#commandCounter++
+    const commandId = this.commandCounter++
     const commandLogEntry: CommandLog & { _id?: number } = {
       _id: commandId,
       command,
       args,
       result,
-      error: serializedError as any,
+      error: serializedError,
       timestamp: timestamp || Date.now(),
       callSource,
       testUid
@@ -294,9 +172,7 @@ export class SessionCapturer {
     )
     if (isNavigationCommand && this.#browser && !error) {
       this.#capturePerformanceData(commandLogEntry, args).catch((err) => {
-        log.warn(
-          `Failed to capture performance data: ${(err as Error).message}`
-        )
+        log.warn(`Failed to capture performance data: ${errorMessage(err)}`)
       })
     }
 
@@ -305,49 +181,18 @@ export class SessionCapturer {
 
   async #capturePerformanceData(
     commandLogEntry: CommandLog & { _id?: number },
-    args: any[]
+    args: unknown[]
   ) {
     await new Promise((resolve) => setTimeout(resolve, 500))
-
-    const performanceData = await this.#browser!.execute(
-      CAPTURE_PERFORMANCE_SCRIPT
+    const raw = await this.#browser!.execute(CAPTURE_PERFORMANCE_SCRIPT)
+    const payload = unwrapDriverValue<CapturedPerformancePayload | undefined>(
+      raw
+    )
+    applyPerformanceData(
+      commandLogEntry,
+      payload,
+      typeof args[0] === 'string' ? args[0] : undefined
     )
-
-    let data: any
-    if (performanceData && typeof performanceData === 'object') {
-      data =
-        'value' in performanceData
-          ? (performanceData as any).value
-          : performanceData
-    }
-
-    if (data && data.navigation) {
-      commandLogEntry.performance = {
-        navigation: data.navigation,
-        resources: data.resources
-      }
-      commandLogEntry.cookies = data.cookies
-      commandLogEntry.documentInfo = data.documentInfo
-      commandLogEntry.result = {
-        url: args[0],
-        loadTime: data.navigation?.timing?.loadTime,
-        resources: data.resources,
-        resourceCount: data.resources?.length,
-        cookies: data.cookies,
-        title: data.documentInfo?.title
-      }
-    }
-  }
-
-  /** Send a command to the UI (only if not already sent) */
-  sendCommand(command: CommandLog & { _id?: number }) {
-    if (command._id !== undefined && !this.#sentCommandIds.has(command._id)) {
-      this.#sentCommandIds.add(command._id)
-      // Remove internal ID before sending
-      const commandToSend = { ...command }
-      delete commandToSend._id
-      this.sendUpstream('commands', [commandToSend])
-    }
   }
 
   /**
@@ -360,31 +205,33 @@ export class SessionCapturer {
   replaceCommand(
     oldId: number,
     command: string,
-    args: any[],
-    result: any,
+    args: unknown[],
+    result: unknown,
     error: Error | undefined,
     testUid?: string,
     callSource?: string,
     timestamp?: number
   ): { entry: CommandLog & { _id?: number }; oldTimestamp: number } {
     // Remove the superseded entry and capture its timestamp for the UI
-    const idx = this.commandsLog.findIndex((c: any) => c._id === oldId)
+    const idx = this.commandsLog.findIndex(
+      (c) => (c as CommandLog & { _id?: number })._id === oldId
+    )
     const oldTimestamp: number =
-      idx !== -1 ? ((this.commandsLog[idx] as any).timestamp ?? 0) : 0
+      idx !== -1 ? (this.commandsLog[idx]?.timestamp ?? 0) : 0
     if (idx !== -1) {
       this.commandsLog.splice(idx, 1)
     }
     // Allow the slot to be re-used by a new entry
-    this.#sentCommandIds.delete(oldId)
+    this.sentCommandIds.delete(oldId)
 
-    const serializedError = this.#serializeError(error)
-    const commandId = this.#commandCounter++
+    const serializedError = serializeError(error)
+    const commandId = this.commandCounter++
     const entry: CommandLog & { _id?: number } = {
       _id: commandId,
       command,
       args,
       result,
-      error: serializedError as any,
+      error: serializedError,
       timestamp: timestamp || Date.now(),
       callSource,
       testUid
@@ -393,70 +240,28 @@ export class SessionCapturer {
     return { entry, oldTimestamp }
   }
 
-  /** Send a replace-command event to the UI (swaps old entry in-place) */
-  sendReplaceCommand(
-    oldTimestamp: number,
-    command: CommandLog & { _id?: number }
-  ) {
-    const commandToSend = { ...command }
-    delete commandToSend._id
-    this.sendUpstream('replaceCommand', {
-      oldTimestamp,
-      command: commandToSend
-    })
-  }
-
   /**
    * Take a screenshot by calling the WebDriver HTTP endpoint directly.
    * This completely bypasses Nightwatch's command queue so there is no risk
    * of the request being appended after `end()` / `quit()`.
    */
+  // Nightwatch's internal config lives at non-public paths (transport,
+  // queue.transport, nightwatchInstance.settings, globals.nightwatchInstance);
+  // none are in the NightwatchBrowser type. Cast for dynamic access.
+  #resolveDriverEndpoint(
+    browser: NightwatchBrowser,
+    sessionId: string
+  ): string {
+    const { driverHost, driverPort } = resolveWebDriverAddress(browser)
+    return `http://${driverHost}:${driverPort}/session/${sessionId}/screenshot`
+  }
+
   takeScreenshotViaHttp(browser: NightwatchBrowser): Promise<string | null> {
-    const browserAny = browser as any
-    const sessionId = browserAny.sessionId
+    const sessionId = (browser as unknown as { sessionId?: string }).sessionId
     if (!sessionId) {
       return Promise.resolve(null)
     }
-
-    const pick = (obj: any, ...keys: string[]): any => {
-      if (!obj || typeof obj !== 'object') {
-        return undefined
-      }
-      for (const k of keys) {
-        const val = obj[k]
-        if (val !== undefined && val !== null) {
-          return val
-        }
-      }
-      return undefined
-    }
-
-    const transportSettings =
-      browserAny.transport?.settings?.webdriver ||
-      browserAny.queue?.transport?.settings?.webdriver ||
-      browserAny.nightwatchInstance?.transport?.settings?.webdriver ||
-      {}
-
-    const opts = browserAny.options || {}
-    const nightwatchSettings =
-      browserAny.nightwatchInstance?.settings ||
-      browserAny.globals?.nightwatchInstance?.settings ||
-      {}
-
-    const driverHost: string =
-      pick(transportSettings, 'host', 'server_address') ||
-      pick(opts.webdriver, 'host') ||
-      pick(nightwatchSettings.webdriver, 'host') ||
-      'localhost'
-
-    const driverPort: number =
-      pick(transportSettings, 'port') ||
-      pick(opts.webdriver, 'port') ||
-      pick(nightwatchSettings.webdriver, 'port') ||
-      9515
-
-    const endpoint = `http://${driverHost}:${driverPort}/session/${sessionId}/screenshot`
-
+    const endpoint = this.#resolveDriverEndpoint(browser, sessionId)
     return new Promise((resolve) => {
       const req = http.get(endpoint, (res) => {
         let body = ''
@@ -478,7 +283,7 @@ export class SessionCapturer {
       })
       req.on('error', (err) => {
         log.warn(
-          `[screenshot] HTTP request failed (${endpoint}): ${(err as Error).message}`
+          `[screenshot] HTTP request failed (${endpoint}): ${errorMessage(err)}`
         )
         resolve(null)
       })
@@ -490,98 +295,44 @@ export class SessionCapturer {
     })
   }
 
-  /** Capture test source code */
-  async captureSource(filePath: string) {
-    if (!this.sources.has(filePath)) {
-      try {
-        const sourceCode = await fs.readFile(filePath, 'utf-8')
-        this.sources.set(filePath, sourceCode.toString())
-        this.sendUpstream('sources', { [filePath]: sourceCode.toString() })
-      } catch (err) {
-        log.warn(
-          `Failed to read source file ${filePath}: ${(err as Error).message}`
-        )
-      }
-    }
+  protected override onSourceReadError(filePath: string, err: unknown): void {
+    log.warn(`Failed to read source file ${filePath}: ${errorMessage(err)}`)
   }
 
-  /** Send data upstream to backend */
-  sendUpstream(event: string, data: any) {
-    if (!this.#ws || this.#ws.readyState !== WebSocket.OPEN) {
-      if (this.#hasConnected) {
-        log.warn(`[upstream] WebSocket not open — dropping "${event}" event`)
-      }
+  protected override onUpstreamDrop(
+    event: string,
+    reason: 'closed' | 'send-error',
+    err?: unknown
+  ): void {
+    if (reason === 'send-error') {
+      log.warn(`[upstream] Failed to send "${event}": ${errorMessage(err)}`)
       return
     }
-
-    try {
-      this.#ws.send(JSON.stringify({ scope: event, data }))
-    } catch (err) {
-      log.warn(
-        `[upstream] Failed to send "${event}": ${(err as Error).message}`
-      )
+    if (this.hasEverConnected()) {
+      log.warn(`[upstream] WebSocket not open — dropping "${event}" event`)
     }
   }
 
-  /** Returns true when the WebSocket is open. */
-  isConnected(): boolean {
-    return this.#ws?.readyState === WebSocket.OPEN
-  }
-
-  /**
-   * Gracefully close the WebSocket, waiting for any buffered messages to flush.
-   * Call this before process exit in reuse mode to prevent data loss.
-   */
-  async closeWebSocket(): Promise<void> {
-    if (!this.#ws || this.#ws.readyState === WebSocket.CLOSED) {
-      return
-    }
-    return new Promise<void>((resolve) => {
-      const timeout = setTimeout(resolve, 2000)
-      this.#ws!.once('close', () => {
-        clearTimeout(timeout)
-        resolve()
-      })
-      this.#ws!.close()
-    })
-  }
-
   /**
    * Inject the WDIO devtools script into the browser page
    */
   async injectScript(browser: NightwatchBrowser) {
     try {
-      // Load the preload script
-      const scriptPath = require.resolve('@wdio/devtools-script')
-      const scriptDir = path.dirname(scriptPath)
-      const preloadScriptPath = path.join(scriptDir, 'script.js')
-      let scriptContent = await fs.readFile(preloadScriptPath, 'utf-8')
-
-      // The script contains top-level await - wrap the entire script in async IIFE before injection
-      scriptContent = `(async function() { ${scriptContent} })()`
-
-      // Inject using script element - synchronous check after timeout
+      const scriptContent = await loadInjectableScript()
       const injectionScript = `
         const script = document.createElement('script');
         script.textContent = arguments[0];
         document.head.appendChild(script);
         return true;
       `
-
       await browser.execute(injectionScript, [scriptContent])
 
-      // Poll for collector — the async IIFE may take a moment to initialise
-      let hasCollector = false
-      for (let attempt = 0; attempt < 5; attempt++) {
-        await new Promise((resolve) => setTimeout(resolve, 200))
+      const hasCollector = await pollUntilReady(async () => {
         const checkResult = await browser.execute(
           'return typeof window.wdioTraceCollector !== "undefined"'
         )
-        hasCollector = ((checkResult as any)?.value ?? checkResult) === true
-        if (hasCollector) {
-          break
-        }
-      }
+        return unwrapDriverValue<unknown>(checkResult) === true
+      })
 
       if (hasCollector) {
         log.info('✓ Script injected and collector ready')
@@ -589,7 +340,7 @@ export class SessionCapturer {
         log.warn('Script injection may have failed — collector not found')
       }
     } catch (err) {
-      log.error(`Failed to inject script: ${(err as Error).message}`)
+      log.error(`Failed to inject script: ${errorMessage(err)}`)
       throw err
     }
   }
@@ -600,25 +351,19 @@ export class SessionCapturer {
    */
   async captureBrowserLogs(browser: NightwatchBrowser) {
     try {
-      const rawLogs = await (browser as any).getLog('browser')
-      const logs = ((rawLogs as any)?.value ?? rawLogs) as Array<{
-        level: string
-        message: string
-        source: string
-        timestamp: number
-      }>
+      const rawLogs = await (
+        browser as unknown as Record<string, (type: string) => Promise<unknown>>
+      ).getLog('browser')
+      const logs =
+        unwrapDriverValue<
+          Array<{ level: string; message: string; timestamp: number }>
+        >(rawLogs)
 
       if (!Array.isArray(logs) || logs.length === 0) {
         return
       }
 
-      const entries: ConsoleLog[] = logs.map((entry) => ({
-        timestamp: entry.timestamp,
-        type: chromeLogLevelToLogLevel(entry.level),
-        args: [entry.message],
-        source: LOG_SOURCES.BROWSER
-      }))
-
+      const entries = mapChromeBrowserLogs(logs)
       this.consoleLogs.push(...entries)
       this.sendUpstream('consoleLogs', entries)
     } catch {
@@ -631,127 +376,41 @@ export class SessionCapturer {
    * Requires loggingPrefs: { performance: 'ALL' } in Chrome capabilities.
    */
   async captureNetworkFromPerformanceLogs(browser: NightwatchBrowser) {
+    // BiDi network inspector is the source of truth when attached.
+    if (this.bidiActive) {
+      return
+    }
     try {
-      const rawLogs = await (browser as any).getLog('performance')
-      const logs = ((rawLogs as any)?.value ?? rawLogs) as Array<{
-        level: string
-        message: string
-        timestamp: number
-      }>
+      const rawLogs = await (
+        browser as unknown as Record<string, (type: string) => Promise<unknown>>
+      ).getLog('performance')
+      const logs = unwrapDriverValue<PerfLogEntry[]>(rawLogs)
 
       if (!Array.isArray(logs) || logs.length === 0) {
         return
       }
 
-      // Parse CDP Network.* events from the performance log
-      const pendingRequests = new Map<string, any>()
-      const networkEntries: any[] = []
-
-      for (const entry of logs) {
-        try {
-          const msg = JSON.parse(entry.message)
-          const { method, params } = msg.message
-
-          if (method === 'Network.requestWillBeSent') {
-            const { requestId, request: req, timestamp } = params
-            pendingRequests.set(requestId, {
-              id: `${entry.timestamp}-${requestId}`,
-              url: req.url,
-              method: req.method,
-              requestHeaders: req.headers,
-              timestamp: Math.round(timestamp * 1000),
-              startTime: entry.timestamp
-            })
-          } else if (method === 'Network.responseReceived') {
-            const { requestId, response } = params
-            const pending = pendingRequests.get(requestId)
-            if (pending) {
-              const responseHeaders: Record<string, string> = {}
-              for (const [k, v] of Object.entries(response.headers || {})) {
-                responseHeaders[k.toLowerCase()] = String(v)
-              }
-              pending.status = response.status
-              pending.statusText = response.statusText
-              pending.responseHeaders = responseHeaders
-              pending.mimeType = response.mimeType
-              pending.type = getRequestType(pending.url, response.mimeType)
-            }
-          } else if (method === 'Network.loadingFinished') {
-            const { requestId, encodedDataLength } = params
-            const pending = pendingRequests.get(requestId)
-            if (pending && pending.status !== undefined) {
-              pending.size = encodedDataLength
-              pending.endTime = entry.timestamp
-              pending.time = entry.timestamp - pending.startTime
-              networkEntries.push({ ...pending })
-              pendingRequests.delete(requestId)
-            }
-          } else if (method === 'Network.loadingFailed') {
-            const { requestId, errorText } = params
-            const pending = pendingRequests.get(requestId)
-            if (pending) {
-              pending.error = errorText
-              pending.endTime = entry.timestamp
-              pending.time = entry.timestamp - pending.startTime
-              networkEntries.push({ ...pending })
-              pendingRequests.delete(requestId)
-            }
-          }
-        } catch {
-          // skip malformed entries
-        }
+      const networkEntries = parseNetworkFromPerfLogs(logs)
+      if (networkEntries.length === 0) {
+        return
       }
 
-      if (networkEntries.length > 0) {
-        // Helper: for failed requests strip query string so that parallel
-        // autocomplete/prefetch requests to the same path (e.g. /search?q=W,
-        // /search?q=We, /search?q=Web…) collapse to a single entry.
-        const failedKey = (entry: any): string => {
-          try {
-            const u = new URL(entry.url)
-            return `err:${entry.method}:${u.origin}${u.pathname}`
-          } catch {
-            return `err:${entry.method}:${entry.url}`
-          }
-        }
-
-        const alreadySeen = new Set(
-          this.networkRequests.map((r: any) =>
-            r.error !== undefined
-              ? failedKey(r)
-              : `ok:${r.method}:${r.url}:${r.timestamp}`
-          )
-        )
-
-        const deduped: any[] = []
-        const seenFailedInBatch = new Map<string, number>()
-
-        for (const entry of networkEntries) {
-          if (entry.error !== undefined) {
-            const key = failedKey(entry)
-            if (alreadySeen.has(key)) {
-              continue
-            }
-            const existing = seenFailedInBatch.get(key)
-            if (existing !== undefined) {
-              deduped[existing] = entry // replace with latest failure
-            } else {
-              seenFailedInBatch.set(key, deduped.length)
-              deduped.push(entry)
-            }
-          } else {
-            const key = `ok:${entry.method}:${entry.url}:${entry.timestamp}`
-            if (!alreadySeen.has(key)) {
-              deduped.push(entry)
-            }
-          }
-        }
-
-        this.networkRequests.push(...deduped)
-        this.sendUpstream('networkRequests', deduped)
+      const deduped = dedupeNetworkRequests(
+        networkEntries,
+        this.networkRequests as NetworkEntry[]
+      )
+      if (deduped.length > 0) {
+        // NetworkEntry has `type?: string`; the shared NetworkRequest needs
+        // `type: string` so default the field at this framework boundary.
+        const normalized = deduped.map((d) => ({
+          ...d,
+          type: d.type ?? 'unknown'
+        }))
+        this.networkRequests.push(...normalized)
+        this.sendUpstream('networkRequests', normalized)
       }
     } catch (err) {
-      const msg = (err as Error).message ?? ''
+      const msg = errorMessage(err) ?? ''
       // Silently skip when performance logging was not enabled in capabilities
       if (!msg.includes('log type') && !msg.includes('performance')) {
         log.warn(`Performance log capture failed: ${msg}`)
@@ -771,8 +430,7 @@ export class SessionCapturer {
       const checkResult = await browser.execute(
         'return typeof window.wdioTraceCollector !== "undefined"'
       )
-      const collectorExists =
-        ((checkResult as any)?.value ?? checkResult) === true
+      const collectorExists = unwrapDriverValue<unknown>(checkResult) === true
 
       if (!collectorExists) {
         return
@@ -785,52 +443,25 @@ export class SessionCapturer {
         return window.wdioTraceCollector.getTraceData();
       `)
 
-      const traceData = (result as any)?.value ?? result
+      const traceData = unwrapDriverValue<Record<string, unknown> | null>(
+        result
+      )
       if (!traceData) {
         return
       }
 
-      const { mutations, traceLogs, consoleLogs, networkRequests, metadata } =
-        traceData
-
-      if (metadata) {
-        this.metadata = { ...this.metadata, ...metadata }
-        this.sendUpstream('metadata', this.metadata)
-      }
-
-      if (Array.isArray(consoleLogs) && consoleLogs.length > 0) {
-        const tagged = consoleLogs.map((e: any) => ({
-          ...e,
-          source: LOG_SOURCES.BROWSER
-        }))
-        this.consoleLogs.push(...tagged)
-        this.sendUpstream('consoleLogs', tagged)
-      }
-
-      if (Array.isArray(networkRequests) && networkRequests.length > 0) {
-        this.networkRequests.push(...networkRequests)
-        this.sendUpstream('networkRequests', networkRequests)
-      }
-
-      if (Array.isArray(mutations) && mutations.length > 0) {
-        this.mutations.push(...mutations)
-        this.sendUpstream('mutations', mutations)
-        log.info(`[trace] Captured ${mutations.length} DOM mutation(s)`)
-      }
-
-      if (Array.isArray(traceLogs) && traceLogs.length > 0) {
-        this.traceLogs.push(...traceLogs)
-        this.sendUpstream('logs', traceLogs)
-      }
-
-      if (Array.isArray(networkRequests) && networkRequests.length > 0) {
-        log.info(
-          `[trace] Captured ${networkRequests.length} network request(s)`
-        )
+      this.processTracePayload(traceData)
+      const mutationCount = Array.isArray(
+        (traceData as { mutations?: unknown }).mutations
+      )
+        ? (traceData as { mutations: unknown[] }).mutations.length
+        : 0
+      if (mutationCount > 0) {
+        log.info(`[trace] Captured ${mutationCount} DOM mutation(s)`)
       }
     } catch (err) {
       log.error(
-        `Failed to capture trace from injected script: ${(err as Error).message}`
+        `Failed to capture trace from injected script: ${errorMessage(err)}`
       )
     }
   }
diff --git a/packages/nightwatch-devtools/src/test-lifecycle.ts b/packages/nightwatch-devtools/src/test-lifecycle.ts
new file mode 100644
index 00000000..4bbd52e6
--- /dev/null
+++ b/packages/nightwatch-devtools/src/test-lifecycle.ts
@@ -0,0 +1,267 @@
+/**
+ * Test (Mocha/Jasmine-style) lifecycle helpers for the Nightwatch plugin.
+ *
+ * Extracted from the plugin class to keep `index.ts` under the file-size cap
+ * and to keep the per-test orchestration distinct from the cucumber path.
+ *
+ * The plugin passes itself as a `TestLifecycleCtx` — a narrow interface that
+ * exposes only the fields and methods these helpers need.
+ */
+
+import logger from '@wdio/logger'
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { TestManager } from './helpers/testManager.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { BrowserProxy } from './helpers/browserProxy.js'
+import type {
+  NightwatchBrowser,
+  NightwatchCurrentTest,
+  NightwatchTestCase,
+  NightwatchTestResults,
+  SuiteStats,
+  TestStats
+} from './types.js'
+import { DEFAULTS, TIMING, TEST_STATE } from './constants.js'
+import { resolveSpecFilePath } from './helpers/specFileResolver.js'
+import { closePreviousTest } from './helpers/closePreviousTest.js'
+import { extractTestMetadata, determineTestState } from './helpers/utils.js'
+
+const log = logger('@wdio/nightwatch-devtools:test-lifecycle')
+
+export interface TestLifecycleCtx {
+  readonly sessionCapturer: SessionCapturer
+  readonly testReporter: TestReporter
+  readonly testManager: TestManager
+  readonly suiteManager: SuiteManager
+  readonly browserProxy: BrowserProxy
+  readonly srcFolders: string[]
+  isScriptInjected: boolean
+  getRerunLabel(): string | undefined
+  incrementCount(state: TestStats['state']): void
+  testIcon(state: TestStats['state']): string
+  setCurrentTest(t: unknown): void
+}
+
+interface SuiteMetadata {
+  testFile: string
+  fullPath: string | null
+  suiteTitle: string
+  testNames: string[]
+  suiteLine: number | null
+  testLines: number[]
+}
+
+export function resolveSuiteMetadata(
+  ctx: TestLifecycleCtx,
+  currentTest: NightwatchCurrentTest
+): SuiteMetadata {
+  const moduleName = currentTest.module ?? ''
+  const testFile =
+    moduleName.split('/').pop() || moduleName || DEFAULTS.FILE_NAME
+  const fullPath = resolveSpecFilePath(
+    testFile,
+    moduleName,
+    ctx.srcFolders,
+    ctx.browserProxy.getCurrentTestFullPath() || undefined
+  )
+  if (!fullPath) {
+    log.warn(
+      `[beforeEach] Could not resolve file path for "${testFile}" — source view will be unavailable`
+    )
+  }
+  let suiteTitle = testFile
+  let testNames: string[] = []
+  let suiteLine: number | null = null
+  let testLines: number[] = []
+  if (fullPath) {
+    const parsed = extractTestMetadata(fullPath)
+    if (parsed.suiteTitle) {
+      suiteTitle = parsed.suiteTitle
+    }
+    testNames = parsed.testNames
+    suiteLine = parsed.suiteLine
+    testLines = parsed.testLines
+  }
+  const rerunLabel = ctx.getRerunLabel()
+  if (rerunLabel) {
+    const targetIndex = testNames.findIndex((name) => name === rerunLabel)
+    if (targetIndex !== -1) {
+      testNames = [testNames[targetIndex]]
+      testLines = testLines[targetIndex] ? [testLines[targetIndex]] : []
+    }
+  }
+  return { testFile, fullPath, suiteTitle, testNames, suiteLine, testLines }
+}
+
+export function pickCurrentTestName(
+  currentTest: NightwatchCurrentTest,
+  testNames: string[],
+  processedTests: Set<string>
+): string | undefined {
+  const runtimeTestName =
+    typeof currentTest?.name === 'string' ? currentTest.name.trim() : undefined
+  const matchedRuntimeTestName = runtimeTestName
+    ? testNames.find(
+        (name) =>
+          runtimeTestName === name || runtimeTestName.endsWith(` ${name}`)
+      )
+    : undefined
+  return (
+    matchedRuntimeTestName ||
+    testNames.find((name) => !processedTests.has(name))
+  )
+}
+
+export async function startNextTest(
+  ctx: TestLifecycleCtx,
+  currentSuite: SuiteStats,
+  currentTestName: string,
+  processedTests: Set<string>
+): Promise<void> {
+  if (processedTests.size === 0) {
+    ctx.suiteManager.markSuiteAsRunning(currentSuite)
+  }
+  const test = ctx.testManager.findTestInSuite(currentSuite, currentTestName)
+  if (test) {
+    test.state = TEST_STATE.RUNNING as TestStats['state']
+    test.start = new Date()
+    test.end = null
+    ctx.testReporter.onTestStart(test)
+    ctx.setCurrentTest(test)
+    log.info(`  ▶ ${currentTestName}`)
+    await new Promise((resolve) => setTimeout(resolve, TIMING.TEST_START_DELAY))
+  } else {
+    log.warn(
+      `Test "${currentTestName}" not found in suite "${currentSuite.title}"`
+    )
+    ctx.setCurrentTest(null)
+  }
+}
+
+export async function closePreviousRunningTest(
+  ctx: TestLifecycleCtx,
+  currentSuite: SuiteStats,
+  testFile: string,
+  currentTest: NightwatchCurrentTest
+): Promise<void> {
+  const runningTest = currentSuite.tests.find(
+    (t): t is TestStats =>
+      typeof t !== 'string' && t.state === TEST_STATE.RUNNING
+  )
+  if (!runningTest) {
+    return
+  }
+  await closePreviousTest({
+    runningTest,
+    testFile,
+    testcases: currentTest?.results?.testcases || {},
+    testManager: ctx.testManager,
+    incrementCount: (state) => ctx.incrementCount(state),
+    testIcon: (state) => ctx.testIcon(state)
+  })
+}
+
+export function wrapBrowserOnce(
+  ctx: TestLifecycleCtx,
+  browser: NightwatchBrowser
+): void {
+  if (!ctx.isScriptInjected) {
+    ctx.browserProxy.wrapUrlMethod(browser)
+    ctx.isScriptInjected = true
+  }
+  ctx.browserProxy.resetCommandTracking()
+  ctx.browserProxy.wrapBrowserCommands(browser)
+}
+
+function closeUnreportedRunningTest(
+  ctx: TestLifecycleCtx,
+  currentSuite: SuiteStats,
+  testFile: string,
+  results: NightwatchTestResults,
+  processedTests: Set<string>
+): void {
+  const runningTest = currentSuite.tests.find(
+    (t): t is TestStats =>
+      typeof t !== 'string' && t.state === TEST_STATE.RUNNING
+  )
+  if (!runningTest || processedTests.has(runningTest.title)) {
+    return
+  }
+  const failed = (results.errors ?? 0) > 0 || (results.failed ?? 0) > 0
+  const testState: TestStats['state'] = failed
+    ? TEST_STATE.FAILED
+    : TEST_STATE.PASSED
+  const endTime = new Date()
+  const duration = endTime.getTime() - (runningTest.start?.getTime() || 0)
+  ctx.testManager.updateTestState(runningTest, testState, endTime, duration)
+  ctx.testManager.markTestAsProcessed(testFile, runningTest.title)
+  ctx.incrementCount(testState)
+  const icon = ctx.testIcon(testState)
+  log.info(`  ${icon} ${runningTest.title} (${(duration / 1000).toFixed(2)}s)`)
+}
+
+async function closeReportedTestcases(
+  ctx: TestLifecycleCtx,
+  currentSuite: SuiteStats,
+  testFile: string,
+  testcases: Record<string, NightwatchTestCase>,
+  processedTests: Set<string>
+): Promise<void> {
+  const testcaseNames = Object.keys(testcases)
+  const unprocessedTests = testcaseNames.filter(
+    (name) => !processedTests.has(name)
+  )
+  for (const currentTestName of unprocessedTests) {
+    const testcase = testcases[currentTestName]
+    const testState = determineTestState(testcase)
+    const test = ctx.testManager.findTestInSuite(currentSuite, currentTestName)
+    if (test) {
+      const dur = parseFloat(testcase.time || '0') * 1000
+      ctx.testManager.updateTestState(test, testState, new Date(), dur)
+      ctx.incrementCount(testState)
+      const icon = ctx.testIcon(testState)
+      log.info(`  ${icon} ${currentTestName} (${(dur / 1000).toFixed(2)}s)`)
+    }
+    ctx.testManager.markTestAsProcessed(testFile, currentTestName)
+  }
+  if (processedTests.size === testcaseNames.length) {
+    ctx.suiteManager.finalizeSuite(currentSuite)
+    await new Promise((resolve) =>
+      setTimeout(resolve, TIMING.SUITE_COMPLETE_DELAY)
+    )
+  }
+}
+
+export async function closeOutTestcases(
+  ctx: TestLifecycleCtx,
+  browser: NightwatchBrowser
+): Promise<void> {
+  const currentTest = (browser.currentTest ?? {}) as NightwatchCurrentTest
+  const results: NightwatchTestResults = currentTest.results ?? {}
+  const moduleName = currentTest.module ?? ''
+  const testFile = moduleName.split('/').pop() || DEFAULTS.FILE_NAME
+  const testcases = results.testcases ?? {}
+  const currentSuite = ctx.suiteManager.getSuite(testFile)
+  if (!currentSuite) {
+    return
+  }
+  const processedTests = ctx.testManager.getProcessedTests(testFile)
+  if (Object.keys(testcases).length === 0) {
+    closeUnreportedRunningTest(
+      ctx,
+      currentSuite,
+      testFile,
+      results,
+      processedTests
+    )
+  } else {
+    await closeReportedTestcases(
+      ctx,
+      currentSuite,
+      testFile,
+      testcases,
+      processedTests
+    )
+  }
+}
diff --git a/packages/nightwatch-devtools/src/types.ts b/packages/nightwatch-devtools/src/types.ts
index c159e7d0..a2e2b8c0 100644
--- a/packages/nightwatch-devtools/src/types.ts
+++ b/packages/nightwatch-devtools/src/types.ts
@@ -1,98 +1,66 @@
+// Nightwatch-specific types live here. Cross-package types come from @wdio/devtools-shared.
+
+export {
+  TraceType,
+  type CommandLog,
+  type ConsoleLog,
+  type DocumentInfo,
+  type LogLevel,
+  type Metadata,
+  type NetworkRequest,
+  type PerformanceData,
+  type ScreencastFrame,
+  type ScreencastOptions,
+  type SuiteStats,
+  type TestStats,
+  type TestStatus,
+  type TraceLog
+} from '@wdio/devtools-shared'
+
+import type { ScreencastOptions } from '@wdio/devtools-shared'
+
 export interface CommandStackFrame {
   command: string
   callSource?: string
   signature: string
 }
 
-export interface PerformanceData {
-  navigation?: {
-    url: string
-    timing: {
-      loadTime?: number
-      domReady?: number
-      responseTime?: number
-      dnsLookup?: number
-      tcpConnection?: number
-      serverResponse?: number
-    }
-  }
-  resources?: Array<{
-    url: string
-    duration: number
-    size: number
-    type: string
-    startTime: number
-    responseEnd: number
-  }>
-}
-
-export interface DocumentInfo {
-  url: string
-  title: string
-  headers: {
-    userAgent: string
-    language: string
-    platform: string
-  }
-  documentInfo: {
-    readyState: string
-    referrer: string
-    characterSet: string
-  }
-}
-
-export interface CommandLog {
-  command: string
-  args: any[]
-  result?: any
-  error?: Error
-  timestamp: number
-  callSource?: string
-  screenshot?: string
-  testUid?: string
-  performance?: PerformanceData
-  cookies?: string
-  documentInfo?: DocumentInfo
-}
-
-export enum TraceType {
-  Testrunner = 'testrunner'
-}
-
-export type LogLevel = 'trace' | 'debug' | 'log' | 'info' | 'warn' | 'error'
-
-export interface ConsoleLog {
-  timestamp: number
-  type: LogLevel
-  args: any[]
-  source: string
-}
-
-export interface TestStats {
-  uid: string
-  cid: string
-  title: string
-  fullTitle: string
-  parent: string
-  state: 'passed' | 'failed' | 'skipped' | 'pending' | 'running'
-  start: Date
-  end: Date | null
-  type: 'test'
-  file: string
-  retries: number
-  _duration: number
-  error?: Error
-  hooks?: any[]
-  callSource?: string
-}
-
 export interface NightwatchTestCase {
   passed: number
   failed: number
   errors: number
   skipped: number
   time: string
-  assertions: any[]
+  assertions: unknown[]
+}
+
+/** Nightwatch's per-test results bag. Loose by design — fields vary across
+ *  Nightwatch versions. We read only the pieces we need; everything else
+ *  flows through as `unknown`. */
+export interface NightwatchTestResults {
+  errors?: number
+  failed?: number
+  passed?: number
+  skipped?: number
+  testcases?: Record<string, NightwatchTestCase>
+  [key: string]: unknown
+}
+
+/** `browser.currentTest` shape — Nightwatch documents this informally. */
+export interface NightwatchCurrentTest {
+  name?: string
+  module?: string
+  group?: string
+  results?: NightwatchTestResults
+  [key: string]: unknown
+}
+
+/** Nightwatch `eventHub` shape — only `runner` + `on()` are documented; the
+ *  rest of the public surface is `unknown` to us. */
+export interface NightwatchEventHub {
+  runner?: string
+  on(event: string, listener: (data: unknown) => void): void
+  [key: string]: unknown
 }
 
 export interface TestFileMetadata {
@@ -107,98 +75,54 @@ export interface StepLocation {
   line: number
 }
 
-export interface SuiteStats {
-  uid: string
-  cid: string
-  title: string
-  fullTitle: string
-  type: 'suite'
-  file: string
-  start: Date
-  state?: 'pending' | 'running' | 'passed' | 'failed' | 'skipped'
-  end?: Date | null
-  tests: (string | TestStats)[]
-  suites: SuiteStats[]
-  hooks: any[]
-  _duration: number
-  parent?: string
-  callSource?: string
-}
-
-export interface Metadata {
-  type: TraceType
-  url?: string
-  options?: any
-  capabilities?: any
-  viewport?: any
-}
-
-export interface TraceLog {
-  mutations: any[]
-  logs: string[]
-  consoleLogs: ConsoleLog[]
-  networkRequests: any[]
-  metadata: Metadata
-  commands: CommandLog[]
-  sources: Record<string, string>
-  suites: Record<string, SuiteStats>[]
-}
-
 export interface DevToolsOptions {
   port?: number
   hostname?: string
+  /**
+   * Screencast recording options. When enabled, a continuous video of the
+   * browser session is recorded and saved as a .webm file at the end of the
+   * test run. Polling mode only on Nightwatch (no CDP push); works on every
+   * browser Nightwatch supports.
+   */
+  screencast?: ScreencastOptions
+  /**
+   * Enable WebDriver BiDi capture (browser console + JS exceptions + network
+   * via `selenium-webdriver/bidi`). Requires `webSocketUrl: true` in your
+   * capabilities and a BiDi-capable chromedriver. When attached, the per-
+   * command perf-log network capture path is gated off to avoid duplicate
+   * entries. Defaults to `false` — opt-in.
+   */
+  bidi?: boolean
 }
 
 export interface NightwatchBrowser {
-  url: (url: string) => Promise<any>
-  execute: (script: string | Function, args?: any[]) => Promise<any>
-  executeAsync: (script: Function, args?: any[]) => Promise<any>
-  pause: (ms: number) => Promise<any>
-  capabilities?: Record<string, any>
-  desiredCapabilities?: Record<string, any>
+  url: (url: string) => Promise<unknown>
+  execute: (
+    script: string | ((...args: unknown[]) => unknown),
+    args?: unknown[]
+  ) => Promise<unknown>
+  executeAsync: (
+    script: (...args: unknown[]) => unknown,
+    args?: unknown[]
+  ) => Promise<unknown>
+  pause: (ms: number) => Promise<unknown>
+  capabilities?: Record<string, unknown>
+  desiredCapabilities?: Record<string, unknown>
   sessionId?: string
-  driver?: any
+  /** Driver instance from selenium-webdriver — its public shape is wide; we
+   *  pass it through to BiDi attach helpers that do their own narrowing. */
+  driver?: unknown
   options?: {
     testEnv?: string
     webdriver?: { host?: string }
-    [key: string]: any
+    [key: string]: unknown
   }
   currentTest?: {
     name?: string
     module?: string
     group?: string
-    [key: string]: any
-  }
-  results?: any
-  queue?: any
-}
-
-export interface NetworkRequest {
-  id: string
-  url: string
-  method: string
-  headers?: Record<string, string>
-  cookies?: any[]
-  status?: number
-  statusText?: string
-  timestamp: number
-  startTime: number
-  endTime?: number
-  time?: number
-  type: string
-  requestHeaders?: Record<string, string>
-  responseHeaders?: Record<string, string>
-  navigation?: string
-  redirectChain?: any[]
-  children?: NetworkRequest[]
-  response?: {
-    fromCache: boolean
-    headers: Record<string, string>
-    mimeType: string
-    status: number
+    [key: string]: unknown
   }
-  error?: string
-  requestBody?: string
-  responseBody?: string
-  size?: number
+  results?: unknown
+  queue?: unknown
 }
diff --git a/packages/nightwatch-devtools/tests/cucumberResult.test.ts b/packages/nightwatch-devtools/tests/cucumberResult.test.ts
new file mode 100644
index 00000000..0247908b
--- /dev/null
+++ b/packages/nightwatch-devtools/tests/cucumberResult.test.ts
@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest'
+import {
+  closeOpenSteps,
+  cucumberResultToTestState
+} from '../src/helpers/cucumberResult.js'
+import { TEST_STATE } from '../src/constants.js'
+import type { SuiteStats, TestStats } from '../src/types.js'
+
+function suiteWithSteps(stepStates: Array<TestStats['state']>): SuiteStats {
+  return {
+    uid: 's',
+    cid: '0-0',
+    title: 'scenario',
+    fullTitle: 'scenario',
+    file: '/f.feature',
+    type: 'suite',
+    state: TEST_STATE.RUNNING,
+    start: new Date(),
+    end: null,
+    tests: stepStates.map((state, i) => ({
+      uid: `t${i}`,
+      cid: '0-0',
+      title: `step ${i}`,
+      fullTitle: `step ${i}`,
+      parent: 's',
+      state,
+      start: new Date(),
+      end: null,
+      type: 'test' as const,
+      file: '/f.feature',
+      retries: 0,
+      _duration: 0,
+      hooks: []
+    })),
+    suites: [],
+    hooks: [],
+    _duration: 0
+  }
+}
+
+describe('cucumberResultToTestState', () => {
+  it('maps statuses to dashboard states (case-insensitive, everything-else → FAILED)', () => {
+    expect(cucumberResultToTestState({ status: 'PASSED' })).toBe(
+      TEST_STATE.PASSED
+    )
+    expect(cucumberResultToTestState({ status: 'skipped' })).toBe(
+      TEST_STATE.SKIPPED
+    )
+    // FAILED / AMBIGUOUS / UNDEFINED / PENDING / UNKNOWN / unknown words all collapse to FAILED
+    for (const s of [
+      'FAILED',
+      'AMBIGUOUS',
+      'UNDEFINED',
+      'PENDING',
+      'mystery'
+    ]) {
+      expect(cucumberResultToTestState({ status: s })).toBe(TEST_STATE.FAILED)
+    }
+  })
+
+  it('treats missing status / null / undefined as FAILED', () => {
+    expect(cucumberResultToTestState({})).toBe(TEST_STATE.FAILED)
+    expect(cucumberResultToTestState(null)).toBe(TEST_STATE.FAILED)
+    expect(cucumberResultToTestState(undefined)).toBe(TEST_STATE.FAILED)
+  })
+})
+
+describe('closeOpenSteps', () => {
+  it('marks open steps PASSED when scenario passed and FAILED otherwise', () => {
+    const passed = suiteWithSteps([TEST_STATE.RUNNING, TEST_STATE.PENDING])
+    closeOpenSteps(passed, TEST_STATE.PASSED)
+    expect((passed.tests as TestStats[]).map((t) => t.state)).toEqual([
+      TEST_STATE.PASSED,
+      TEST_STATE.PASSED
+    ])
+
+    const failed = suiteWithSteps([TEST_STATE.RUNNING, TEST_STATE.PENDING])
+    closeOpenSteps(failed, TEST_STATE.FAILED)
+    expect((failed.tests as TestStats[]).map((t) => t.state)).toEqual([
+      TEST_STATE.FAILED,
+      TEST_STATE.FAILED
+    ])
+
+    // SKIPPED scenario also treats open steps as FAILED — only PASSED clears them
+    const skipped = suiteWithSteps([TEST_STATE.RUNNING])
+    closeOpenSteps(skipped, TEST_STATE.SKIPPED)
+    expect((skipped.tests[0] as TestStats).state).toBe(TEST_STATE.FAILED)
+  })
+
+  it('leaves terminal-state steps unchanged and stamps end timestamp on closed steps', () => {
+    const suite = suiteWithSteps([
+      TEST_STATE.PASSED,
+      TEST_STATE.FAILED,
+      TEST_STATE.RUNNING
+    ])
+    const ts = new Date(123456789)
+    closeOpenSteps(suite, TEST_STATE.PASSED, ts)
+    // First two unchanged
+    expect((suite.tests[0] as TestStats).state).toBe(TEST_STATE.PASSED)
+    expect((suite.tests[1] as TestStats).state).toBe(TEST_STATE.FAILED)
+    // Third closed at our timestamp
+    expect((suite.tests[2] as TestStats).end).toBe(ts)
+  })
+
+  it('skips non-TestStats entries (defensive against legacy string-only arrays)', () => {
+    const suite = suiteWithSteps([TEST_STATE.RUNNING])
+    suite.tests.push('legacy' as unknown as TestStats)
+    closeOpenSteps(suite, TEST_STATE.PASSED)
+    expect(suite.tests[1]).toBe('legacy')
+  })
+})
diff --git a/packages/nightwatch-devtools/tests/serializeCommandResult.test.ts b/packages/nightwatch-devtools/tests/serializeCommandResult.test.ts
new file mode 100644
index 00000000..d8520714
--- /dev/null
+++ b/packages/nightwatch-devtools/tests/serializeCommandResult.test.ts
@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest'
+import { serializeCommandResult } from '../src/helpers/serializeCommandResult.js'
+
+describe('serializeCommandResult', () => {
+  describe('null/undefined inputs', () => {
+    it('returns undefined for null', () => {
+      expect(serializeCommandResult(null, 'click')).toBeUndefined()
+    })
+
+    it('returns undefined for undefined', () => {
+      expect(serializeCommandResult(undefined, 'click')).toBeUndefined()
+    })
+  })
+
+  describe('Nightwatch assertion objects {passed, ...}', () => {
+    it('collapses to `true` when passed: true', () => {
+      const result = serializeCommandResult(
+        { passed: true, actual: 'foo', expected: 'foo' },
+        'expect'
+      )
+      expect(result).toBe(true)
+    })
+
+    it('returns the structured failure record when passed: false', () => {
+      const result = serializeCommandResult(
+        {
+          passed: false,
+          actual: 'foo',
+          expected: 'bar',
+          message: 'mismatch'
+        },
+        'expect'
+      )
+      expect(result).toEqual({
+        passed: false,
+        actual: 'foo',
+        expected: 'bar',
+        message: 'mismatch'
+      })
+    })
+  })
+
+  describe('Driver result wrappers {value}', () => {
+    it('unwraps the inner value for normal commands', () => {
+      expect(serializeCommandResult({ value: 'page title' }, 'getTitle')).toBe(
+        'page title'
+      )
+    })
+
+    it('coerces null to false for boolean-semantic commands (waitFor*, is*, has*)', () => {
+      expect(serializeCommandResult({ value: null }, 'waitForExist')).toBe(
+        false
+      )
+      expect(serializeCommandResult({ value: null }, 'isVisible')).toBe(false)
+      expect(serializeCommandResult({ value: null }, 'hasClass')).toBe(false)
+    })
+
+    it('leaves null unchanged for non-boolean commands', () => {
+      expect(serializeCommandResult({ value: null }, 'getText')).toBe(null)
+    })
+
+    it('preserves an object value verbatim', () => {
+      expect(serializeCommandResult({ value: { x: 1 } }, 'execute')).toEqual({
+        x: 1
+      })
+    })
+  })
+
+  describe('Plain objects (deep-clone path)', () => {
+    it('deep-clones via JSON for plain objects', () => {
+      const input = { a: 1, nested: { b: 2 } }
+      const out = serializeCommandResult(input, 'execute')
+      expect(out).toEqual(input)
+      expect(out).not.toBe(input) // not the same reference
+    })
+
+    it('falls back to String() for circular references (JSON.stringify throws)', () => {
+      const circular: Record<string, unknown> = { a: 1 }
+      circular.self = circular
+      const out = serializeCommandResult(circular, 'execute')
+      expect(typeof out).toBe('string')
+      expect(out).toBe('[object Object]')
+    })
+  })
+
+  describe('Function inputs', () => {
+    it('returns undefined for a function (no useful serialization)', () => {
+      expect(serializeCommandResult(() => 1, 'execute')).toBeUndefined()
+    })
+  })
+})
diff --git a/packages/nightwatch-devtools/tests/session.test.ts b/packages/nightwatch-devtools/tests/session.test.ts
new file mode 100644
index 00000000..19822c97
--- /dev/null
+++ b/packages/nightwatch-devtools/tests/session.test.ts
@@ -0,0 +1,335 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { SessionCapturer } from '../src/session.js'
+import type { NightwatchBrowser } from '../src/types.js'
+
+function makeMockBrowser(
+  overrides: Partial<Record<string, unknown>> = {}
+): NightwatchBrowser {
+  return {
+    url: vi.fn(async () => ({})),
+    execute: vi.fn(async () => ({ value: null })),
+    executeAsync: vi.fn(async () => ({ value: null })),
+    pause: vi.fn(async () => ({})),
+    ...overrides
+  } as unknown as NightwatchBrowser
+}
+
+function makeCapturer(browser?: NightwatchBrowser): SessionCapturer {
+  // No hostname/port → no WebSocket; lets us unit-test the capture surface
+  // without a backend stub.
+  return new SessionCapturer({}, browser)
+}
+
+describe('SessionCapturer.captureCommand', () => {
+  it('pushes the entry into commandsLog with a stable _id', async () => {
+    const cap = makeCapturer()
+    await cap.captureCommand('click', ['#btn'], { ok: true }, undefined)
+    await cap.captureCommand('url', ['https://x'], undefined, undefined)
+    expect(cap.commandsLog).toHaveLength(2)
+    expect(cap.commandsLog[0]).toMatchObject({
+      command: 'click',
+      args: ['#btn'],
+      result: { ok: true }
+    })
+    expect((cap.commandsLog[0] as { _id: number })._id).not.toBe(
+      (cap.commandsLog[1] as { _id: number })._id
+    )
+  })
+
+  it('uses provided timestamp when given', async () => {
+    const cap = makeCapturer()
+    await cap.captureCommand(
+      'x',
+      [],
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      12345
+    )
+    expect(cap.commandsLog[0].timestamp).toBe(12345)
+  })
+
+  it('serializes Error before storing', async () => {
+    const cap = makeCapturer()
+    const err = new Error('boom')
+    await cap.captureCommand('click', [], undefined, err)
+    const stored = cap.commandsLog[0].error as { name: string; message: string }
+    expect(stored.name).toBe('Error')
+    expect(stored.message).toBe('boom')
+  })
+
+  it('triggers performance capture for navigation commands when browser present', async () => {
+    const execute = vi.fn(async () => ({ value: undefined }))
+    const browser = makeMockBrowser({ execute })
+    const cap = makeCapturer(browser)
+    await cap.captureCommand('url', ['https://x'], undefined, undefined)
+    // perf capture runs in background after a 500ms delay; let it settle
+    await new Promise((r) => setTimeout(r, 600))
+    expect(execute).toHaveBeenCalled()
+  })
+
+  it('skips performance capture when error present', async () => {
+    const execute = vi.fn()
+    const browser = makeMockBrowser({ execute })
+    const cap = makeCapturer(browser)
+    await cap.captureCommand('url', ['https://x'], undefined, new Error('nav'))
+    await new Promise((r) => setTimeout(r, 50))
+    expect(execute).not.toHaveBeenCalled()
+  })
+})
+
+describe('SessionCapturer.replaceCommand', () => {
+  it('splices the old entry and reissues with a new _id', async () => {
+    const cap = makeCapturer()
+    await cap.captureCommand('click', ['#a'], undefined, undefined)
+    const oldId = (cap.commandsLog[0] as { _id: number })._id
+    const oldTs = cap.commandsLog[0].timestamp
+    const { entry, oldTimestamp } = cap.replaceCommand(
+      oldId,
+      'click',
+      ['#a'],
+      { ok: true },
+      undefined
+    )
+    expect(oldTimestamp).toBe(oldTs)
+    expect(cap.commandsLog).toHaveLength(1)
+    expect((cap.commandsLog[0] as { _id: number })._id).not.toBe(oldId)
+    expect(entry.result).toEqual({ ok: true })
+  })
+
+  it('returns oldTimestamp=0 when oldId not found', async () => {
+    const cap = makeCapturer()
+    const { oldTimestamp } = cap.replaceCommand(
+      999,
+      'click',
+      [],
+      undefined,
+      undefined
+    )
+    expect(oldTimestamp).toBe(0)
+  })
+})
+
+describe('SessionCapturer.captureBrowserLogs', () => {
+  it('maps Chrome browser log entries into consoleLogs and broadcasts', async () => {
+    const browser = makeMockBrowser({
+      getLog: vi.fn(async () => [
+        { level: 'INFO', message: 'console-api hello', timestamp: 1000 }
+      ])
+    })
+    const cap = makeCapturer(browser)
+    const send = vi.spyOn(
+      cap as unknown as { sendUpstream: (e: string, d: unknown) => void },
+      'sendUpstream'
+    )
+    await cap.captureBrowserLogs(browser)
+    expect(cap.consoleLogs).toHaveLength(1)
+    expect(send).toHaveBeenCalledWith('consoleLogs', expect.any(Array))
+  })
+
+  it('silently no-ops when getLog throws (perf logging not enabled)', async () => {
+    const browser = makeMockBrowser({
+      getLog: vi.fn(async () => {
+        throw new Error('unknown log type')
+      })
+    })
+    const cap = makeCapturer(browser)
+    await expect(cap.captureBrowserLogs(browser)).resolves.toBeUndefined()
+    expect(cap.consoleLogs).toHaveLength(0)
+  })
+
+  it('no-ops when getLog returns an empty array', async () => {
+    const browser = makeMockBrowser({
+      getLog: vi.fn(async () => [])
+    })
+    const cap = makeCapturer(browser)
+    await cap.captureBrowserLogs(browser)
+    expect(cap.consoleLogs).toHaveLength(0)
+  })
+})
+
+describe('SessionCapturer.captureNetworkFromPerformanceLogs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('short-circuits when BiDi is active (no double-emit)', async () => {
+    const getLog = vi.fn()
+    const browser = makeMockBrowser({ getLog })
+    const cap = makeCapturer(browser)
+    cap.bidiActive = true
+    await cap.captureNetworkFromPerformanceLogs(browser)
+    expect(getLog).not.toHaveBeenCalled()
+  })
+
+  it('parses CDP performance logs into networkRequests', async () => {
+    const perfMessage = {
+      message: JSON.stringify({
+        message: {
+          method: 'Network.requestWillBeSent',
+          params: {
+            requestId: 'r1',
+            request: { url: 'https://x/api', method: 'GET', headers: {} },
+            timestamp: 1
+          }
+        }
+      }),
+      timestamp: 1700000000000
+    }
+    const finishMessage = {
+      message: JSON.stringify({
+        message: {
+          method: 'Network.responseReceived',
+          params: {
+            requestId: 'r1',
+            response: {
+              status: 200,
+              statusText: 'OK',
+              headers: { 'content-type': 'application/json' },
+              mimeType: 'application/json'
+            }
+          }
+        }
+      }),
+      timestamp: 1700000000100
+    }
+    const loadingFinished = {
+      message: JSON.stringify({
+        message: {
+          method: 'Network.loadingFinished',
+          params: { requestId: 'r1', encodedDataLength: 42 }
+        }
+      }),
+      timestamp: 1700000000200
+    }
+    const browser = makeMockBrowser({
+      getLog: vi.fn(async () => [perfMessage, finishMessage, loadingFinished])
+    })
+    const cap = makeCapturer(browser)
+    await cap.captureNetworkFromPerformanceLogs(browser)
+    expect(cap.networkRequests).toHaveLength(1)
+    expect(cap.networkRequests[0]).toMatchObject({
+      url: 'https://x/api',
+      method: 'GET',
+      status: 200
+    })
+  })
+
+  it('swallows expected "log type not enabled" errors silently', async () => {
+    const browser = makeMockBrowser({
+      getLog: vi.fn(async () => {
+        throw new Error('unknown log type: performance')
+      })
+    })
+    const cap = makeCapturer(browser)
+    await expect(
+      cap.captureNetworkFromPerformanceLogs(browser)
+    ).resolves.toBeUndefined()
+  })
+})
+
+describe('SessionCapturer.takeScreenshotViaHttp', () => {
+  it('returns null when no sessionId on the browser', async () => {
+    const browser = makeMockBrowser()
+    const cap = makeCapturer(browser)
+    expect(await cap.takeScreenshotViaHttp(browser)).toBeNull()
+  })
+
+  it('parses { value } JSON from the driver screenshot endpoint', async () => {
+    const http = await import('node:http')
+    const server = http.createServer((_req, res) => {
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ value: 'base64data' }))
+    })
+    await new Promise<void>((r) => server.listen(0, '127.0.0.1', () => r()))
+    const port = (server.address() as { port: number }).port
+    const browser = makeMockBrowser({
+      sessionId: 'sess-1',
+      transport: {
+        settings: { webdriver: { host: '127.0.0.1', port } }
+      }
+    })
+    const cap = makeCapturer(browser)
+    try {
+      expect(await cap.takeScreenshotViaHttp(browser)).toBe('base64data')
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()))
+    }
+  })
+
+  it('returns null when the response body is not JSON', async () => {
+    const http = await import('node:http')
+    const server = http.createServer((_req, res) => {
+      res.end('<<not json>>')
+    })
+    await new Promise<void>((r) => server.listen(0, '127.0.0.1', () => r()))
+    const port = (server.address() as { port: number }).port
+    const browser = makeMockBrowser({
+      sessionId: 'sess-2',
+      transport: {
+        settings: { webdriver: { host: '127.0.0.1', port } }
+      }
+    })
+    const cap = makeCapturer(browser)
+    try {
+      expect(await cap.takeScreenshotViaHttp(browser)).toBeNull()
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()))
+    }
+  })
+
+  it('returns null when the request fails (no listener)', async () => {
+    // Connect to a port nothing is listening on
+    const browser = makeMockBrowser({
+      sessionId: 'sess-3',
+      transport: {
+        settings: { webdriver: { host: '127.0.0.1', port: 1 } }
+      }
+    })
+    const cap = makeCapturer(browser)
+    expect(await cap.takeScreenshotViaHttp(browser)).toBeNull()
+  })
+})
+
+describe('SessionCapturer.captureTrace', () => {
+  it('delegates to captureNetworkFromPerformanceLogs and stops when no collector', async () => {
+    const browser = makeMockBrowser({
+      // captureNetworkFromPerformanceLogs call (getLog) — return empty
+      getLog: vi.fn(async () => []),
+      // execute is called: first to check window.wdioTraceCollector, returns false-equivalent
+      execute: vi.fn(async () => ({ value: false }))
+    })
+    const cap = makeCapturer(browser)
+    await cap.captureTrace(browser)
+    // No mutations / commands added since collector not present
+    expect(cap.networkRequests).toHaveLength(0)
+  })
+
+  it('processes trace payload when collector is present', async () => {
+    let call = 0
+    const browser = makeMockBrowser({
+      getLog: vi.fn(async () => []),
+      execute: vi.fn(async () => {
+        call++
+        if (call === 1) {
+          // collector check
+          return { value: true }
+        }
+        // getTraceData
+        return {
+          value: {
+            mutations: [
+              { type: 'attributes', addedNodes: [], removedNodes: [] }
+            ],
+            networkRequests: [],
+            consoleLogs: []
+          }
+        }
+      })
+    })
+    const cap = makeCapturer(browser)
+    await cap.captureTrace(browser)
+    expect(call).toBe(2)
+  })
+})
diff --git a/packages/nightwatch-devtools/tests/utils.test.ts b/packages/nightwatch-devtools/tests/utils.test.ts
new file mode 100644
index 00000000..82dcc3b2
--- /dev/null
+++ b/packages/nightwatch-devtools/tests/utils.test.ts
@@ -0,0 +1,355 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { resetSignatureCounters } from '@wdio/devtools-core'
+import {
+  buildPluginMetadataOptions,
+  determineTestState,
+  extractTestMetadata,
+  findStepDefinitionLine,
+  findTestFileByName,
+  generateStableUid,
+  getTestIcon,
+  incrementCounters,
+  parseCucumberScenario,
+  resolveNightwatchConfig
+} from '../src/helpers/utils.js'
+
+describe('determineTestState', () => {
+  it.each([
+    [
+      {
+        passed: 0,
+        failed: 0,
+        errors: 0,
+        skipped: 1,
+        time: '0',
+        assertions: []
+      },
+      'skipped'
+    ],
+    [
+      {
+        passed: 1,
+        failed: 0,
+        errors: 0,
+        skipped: 0,
+        time: '0',
+        assertions: []
+      },
+      'passed'
+    ],
+    [
+      {
+        passed: 0,
+        failed: 1,
+        errors: 0,
+        skipped: 0,
+        time: '0',
+        assertions: []
+      },
+      'failed'
+    ],
+    [
+      {
+        passed: 1,
+        failed: 1,
+        errors: 0,
+        skipped: 0,
+        time: '0',
+        assertions: []
+      },
+      'failed'
+    ]
+  ])('maps testcase to %j → %s', (tc, expected) => {
+    expect(determineTestState(tc as never)).toBe(expected)
+  })
+})
+
+describe('getTestIcon', () => {
+  it.each([
+    ['passed', '✅'],
+    ['skipped', '⏭'],
+    ['failed', '❌'],
+    ['running', '❌']
+  ])('icon for %s', (state, icon) => {
+    expect(getTestIcon(state as never)).toBe(icon)
+  })
+})
+
+describe('incrementCounters', () => {
+  it('increments the right bucket per state', () => {
+    const c = { passCount: 0, failCount: 0, skipCount: 0 }
+    incrementCounters(c, 'passed')
+    incrementCounters(c, 'passed')
+    incrementCounters(c, 'skipped')
+    incrementCounters(c, 'failed')
+    incrementCounters(c, 'running')
+    expect(c).toEqual({ passCount: 2, failCount: 2, skipCount: 1 })
+  })
+})
+
+describe('buildPluginMetadataOptions', () => {
+  it('marks nightwatch + cucumber + canRunTests=false', () => {
+    expect(
+      buildPluginMetadataOptions({ isCucumberRunner: true, configPath: '/x' })
+    ).toMatchObject({
+      framework: 'nightwatch-cucumber',
+      configFile: '/x',
+      runCapabilities: {
+        canRunSuites: true,
+        canRunTests: false,
+        canRunAll: false
+      }
+    })
+  })
+
+  it('marks plain nightwatch + canRunTests=true', () => {
+    expect(
+      buildPluginMetadataOptions({
+        isCucumberRunner: false,
+        configPath: undefined
+      })
+    ).toMatchObject({
+      framework: 'nightwatch',
+      configFile: undefined,
+      runCapabilities: {
+        canRunSuites: true,
+        canRunTests: true,
+        canRunAll: false
+      }
+    })
+  })
+})
+
+describe('generateStableUid', () => {
+  it('produces a deterministic hash for the first (file, name) call', () => {
+    resetSignatureCounters()
+    const a = generateStableUid('/a.test.ts', 'name')
+    resetSignatureCounters()
+    const b = generateStableUid('/a.test.ts', 'name')
+    expect(a).toBe(b)
+  })
+
+  it('differentiates by file', () => {
+    resetSignatureCounters()
+    const a = generateStableUid('/a.test.ts', 'name')
+    const b = generateStableUid('/b.test.ts', 'name')
+    expect(a).not.toBe(b)
+  })
+
+  it('extracts file + fullTitle from an item form', () => {
+    resetSignatureCounters()
+    const a = generateStableUid({ file: '/a.test.ts', fullTitle: 'fullTitle' })
+    resetSignatureCounters()
+    const b = generateStableUid('/a.test.ts', 'fullTitle')
+    expect(a).toBe(b)
+  })
+
+  it('falls back to title when fullTitle is missing', () => {
+    resetSignatureCounters()
+    const a = generateStableUid({ file: '/x.ts', title: 't' })
+    resetSignatureCounters()
+    const b = generateStableUid('/x.ts', 't')
+    expect(a).toBe(b)
+  })
+
+  it('tolerates missing file and name', () => {
+    expect(generateStableUid({ title: '' })).toBeTruthy()
+  })
+})
+
+describe('parseCucumberScenario', () => {
+  const feature = [
+    'Feature: Login',
+    '  Scenario: User logs in',
+    '    Given a registered user',
+    '    When they enter credentials',
+    '    Then they see the dashboard'
+  ].join('\n')
+
+  it('finds feature, scenario, and step lines + keywords', () => {
+    const r = parseCucumberScenario(feature, 'User logs in', [
+      'a registered user',
+      'they enter credentials',
+      'they see the dashboard'
+    ])
+    expect(r.featureLine).toBe(1)
+    expect(r.scenarioLine).toBe(2)
+    expect(r.stepLines).toEqual([3, 4, 5])
+    expect(r.stepKeywords).toEqual(['Given', 'When', 'Then'])
+  })
+
+  it('returns defaults when content is empty', () => {
+    const r = parseCucumberScenario('', 'x', ['a', 'b'])
+    expect(r.featureLine).toBe(1)
+    expect(r.scenarioLine).toBe(1)
+    expect(r.stepLines).toEqual([])
+    expect(r.stepKeywords).toEqual(['', ''])
+  })
+
+  it('pads stepKeywords up to stepCount when feature has fewer steps', () => {
+    const r = parseCucumberScenario(feature, 'User logs in', [
+      'a',
+      'b',
+      'c',
+      'd'
+    ])
+    expect(r.stepKeywords).toHaveLength(4)
+  })
+
+  it('uses default scenarioLine when scenario not found', () => {
+    const r = parseCucumberScenario(feature, 'Nonexistent', [])
+    expect(r.scenarioLine).toBe(1)
+  })
+})
+
+describe('findStepDefinitionLine', () => {
+  it('finds string-literal step defs', () => {
+    const files = [
+      {
+        filePath: '/steps.ts',
+        content: [
+          'Given("a registered user", () => {})',
+          'When("they {string}", () => {})'
+        ].join('\n')
+      }
+    ]
+    expect(findStepDefinitionLine(files, 'a registered user')).toEqual({
+      filePath: '/steps.ts',
+      line: 1
+    })
+    expect(findStepDefinitionLine(files, 'they "hello"')).toEqual({
+      filePath: '/steps.ts',
+      line: 2
+    })
+  })
+
+  it('finds regex-literal step defs', () => {
+    const files = [
+      {
+        filePath: '/s.ts',
+        content: 'Then(/^see (\\d+) results$/, () => {})'
+      }
+    ]
+    expect(findStepDefinitionLine(files, 'see 42 results')).toEqual({
+      filePath: '/s.ts',
+      line: 1
+    })
+  })
+
+  it('returns null when nothing matches', () => {
+    expect(findStepDefinitionLine([], 'anything')).toBeNull()
+    expect(
+      findStepDefinitionLine(
+        [{ filePath: '/x.ts', content: 'Given("a", () => {})' }],
+        'unmatched'
+      )
+    ).toBeNull()
+  })
+
+  it('handles cucumber-expression {int} placeholder', () => {
+    const files = [
+      {
+        filePath: '/s.ts',
+        content: 'Then("see {int} results", () => {})'
+      }
+    ]
+    expect(findStepDefinitionLine(files, 'see 42 results')).toEqual({
+      filePath: '/s.ts',
+      line: 1
+    })
+  })
+})
+
+describe('findTestFileByName', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nw-utils-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('finds a matching test file under the workspace', () => {
+    const target = path.join(tmpDir, 'sub', 'login.test.ts')
+    fs.mkdirSync(path.dirname(target), { recursive: true })
+    fs.writeFileSync(target, 'export {}')
+    const found = findTestFileByName('login', tmpDir)
+    expect(found).toBe(target)
+  })
+
+  it('returns undefined when no workspace is given', () => {
+    expect(findTestFileByName('anything')).toBeUndefined()
+  })
+
+  it('returns undefined when no match exists', () => {
+    expect(findTestFileByName('nothere', tmpDir)).toBeUndefined()
+  })
+})
+
+describe('extractTestMetadata', () => {
+  let tmpFile: string
+  beforeEach(() => {
+    tmpFile = path.join(
+      fs.mkdtempSync(path.join(os.tmpdir(), 'nw-meta-')),
+      'sample.test.ts'
+    )
+    fs.writeFileSync(
+      tmpFile,
+      [
+        'describe("login", () => {',
+        '  it("succeeds", () => {})',
+        '  it("fails", () => {})',
+        '})'
+      ].join('\n')
+    )
+  })
+  afterEach(() => {
+    fs.rmSync(path.dirname(tmpFile), { recursive: true, force: true })
+  })
+
+  it('extracts suite and tests with line numbers', () => {
+    const md = extractTestMetadata(tmpFile)
+    expect(md.suiteTitle).toBe('login')
+    expect(md.suiteLine).toBe(1)
+    expect(md.testNames).toEqual(['succeeds', 'fails'])
+    expect(md.testLines).toEqual([2, 3])
+  })
+})
+
+describe('resolveNightwatchConfig', () => {
+  it('prefers --config argv', () => {
+    const cfgDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nw-cfg-'))
+    const cfg = path.join(cfgDir, 'nightwatch.conf.cjs')
+    fs.writeFileSync(cfg, 'module.exports = {}')
+    const origArgv = process.argv
+    process.argv = ['node', 'cli', '--config', cfg]
+    try {
+      expect(resolveNightwatchConfig()).toBe(cfg)
+    } finally {
+      process.argv = origArgv
+      fs.rmSync(cfgDir, { recursive: true, force: true })
+    }
+  })
+
+  it('returns undefined when --config points to a non-existent file', () => {
+    const origArgv = process.argv
+    const origCwd = process.cwd()
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nw-cfg-empty-'))
+    process.argv = ['node', 'cli', '--config', '/definitely/not/a/file']
+    process.chdir(tmpDir)
+    try {
+      // Walks up from tmpDir; if no nightwatch.conf.* exists upstream it's undefined.
+      const result = resolveNightwatchConfig()
+      expect(typeof result === 'string' || result === undefined).toBe(true)
+    } finally {
+      process.chdir(origCwd)
+      process.argv = origArgv
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})
diff --git a/packages/nightwatch-devtools/tsconfig.json b/packages/nightwatch-devtools/tsconfig.json
index 25c4541c..40ac89a1 100644
--- a/packages/nightwatch-devtools/tsconfig.json
+++ b/packages/nightwatch-devtools/tsconfig.json
@@ -11,7 +11,8 @@
     "strict": true,
     "resolveJsonModule": true,
     "skipLibCheck": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "ignoreDeprecations": "6.0"
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]
diff --git a/packages/script/package.json b/packages/script/package.json
index 510e2c7d..6a9c42fc 100644
--- a/packages/script/package.json
+++ b/packages/script/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@wdio/devtools-script",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Script to be injected into a page to trace the page",
   "author": "Christian Bromann <mail@bromann.dev>",
   "repository": {
@@ -21,12 +21,12 @@
   },
   "dependencies": {
     "htm": "^3.1.1",
-    "parse5": "^8.0.0",
-    "preact": "^10.27.1",
-    "vite-plugin-singlefile": "^2.3.2"
+    "parse5": "^8.0.1",
+    "preact": "^10.29.2",
+    "vite-plugin-singlefile": "^2.3.3"
   },
   "devDependencies": {
-    "vite": "8.0.7"
+    "vite": "^8.0.16"
   },
   "license": "MIT"
 }
diff --git a/packages/script/src/collectors/consoleLogs.ts b/packages/script/src/collectors/consoleLogs.ts
index 5cedb055..c3852af1 100644
--- a/packages/script/src/collectors/consoleLogs.ts
+++ b/packages/script/src/collectors/consoleLogs.ts
@@ -3,7 +3,7 @@ import type { Collector } from './collector.js'
 const consoleMethods = ['log', 'info', 'warn', 'error'] as const
 export interface ConsoleLogs {
   type: 'log' | 'info' | 'warn' | 'error'
-  args: any[]
+  args: unknown[]
   timestamp: number
   source?: 'browser' | 'test' | 'terminal'
 }
diff --git a/packages/script/src/collectors/networkRequests.ts b/packages/script/src/collectors/networkRequests.ts
index 75ca3e38..191ec3fd 100644
--- a/packages/script/src/collectors/networkRequests.ts
+++ b/packages/script/src/collectors/networkRequests.ts
@@ -68,94 +68,94 @@ export class NetworkRequestCollector implements Collector<NetworkRequest> {
     return false
   }
 
+  #extractFetchUrl(input: RequestInfo | URL): string {
+    if (typeof input === 'string') {
+      return input
+    }
+    return input instanceof URL ? input.href : input.url
+  }
+
+  async #readResponseBody(
+    response: Response,
+    contentType: string
+  ): Promise<string | undefined> {
+    try {
+      if (
+        contentType.includes('application/json') ||
+        contentType.includes('text/')
+      ) {
+        return await response.clone().text()
+      }
+    } catch {
+      /* ignore body read errors */
+    }
+    return undefined
+  }
+
+  async #recordFetchResponse(
+    id: string,
+    request: Partial<NetworkRequest>,
+    response: Response,
+    startTime: number
+  ): Promise<void> {
+    const endTime = performance.now()
+    const responseHeaders = this.#extractHeaders(response.headers)
+    const contentType = responseHeaders['content-type']?.trim()
+    if (!contentType || contentType === '-') {
+      this.#pendingRequests.delete(id)
+      return
+    }
+    const responseBody = await this.#readResponseBody(response, contentType)
+    this.#requests.push({
+      id,
+      url: request.url!,
+      method: request.method!,
+      status: response.status,
+      statusText: response.statusText,
+      type: 'fetch',
+      timestamp: request.timestamp!,
+      startTime,
+      endTime,
+      time: endTime - startTime,
+      requestHeaders: request.requestHeaders,
+      responseHeaders,
+      requestBody: request.requestBody,
+      responseBody,
+      size: this.#estimateSize(responseBody)
+    })
+    this.#pendingRequests.delete(id)
+  }
+
   #patchFetch() {
     if (typeof window.fetch !== 'function') {
       return
     }
-
     this.#originalFetch = window.fetch
     const self = this
-
     window.fetch = async function (
       input: RequestInfo | URL,
       init?: RequestInit
     ): Promise<Response> {
-      const id = self.#generateId()
-      const url =
-        typeof input === 'string'
-          ? input
-          : input instanceof URL
-            ? input.href
-            : input.url
-      const method = init?.method?.toUpperCase() || 'GET'
-
-      // Skip internal/non-HTTP requests
+      const url = self.#extractFetchUrl(input)
       if (self.#shouldIgnoreRequest(url)) {
         return self.#originalFetch!.apply(this, [input, init])
       }
-
+      const id = self.#generateId()
       const startTime = performance.now()
-      const timestamp = Date.now()
-
       const request: Partial<NetworkRequest> = {
         id,
         url,
-        method,
+        method: init?.method?.toUpperCase() || 'GET',
         type: 'fetch',
-        timestamp,
+        timestamp: Date.now(),
         startTime,
         requestHeaders: init?.headers ? self.#extractHeaders(init.headers) : {},
         requestBody: init?.body ? String(init.body) : undefined
       }
-
       self.#pendingRequests.set(id, request)
-
       try {
         const response = await self.#originalFetch!.apply(this, [input, init])
-        const endTime = performance.now()
-        const time = endTime - startTime
-
-        const responseHeaders = self.#extractHeaders(response.headers)
-        const contentType = responseHeaders['content-type']?.trim()
-
-        if (!contentType || contentType === '-') {
-          self.#pendingRequests.delete(id)
-          return response
-        }
-
-        let responseBody: string | undefined
-        try {
-          if (
-            contentType.includes('application/json') ||
-            contentType.includes('text/')
-          ) {
-            responseBody = await response.clone().text()
-          }
-        } catch {
-          // Ignore body read errors
-        }
-
-        const networkRequest: NetworkRequest = {
-          id,
-          url,
-          method,
-          status: response.status,
-          statusText: response.statusText,
-          type: 'fetch',
-          timestamp,
-          startTime,
-          endTime,
-          time,
-          requestHeaders: request.requestHeaders,
-          responseHeaders,
-          requestBody: request.requestBody,
-          responseBody,
-          size: self.#estimateSize(responseBody)
-        }
-
-        self.#requests.push(networkRequest)
-        self.#pendingRequests.delete(id)
-
+        await self.#recordFetchResponse(id, request, response, startTime)
         return response
       } catch (error) {
         self.#pendingRequests.delete(id)
@@ -164,15 +164,48 @@ export class NetworkRequestCollector implements Collector<NetworkRequest> {
     }
   }
 
-  #patchXHR() {
-    if (typeof XMLHttpRequest === 'undefined') {
+  #recordXHRResponse(
+    xhr: XMLHttpRequest,
+    requestData: Partial<NetworkRequest>,
+    startTime: number
+  ): void {
+    const endTime = performance.now()
+    const responseHeaders = this.#extractXHRHeaders(xhr)
+    const contentType = responseHeaders['content-type']?.trim()
+    if (!contentType || contentType === '-') {
       return
     }
+    let responseBody: string | undefined
+    try {
+      if (
+        contentType.includes('application/json') ||
+        contentType.includes('text/')
+      ) {
+        responseBody = xhr.responseText
+      }
+    } catch {
+      /* ignore body read errors */
+    }
+    this.#requests.push({
+      id: requestData.id!,
+      url: requestData.url!,
+      method: requestData.method!,
+      status: xhr.status,
+      statusText: xhr.statusText,
+      type: 'xhr',
+      timestamp: requestData.timestamp!,
+      startTime,
+      endTime,
+      time: endTime - startTime,
+      requestHeaders: requestData.requestHeaders,
+      responseHeaders,
+      requestBody: requestData.requestBody,
+      responseBody,
+      size: this.#estimateSize(responseBody)
+    })
+  }
 
-    const self = this
-    this.#originalXhrOpen = XMLHttpRequest.prototype.open
-    this.#originalXhrSend = XMLHttpRequest.prototype.send
-
+  #patchXHROpen(self: this): void {
     XMLHttpRequest.prototype.open = function (
       method: string,
       url: string | URL,
@@ -180,31 +213,18 @@ export class NetworkRequestCollector implements Collector<NetworkRequest> {
       username?: string | null,
       password?: string | null
     ) {
-      const id = self.#generateId()
       const urlString = typeof url === 'string' ? url : url.href
-
-      // Skip internal/non-HTTP requests
-      if (self.#shouldIgnoreRequest(urlString)) {
-        return self.#originalXhrOpen!.call(
-          this,
-          method,
-          url as string,
-          async ?? true,
-          username,
-          password
-        )
+      if (!self.#shouldIgnoreRequest(urlString)) {
+        self.#pendingXHRRequests.set(this, {
+          id: self.#generateId(),
+          url: urlString,
+          method: method.toUpperCase(),
+          type: 'xhr',
+          timestamp: Date.now(),
+          startTime: performance.now(),
+          requestHeaders: {}
+        })
       }
-
-      self.#pendingXHRRequests.set(this, {
-        id,
-        url: urlString,
-        method: method.toUpperCase(),
-        type: 'xhr',
-        timestamp: Date.now(),
-        startTime: performance.now(),
-        requestHeaders: {}
-      })
-
       return self.#originalXhrOpen!.call(
         this,
         method,
@@ -214,78 +234,37 @@ export class NetworkRequestCollector implements Collector<NetworkRequest> {
         password
       )
     }
+  }
 
+  #patchXHRSend(self: this): void {
     XMLHttpRequest.prototype.send = function (
       body?: Document | XMLHttpRequestBodyInit | null
     ) {
       const requestData = self.#pendingXHRRequests.get(this)
-
-      // If no request data, this request was filtered out - just send it
       if (!requestData) {
         return self.#originalXhrSend!.call(this, body)
       }
-
       if (body) {
         requestData.requestBody = String(body)
       }
-
       const startTime = requestData.startTime || performance.now()
-
-      const loadHandler = function (this: XMLHttpRequest) {
-        const endTime = performance.now()
-        const time = endTime - startTime
-
-        const responseHeaders = self.#extractXHRHeaders(this)
-        const contentType = responseHeaders['content-type']?.trim()
-
-        if (!contentType || contentType === '-') {
-          return
-        }
-
-        let responseBody: string | undefined
-        try {
-          if (
-            contentType.includes('application/json') ||
-            contentType.includes('text/')
-          ) {
-            responseBody = this.responseText
-          }
-        } catch {
-          // Ignore
-        }
-
-        const networkRequest: NetworkRequest = {
-          id: requestData.id!,
-          url: requestData.url!,
-          method: requestData.method!,
-          status: this.status,
-          statusText: this.statusText,
-          type: 'xhr',
-          timestamp: requestData.timestamp!,
-          startTime,
-          endTime,
-          time,
-          requestHeaders: requestData.requestHeaders,
-          responseHeaders,
-          requestBody: requestData.requestBody,
-          responseBody,
-          size: self.#estimateSize(responseBody)
-        }
-
-        self.#requests.push(networkRequest)
-      }
-
-      const errorHandler = function (this: XMLHttpRequest) {
-        // Skip errors
-      }
-
-      this.addEventListener('load', loadHandler)
-      this.addEventListener('error', errorHandler)
-
+      this.addEventListener('load', function (this: XMLHttpRequest) {
+        self.#recordXHRResponse(this, requestData, startTime)
+      })
       return self.#originalXhrSend!.call(this, body)
     }
   }
 
+  #patchXHR() {
+    if (typeof XMLHttpRequest === 'undefined') {
+      return
+    }
+    this.#originalXhrOpen = XMLHttpRequest.prototype.open
+    this.#originalXhrSend = XMLHttpRequest.prototype.send
+    this.#patchXHROpen(this)
+    this.#patchXHRSend(this)
+  }
+
   #extractHeaders(headers: HeadersInit | Headers): Record<string, string> {
     const result: Record<string, string> = {}
 
diff --git a/packages/script/src/index.ts b/packages/script/src/index.ts
index 0e7ad33a..e1a0bc2a 100644
--- a/packages/script/src/index.ts
+++ b/packages/script/src/index.ts
@@ -8,6 +8,43 @@ import {
 import { log } from './logger.js'
 import { collector } from './collector.js'
 
+function serializeMutation(
+  m: MutationRecord,
+  timestamp: number
+): TraceMutation {
+  const addedNodes = Array.from(m.addedNodes).map((node) => {
+    assignRef(node as Element)
+    return parseFragment(node as Element)
+  })
+  const removedNodes = Array.from(m.removedNodes).map((node) => getRef(node))
+  const target = getRef(m.target)
+  const previousSibling = m.previousSibling ? getRef(m.previousSibling) : null
+  const nextSibling = m.nextSibling ? getRef(m.nextSibling) : null
+  let attributeValue: string | undefined
+  if (m.type === 'attributes') {
+    attributeValue = (m.target as Element).getAttribute(m.attributeName!) || ''
+  }
+  let newTextContent: string | undefined
+  if (m.type === 'characterData') {
+    newTextContent = (m.target as Element).textContent || ''
+  }
+  log(`added mutation: ${m.type}`)
+  return {
+    type: m.type,
+    attributeName: m.attributeName,
+    attributeNamespace: m.attributeNamespace,
+    oldValue: m.oldValue,
+    addedNodes,
+    target,
+    removedNodes,
+    previousSibling,
+    nextSibling,
+    timestamp,
+    attributeValue,
+    newTextContent
+  } as TraceMutation
+}
+
 try {
   log('waiting for body to render')
   await waitForBody()
@@ -32,66 +69,18 @@ try {
   const observer = new MutationObserver((ml) => {
     const timestamp = Date.now()
     const mutationList = ml.filter((m) => m.attributeName !== 'data-wdio-ref')
-
     log(`observed ${mutationList.length} mutations`)
     try {
       collector.captureMutation(
-        mutationList.map(
-          ({
-            target: t,
-            addedNodes: an,
-            removedNodes: rn,
-            type,
-            attributeName,
-            attributeNamespace,
-            previousSibling: ps,
-            nextSibling: ns,
-            oldValue
-          }) => {
-            const addedNodes = Array.from(an).map((node) => {
-              assignRef(node as Element)
-              return parseFragment(node as Element)
-            })
-
-            const removedNodes = Array.from(rn).map((node) => getRef(node))
-            const target = getRef(t)
-            const previousSibling = ps ? getRef(ps) : null
-            const nextSibling = ns ? getRef(ns) : null
-
-            let attributeValue: string | undefined
-            if (type === 'attributes') {
-              attributeValue = (t as Element).getAttribute(attributeName!) || ''
-            }
-            let newTextContent: string | undefined
-            if (type === 'characterData') {
-              newTextContent = (t as Element).textContent || ''
-            }
-
-            log(`added mutation: ${type}`)
-            return {
-              type,
-              attributeName,
-              attributeNamespace,
-              oldValue,
-              addedNodes,
-              target,
-              removedNodes,
-              previousSibling,
-              nextSibling,
-              timestamp,
-              attributeValue,
-              newTextContent
-            } as TraceMutation
-          }
-        )
+        mutationList.map((m) => serializeMutation(m, timestamp))
       )
-    } catch (err: any) {
-      collector.captureError(err)
+    } catch (err) {
+      collector.captureError(err as Error)
     }
   })
   observer.observe(document.body, config)
-} catch (err: any) {
-  collector.captureError(err)
+} catch (err) {
+  collector.captureError(err as Error)
 }
 
 log('Finished program')
diff --git a/packages/script/src/logger.ts b/packages/script/src/logger.ts
index 2228463b..d81e6aa8 100644
--- a/packages/script/src/logger.ts
+++ b/packages/script/src/logger.ts
@@ -1,6 +1,6 @@
 let logs: string[] = []
 
-export function log(...args: any[]) {
+export function log(...args: unknown[]) {
   logs.push(args.map((a) => JSON.stringify(a)).join(' '))
 }
 
diff --git a/packages/script/src/utils.ts b/packages/script/src/utils.ts
index 579d2d27..258b1358 100644
--- a/packages/script/src/utils.ts
+++ b/packages/script/src/utils.ts
@@ -14,7 +14,7 @@ export type vElement = DefaultTreeAdapterMap['element']
 export type vText = DefaultTreeAdapterMap['textNode']
 export type vChildNode = DefaultTreeAdapterMap['childNode']
 
-function createVNode(elem: any) {
+function createVNode(elem: { type: unknown; props: unknown }) {
   const { type, props } = elem
   return { type, props } as SimplifiedVNode
 }
@@ -22,7 +22,7 @@ function createVNode(elem: any) {
 export function parseNode(
   fragment: vFragment | vComment | vText | vChildNode
 ): SimplifiedVNode | string {
-  const props: Record<string, any> = {}
+  const props: Record<string, unknown> = {}
 
   if (fragment.nodeName === '#comment') {
     return (fragment as vComment).data
@@ -38,10 +38,10 @@ export function parseNode(
 
   try {
     return createVNode(
-      h(tagName, props, ...(childNodes || []).map((cn) => parseNode(cn))) as any
+      h(tagName, props, ...(childNodes || []).map((cn) => parseNode(cn)))
     )
-  } catch (err: any) {
-    return createVNode(h('div', { class: 'parseNode' }, err.stack))
+  } catch (err) {
+    return createVNode(h('div', { class: 'parseNode' }, (err as Error).stack))
   }
 }
 
@@ -49,8 +49,10 @@ export function parseDocument(node: HTMLElement) {
   try {
     const fragment = parse(node.outerHTML)
     return parseNode(fragment.childNodes[0])
-  } catch (err: any) {
-    return createVNode(h('div', { class: 'parseDocument' }, err.stack))
+  } catch (err) {
+    return createVNode(
+      h('div', { class: 'parseDocument' }, (err as Error).stack)
+    )
   }
 }
 
@@ -58,8 +60,10 @@ export function parseFragment(node: Element) {
   try {
     const fragment = parseFragmentImport(node.outerHTML)
     return parseNode(fragment)
-  } catch (err: any) {
-    return createVNode(h('div', { class: 'parseFragmentWrapper' }, err.stack))
+  } catch (err) {
+    return createVNode(
+      h('div', { class: 'parseFragmentWrapper' }, (err as Error).stack)
+    )
   }
 }
 
diff --git a/packages/script/tests/logger.test.ts b/packages/script/tests/logger.test.ts
new file mode 100644
index 00000000..d893ae64
--- /dev/null
+++ b/packages/script/tests/logger.test.ts
@@ -0,0 +1,36 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { clearLogs, getLogs, log } from '../src/logger.js'
+
+describe('script/logger', () => {
+  beforeEach(() => clearLogs())
+
+  it('appends a JSON-serialized line per call', () => {
+    log('hello', 42)
+    log({ a: 1 })
+    expect(getLogs()).toEqual(['"hello" 42', '{"a":1}'])
+  })
+
+  it('joins multiple args with a single space', () => {
+    log('a', 'b', 'c')
+    expect(getLogs()).toEqual(['"a" "b" "c"'])
+  })
+
+  it('clearLogs wipes the buffer', () => {
+    log('x')
+    clearLogs()
+    expect(getLogs()).toEqual([])
+  })
+
+  it('getLogs returns the live buffer (callers must not mutate)', () => {
+    log('one')
+    const snap = getLogs()
+    log('two')
+    expect(snap).toEqual(['"one"', '"two"'])
+  })
+
+  it('renders undefined args as an empty slot (JSON.stringify(undefined) → undefined)', () => {
+    log('a', undefined, 'b')
+    // JSON.stringify(undefined) returns undefined, and Array#join coerces it to ''
+    expect(getLogs()).toEqual(['"a"  "b"'])
+  })
+})
diff --git a/packages/script/tests/networkRequests.test.ts b/packages/script/tests/networkRequests.test.ts
index 96f64c22..b610d7a6 100644
--- a/packages/script/tests/networkRequests.test.ts
+++ b/packages/script/tests/networkRequests.test.ts
@@ -1,40 +1,259 @@
 /** @vitest-environment happy-dom */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import { NetworkRequestCollector } from '../src/collectors/networkRequests.js'
 
-describe('NetworkRequestCollector', () => {
-  let collector: NetworkRequestCollector
+// happy-dom doesn't ship a Blob with reliable .size in some versions —
+// fall back to a stub that returns the byte length so #estimateSize works
+// without depending on the polyfill flavor we land on.
+if (typeof globalThis.Blob === 'undefined') {
+  ;(globalThis as unknown as { Blob: unknown }).Blob = class {
+    size: number
+    constructor(parts: BlobPart[]) {
+      this.size = parts.reduce(
+        (n, p) => n + (typeof p === 'string' ? p.length : 0),
+        0
+      )
+    }
+  }
+}
 
-  beforeEach(() => {
-    collector = new NetworkRequestCollector()
-  })
+let collector: NetworkRequestCollector
+const realFetch = window.fetch
+let fetchMock: ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  // Patch fetch BEFORE constructing the collector so the collector wraps
+  // OUR mock and we can drive captures deterministically without real I/O.
+  fetchMock = vi.fn()
+  window.fetch = fetchMock as unknown as typeof fetch
+  collector = new NetworkRequestCollector()
+})
+
+afterEach(() => {
+  collector.clear()
+  window.fetch = realFetch
+})
 
-  afterEach(() => {
+describe('NetworkRequestCollector — lifecycle', () => {
+  it('starts empty and clear() resets the buffer', () => {
+    expect(collector.getArtifacts()).toEqual([])
     collector.clear()
+    expect(collector.getArtifacts()).toEqual([])
+    // Reference is stable across reads (callers can hold the array ref)
+    expect(collector.getArtifacts()).toBe(collector.getArtifacts())
   })
+})
+
+describe('NetworkRequestCollector — fetch capture', () => {
+  it('captures a successful JSON response with headers, body, timing, size', async () => {
+    fetchMock.mockResolvedValueOnce(
+      new Response('{"hello":"world"}', {
+        status: 200,
+        statusText: 'OK',
+        headers: { 'content-type': 'application/json' }
+      })
+    )
+
+    await window.fetch('https://api.example.com/data', {
+      method: 'POST',
+      headers: { 'x-trace': 'abc' },
+      body: JSON.stringify({ q: 1 })
+    })
 
-  it('should initialize, clear, and return artifacts correctly', () => {
-    // Test initialization
     const artifacts = collector.getArtifacts()
-    expect(artifacts).toEqual([])
-    expect(Array.isArray(artifacts)).toBe(true)
-    expect(artifacts).toHaveLength(0)
+    expect(artifacts).toHaveLength(1)
+    const req = artifacts[0]
+    expect(req).toMatchObject({
+      url: 'https://api.example.com/data',
+      method: 'POST',
+      type: 'fetch',
+      status: 200,
+      statusText: 'OK',
+      requestBody: JSON.stringify({ q: 1 }),
+      responseBody: '{"hello":"world"}'
+    })
+    expect(req.requestHeaders).toMatchObject({ 'x-trace': 'abc' })
+    expect(req.responseHeaders).toMatchObject({
+      'content-type': 'application/json'
+    })
+    expect(req.startTime).toBeTypeOf('number')
+    expect(req.endTime).toBeTypeOf('number')
+    expect(req.time).toBeGreaterThanOrEqual(0)
+  })
 
-    // Test clear functionality
-    collector.clear()
-    const clearedArtifacts = collector.getArtifacts()
-    expect(clearedArtifacts).toEqual([])
-    expect(clearedArtifacts).toHaveLength(0)
+  it('skips internal protocols (data:, blob:, chrome:, about:, ws:)', async () => {
+    for (const url of [
+      'data:text/plain,hello',
+      'blob:https://example.com/abc',
+      'chrome://settings',
+      'chrome-extension://abc/page',
+      'about:blank',
+      'ws://example.com',
+      'wss://example.com'
+    ]) {
+      fetchMock.mockResolvedValueOnce(new Response(''))
+      await window.fetch(url)
+    }
+    // Every call passed through to the original mock but NONE got captured
+    expect(collector.getArtifacts()).toEqual([])
+    expect(fetchMock).toHaveBeenCalledTimes(7)
+  })
 
-    // Test multiple clears are safe
-    collector.clear()
+  it('skips noise URLs (/favicon.ico, /.well-known/...)', async () => {
+    fetchMock.mockResolvedValue(new Response(''))
+    await window.fetch('https://example.com/favicon.ico')
+    await window.fetch('https://example.com/.well-known/something')
     expect(collector.getArtifacts()).toEqual([])
+  })
+
+  it('extracts the URL from URL objects (URL.href, not toString)', async () => {
+    fetchMock.mockResolvedValueOnce(
+      new Response('{"ok":1}', {
+        status: 200,
+        headers: { 'content-type': 'application/json' }
+      })
+    )
+    await window.fetch(new URL('https://example.com/x'))
+    expect(collector.getArtifacts()[0].url).toBe('https://example.com/x')
+  })
+
+  // Known limitation: the collector reads `init?.method` only — when a
+  // Request object is passed as the first arg with its own method, the
+  // collector reports 'GET' (the default) because it doesn't inspect
+  // Request.method. Pin the behavior here so a future change is intentional.
+  it('reports GET for Request-object inputs with a non-GET Request.method (known limitation)', async () => {
+    fetchMock.mockResolvedValueOnce(
+      new Response('{"ok":2}', {
+        status: 200,
+        headers: { 'content-type': 'application/json' }
+      })
+    )
+    await window.fetch(new Request('https://example.com/y', { method: 'PUT' }))
+    const captured = collector.getArtifacts()[0]
+    expect(captured.url).toBe('https://example.com/y')
+    expect(captured.method).toBe('GET') // not 'PUT' — see comment above
+  })
+
+  it('does not capture an entry when the underlying fetch rejects, and re-throws', async () => {
+    fetchMock.mockRejectedValueOnce(new Error('network down'))
+    await expect(window.fetch('https://example.com/will-fail')).rejects.toThrow(
+      'network down'
+    )
+    expect(collector.getArtifacts()).toEqual([])
+  })
+
+  it('extracts headers from all three accepted shapes (Headers, Array, plain object) and lowercases keys', async () => {
+    // Headers instance
+    fetchMock.mockResolvedValueOnce(
+      new Response('a', {
+        status: 200,
+        headers: { 'content-type': 'text/plain' }
+      })
+    )
+    await window.fetch('https://example.com/h1', {
+      headers: new Headers({ 'X-One': '1' })
+    })
+    // [[k,v]] tuple array
+    fetchMock.mockResolvedValueOnce(
+      new Response('b', {
+        status: 200,
+        headers: { 'content-type': 'text/plain' }
+      })
+    )
+    await window.fetch('https://example.com/h2', {
+      headers: [['X-Two', '2']]
+    })
+    // Plain object
+    fetchMock.mockResolvedValueOnce(
+      new Response('c', {
+        status: 200,
+        headers: { 'content-type': 'text/plain' }
+      })
+    )
+    await window.fetch('https://example.com/h3', {
+      headers: { 'X-Three': '3' }
+    })
+
+    const reqs = collector.getArtifacts()
+    expect(reqs[0].requestHeaders).toMatchObject({ 'x-one': '1' })
+    expect(reqs[1].requestHeaders).toMatchObject({ 'x-two': '2' })
+    expect(reqs[2].requestHeaders).toMatchObject({ 'x-three': '3' })
+  })
+})
+
+describe('NetworkRequestCollector — XHR capture', () => {
+  it('captures a successful JSON XHR (status + body + content-type filter passes)', async () => {
+    const xhr = new XMLHttpRequest()
+    xhr.open('GET', 'https://api.example.com/xhr')
+
+    // Patch the just-opened xhr to fake a successful JSON response without
+    // hitting the network. happy-dom doesn't deliver `load` for a never-sent
+    // request, so we wire up the response shape manually + fire the event.
+    Object.defineProperty(xhr, 'status', { value: 200, configurable: true })
+    Object.defineProperty(xhr, 'statusText', {
+      value: 'OK',
+      configurable: true
+    })
+    Object.defineProperty(xhr, 'responseText', {
+      value: '{"id":42}',
+      configurable: true
+    })
+    Object.defineProperty(xhr, 'getAllResponseHeaders', {
+      value: () => 'content-type: application/json\r\nx-rate-limit: 99\r\n',
+      configurable: true
+    })
+
+    xhr.send()
+    xhr.dispatchEvent(new Event('load'))
+
+    const reqs = collector.getArtifacts()
+    expect(reqs).toHaveLength(1)
+    expect(reqs[0]).toMatchObject({
+      url: 'https://api.example.com/xhr',
+      method: 'GET',
+      type: 'xhr',
+      status: 200,
+      statusText: 'OK',
+      responseBody: '{"id":42}'
+    })
+    expect(reqs[0].responseHeaders).toMatchObject({
+      'content-type': 'application/json',
+      'x-rate-limit': '99'
+    })
+  })
+
+  it('skips ignored URLs in XHR open (does not record)', () => {
+    const xhr = new XMLHttpRequest()
+    xhr.open('GET', 'data:text/plain,hello')
+    // The send + load aren't even needed — `open` was filtered, nothing in
+    // the pending map, nothing to record on load.
+    expect(collector.getArtifacts()).toEqual([])
+  })
+
+  it('captures request body for XHR POST + lowercases response headers', async () => {
+    const xhr = new XMLHttpRequest()
+    xhr.open('POST', 'https://api.example.com/submit')
+    Object.defineProperty(xhr, 'status', { value: 201, configurable: true })
+    Object.defineProperty(xhr, 'statusText', {
+      value: 'Created',
+      configurable: true
+    })
+    Object.defineProperty(xhr, 'responseText', {
+      value: 'OK',
+      configurable: true
+    })
+    Object.defineProperty(xhr, 'getAllResponseHeaders', {
+      value: () => 'Content-Type: text/plain\r\n',
+      configurable: true
+    })
+
+    xhr.send('payload-data')
+    xhr.dispatchEvent(new Event('load'))
 
-    // Test reference consistency
-    const artifacts1 = collector.getArtifacts()
-    const artifacts2 = collector.getArtifacts()
-    expect(artifacts1).toBe(artifacts2)
-    expect(artifacts1).toBeDefined()
-    expect(artifacts1).not.toBeNull()
+    const req = collector.getArtifacts()[0]
+    expect(req.requestBody).toBe('payload-data')
+    // Header key was uppercase "Content-Type" on the wire; the parser
+    // lowercases for consistency with the fetch path.
+    expect(req.responseHeaders).toHaveProperty('content-type', 'text/plain')
   })
 })
diff --git a/packages/selenium-devtools/README.md b/packages/selenium-devtools/README.md
index eb49b1c5..7722139c 100644
--- a/packages/selenium-devtools/README.md
+++ b/packages/selenium-devtools/README.md
@@ -394,6 +394,14 @@ The plugin patches `selenium-webdriver`'s `Builder`, `WebDriver`, and `WebElemen
 
 When BiDi is available (Chrome ≥114), console logs, JavaScript exceptions, and network events stream directly via the Selenium BiDi handlers. Otherwise the plugin falls back to an injected browser-side collector script.
 
+> The BiDi attach + inspector wiring lives in [`@wdio/devtools-core`'s `bidi.ts`](../core/src/bidi.ts) (`loadSeleniumSubmodule`, `attachBidiHandlers`, `arrayHeadersToObject`) — the same helpers nightwatch-devtools uses when its `bidi: true` opt-in is enabled. This adapter's `bidi.ts` keeps only the selenium-specific Builder-cap helpers (`ensureBidiCapability`, `ensureHeadlessChrome`) and the `buildBidiSinks` wrapper.
+
+### Performance API capture
+
+After every navigation command (`get`, `navigate`, `navigateTo`, etc.), the plugin runs the shared `CAPTURE_PERFORMANCE_SCRIPT` from `@wdio/devtools-core` to read `window.performance.getEntriesByType('navigation' | 'resource')`, cookies, and document info. The result is attached to the command entry in the Actions tab so you see `loadTime` / `domReady` / `responseTime` / resource counts / cookies / document title per navigation.
+
+Same script and post-processing (`applyPerformanceData`) used by `@wdio/devtools-service` and `@wdio/nightwatch-devtools` — uniform dashboard fields across all three adapters.
+
 ---
 
 ## Limitations
diff --git a/packages/selenium-devtools/example/cucumber-test/cucumber.json b/packages/selenium-devtools/example/cucumber-test/cucumber.json
deleted file mode 100644
index b96a2d20..00000000
--- a/packages/selenium-devtools/example/cucumber-test/cucumber.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "default": {
-    "import": [
-      "example/cucumber-test/features/support/setup.js",
-      "example/cucumber-test/features/support/world.js",
-      "example/cucumber-test/features/support/steps.js"
-    ],
-    "paths": ["example/cucumber-test/features/*.feature"],
-    "publishQuiet": true,
-    "format": ["progress"]
-  }
-}
diff --git a/packages/selenium-devtools/package.json b/packages/selenium-devtools/package.json
index fb8b93ae..0b118b7f 100644
--- a/packages/selenium-devtools/package.json
+++ b/packages/selenium-devtools/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@wdio/selenium-devtools",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Selenium WebDriver adapter for WebdriverIO DevTools — runner-agnostic, reuses existing backend, UI, and capture infrastructure",
   "type": "module",
   "main": "dist/index.js",
@@ -22,15 +22,15 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
+    "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",
+    "watch": "tsup src/index.ts --format esm --dts --sourcemap --watch",
     "clean": "rm -rf dist",
     "lint": "eslint .",
     "prepublishOnly": "pnpm build",
-    "example:mocha": "mocha --require @wdio/selenium-devtools --timeout 60000 example/mocha-test/test/example.js",
-    "example:jest": "NODE_OPTIONS=--experimental-vm-modules jest --config example/jest-test/jest.config.json",
-    "example:vitest": "vitest run --config example/vitest-test/vitest.config.js",
-    "example:cucumber": "cucumber-js --config example/cucumber-test/cucumber.json"
+    "example": "pnpm example:cucumber",
+    "example:mocha": "mocha --require @wdio/selenium-devtools --timeout 60000 ../../examples/selenium/mocha-test/test/example.js",
+    "example:jest": "NODE_OPTIONS=--experimental-vm-modules jest --config ../../examples/selenium/jest-test/jest.config.json",
+    "example:cucumber": "cucumber-js --config ../../examples/selenium/cucumber-test/cucumber.json"
   },
   "keywords": [
     "selenium",
@@ -44,24 +44,27 @@
   "dependencies": {
     "@wdio/devtools-backend": "workspace:*",
     "@wdio/devtools-script": "workspace:*",
-    "@wdio/logger": "^9.6.0",
+    "@wdio/logger": "^9.18.0",
     "stacktrace-parser": "^0.1.11",
-    "webdriverio": "^9.18.0",
-    "ws": "^8.18.3"
+    "webdriverio": "^9.27.2",
+    "ws": "^8.21.0"
   },
   "optionalDependencies": {
     "fluent-ffmpeg": "^2.1.3"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "^11.1.0",
-    "@types/node": "25.5.2",
+    "@cucumber/cucumber": "^13.0.0",
+    "@types/node": "25.9.1",
     "@types/ws": "^8.18.1",
-    "chromedriver": "^147.0.1",
-    "jest": "^29.7.0",
-    "mocha": "^10.7.0",
-    "selenium-webdriver": "^4.27.0",
-    "typescript": "^6.0.2",
-    "vitest": "^2.1.9"
+    "@wdio/devtools-core": "workspace:^",
+    "@wdio/devtools-shared": "workspace:^",
+    "chromedriver": "^148.0.4",
+    "jest": "^30.4.2",
+    "mocha": "^11.7.6",
+    "selenium-webdriver": "^4.44.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
   },
   "peerDependencies": {
     "selenium-webdriver": ">=4.8.0"
diff --git a/packages/selenium-devtools/src/assertPatcher.ts b/packages/selenium-devtools/src/assertPatcher.ts
index 9cc4e8f2..008df8e4 100644
--- a/packages/selenium-devtools/src/assertPatcher.ts
+++ b/packages/selenium-devtools/src/assertPatcher.ts
@@ -1,133 +1,28 @@
-import { createRequire } from 'node:module'
 import logger from '@wdio/logger'
-import { ASSERT_PATCHED_SYMBOL, TRACKED_ASSERT_METHODS } from './constants.js'
-import { getCallSourceFromStack } from './helpers/utils.js'
+import {
+  patchNodeAssert as patchNodeAssertCore,
+  type CapturedAssert
+} from '@wdio/devtools-core'
 import type { CapturedCommand } from './types.js'
 
 const log = logger('@wdio/selenium-devtools:assertPatcher')
-const require = createRequire(import.meta.url)
-
-function safeSerialize(value: any): any {
-  if (value === null || value === undefined) {
-    return value
-  }
-  if (value instanceof RegExp) {
-    return value.toString()
-  }
-  if (typeof value === 'function') {
-    return '[Function]'
-  }
-  if (typeof value === 'object') {
-    try {
-      return JSON.parse(JSON.stringify(value))
-    } catch {
-      return String(value)
-    }
-  }
-  return value
-}
 
 /**
- * Patch `node:assert` so each tracked method emits a `CapturedCommand` to
- * the supplied hook. Idempotent — calling twice doesn't double-wrap.
- *
- * Note: we patch BOTH the function-form (`assert(...)`) and the namespace
- * methods (`assert.equal(...)`). User code that imported the methods BEFORE
- * this patcher loaded will already have stale references — to be safe,
- * the plugin's main entry imports node:assert before the user's test files.
+ * Selenium-specific wrapper around the core `patchNodeAssert`. Maps each
+ * captured assert to selenium's wider `CapturedCommand` shape (adding the
+ * `fromElement: false` bookkeeping field) and routes its logger through the
+ * adapter's namespace.
  */
 export function patchNodeAssert(
   onCommand: (cmd: CapturedCommand) => void
 ): boolean {
-  let assertModule: any
-  try {
-    assertModule = require('node:assert')
-  } catch {
-    log.warn('node:assert not available — skipping assertion capture')
-    return false
-  }
-
-  if ((assertModule as any)[ASSERT_PATCHED_SYMBOL]) {
-    return true
-  }
-  ;(assertModule as any)[ASSERT_PATCHED_SYMBOL] = true
-
-  // Wrap each tracked method on `assert` and `assert.strict`. We don't
-  // overwrite `assert.strict.equal` separately because Node's strict
-  // namespace shares method bodies internally — patching the surface is
-  // enough.
-  const wrapMethod = (methodName: string) => {
-    const original = (assertModule as any)[methodName]
-    if (typeof original !== 'function') {
-      return
-    }
-    ;(assertModule as any)[methodName] = function patchedAssert(
-      ...args: any[]
-    ) {
-      const callInfo = getCallSourceFromStack()
-      const startedAt = Date.now()
-      const sanitizedArgs = args.map(safeSerialize)
-
-      try {
-        const result = original.apply(this, args)
-        // Async assert methods (rejects/doesNotReject) return a Promise.
-        if (result && typeof result.then === 'function') {
-          return result.then(
-            (v: any) => {
-              onCommand({
-                command: `assert.${methodName}`,
-                args: sanitizedArgs,
-                result: 'passed',
-                error: undefined,
-                callSource: callInfo.callSource,
-                timestamp: startedAt,
-                fromElement: false
-              })
-              return v
-            },
-            (err: any) => {
-              onCommand({
-                command: `assert.${methodName}`,
-                args: sanitizedArgs,
-                result: undefined,
-                error: err instanceof Error ? err : new Error(String(err)),
-                callSource: callInfo.callSource,
-                timestamp: startedAt,
-                fromElement: false
-              })
-              throw err
-            }
-          )
-        }
-        onCommand({
-          command: `assert.${methodName}`,
-          args: sanitizedArgs,
-          result: 'passed',
-          error: undefined,
-          callSource: callInfo.callSource,
-          timestamp: startedAt,
-          fromElement: false
-        })
-        return result
-      } catch (err) {
-        onCommand({
-          command: `assert.${methodName}`,
-          args: sanitizedArgs,
-          result: undefined,
-          error: err instanceof Error ? err : new Error(String(err)),
-          callSource: callInfo.callSource,
-          timestamp: startedAt,
-          fromElement: false
-        })
-        throw err
-      }
-    }
-  }
-
-  for (const m of TRACKED_ASSERT_METHODS) {
-    wrapMethod(m)
-  }
-
-  log.info(`Patched ${TRACKED_ASSERT_METHODS.length} node:assert method(s)`)
-  return true
+  return patchNodeAssertCore(
+    (cmd: CapturedAssert) =>
+      onCommand({
+        ...cmd,
+        rawResult: undefined,
+        fromElement: false
+      }),
+    (level, message) => log[level](message)
+  )
 }
diff --git a/packages/selenium-devtools/src/bidi.ts b/packages/selenium-devtools/src/bidi.ts
index 8b2556d6..a4a62149 100644
--- a/packages/selenium-devtools/src/bidi.ts
+++ b/packages/selenium-devtools/src/bidi.ts
@@ -1,28 +1,45 @@
-import { createRequire } from 'node:module'
 import logger from '@wdio/logger'
-import { LOG_SOURCES } from './constants.js'
-import { chromeLogLevelToLogLevel, getRequestType } from './helpers/utils.js'
-import type { BidiHandlerSinks, LogLevel, NetworkRequest } from './types.js'
+import {
+  type BidiHandlerSinks,
+  attachBidiHandlers as attachBidiHandlersCore,
+  errorMessage
+} from '@wdio/devtools-core'
 import type { SessionCapturer } from './session.js'
 
 const log = logger('@wdio/selenium-devtools:bidi')
 
-function loadSeleniumSubmodule(subpath: string): any | null {
-  try {
-    const userRequire = createRequire(`${process.cwd()}/`)
-    return userRequire(`selenium-webdriver/${subpath}`)
-  } catch {
-    try {
-      const localRequire = createRequire(import.meta.url)
-      return localRequire(`selenium-webdriver/${subpath}`)
-    } catch {
-      return null
-    }
+// Generic BiDi attach/load helpers live in @wdio/devtools-core; re-exported
+// here so existing internal imports from './bidi.js' continue to resolve.
+export {
+  arrayHeadersToObject,
+  loadSeleniumSubmodule,
+  type BidiHandlerSinks
+} from '@wdio/devtools-core'
+
+// Sets webSocketUrl=true so the driver actually exposes the BiDi channel.
+// Selenium-specific because it operates on the selenium-webdriver Builder.
+/** Minimal shape of a selenium-webdriver `Builder` we touch. */
+interface CapabilitiesLike {
+  get?: (key: string) => unknown
+  set?: (key: string, value: unknown) => void
+  has?: (key: string) => boolean
+}
+interface BuilderLike {
+  getCapabilities?: () => CapabilitiesLike | null | undefined
+}
+
+function asBuilder(value: unknown): BuilderLike | null {
+  if (!value || typeof value !== 'object') {
+    return null
   }
+  return value as BuilderLike
 }
 
-// Sets webSocketUrl=true so the driver actually exposes the BiDi channel.
-export function ensureBidiCapability(builder: any): void {
+export function ensureBidiCapability(rawBuilder: unknown): void {
+  const builder = asBuilder(rawBuilder)
+  if (!builder) {
+    return
+  }
   try {
     const caps =
       typeof builder?.getCapabilities === 'function'
@@ -37,24 +54,36 @@ export function ensureBidiCapability(builder: any): void {
     caps.set('webSocketUrl', true)
     log.info('Set webSocketUrl=true on builder capabilities (BiDi enabled)')
   } catch (err) {
-    log.warn(`Failed to set webSocketUrl capability: ${(err as Error).message}`)
+    log.warn(`Failed to set webSocketUrl capability: ${errorMessage(err)}`)
   }
 }
 
 // `--headless=old` (not `=new`) — `new` produces all-black frames under
 // CDP `Page.startScreencast` on macOS (upstream Chrome bug).
-export function ensureHeadlessChrome(builder: any): void {
+// Selenium-specific because it operates on the selenium-webdriver Builder.
+export function ensureHeadlessChrome(rawBuilder: unknown): void {
+  const builder = asBuilder(rawBuilder)
+  if (!builder) {
+    return
+  }
   try {
     const caps =
       typeof builder?.getCapabilities === 'function'
         ? builder.getCapabilities()
         : null
-    if (!caps || typeof caps.get !== 'function') {
+    if (
+      !caps ||
+      typeof caps.get !== 'function' ||
+      typeof caps.set !== 'function'
+    ) {
       return
     }
-    const existing = caps.get('goog:chromeOptions') ?? {}
+    const existing = (caps.get('goog:chromeOptions') ?? {}) as {
+      args?: unknown
+      [k: string]: unknown
+    }
     const args: string[] = Array.isArray(existing.args)
-      ? [...existing.args]
+      ? (existing.args as string[]).slice()
       : []
     const hasHeadless = args.some(
       (a) => typeof a === 'string' && a.startsWith('--headless')
@@ -66,155 +95,22 @@ export function ensureHeadlessChrome(builder: any): void {
     caps.set('goog:chromeOptions', { ...existing, args })
     log.info('Injected --headless=old into Chrome capabilities')
   } catch (err) {
-    log.warn(`Failed to set headless Chrome option: ${(err as Error).message}`)
+    log.warn(`Failed to set headless Chrome option: ${errorMessage(err)}`)
   }
 }
 
-// Returns true when at least one stream connected — caller disables the
-// equivalent script-injection collectors to avoid duplicates.
+/**
+ * Selenium-specific wrapper around the core `attachBidiHandlers`. Adds the
+ * adapter's logger so users see BiDi lifecycle events under the
+ * `@wdio/selenium-devtools:bidi` namespace they're used to.
+ */
 export async function attachBidiHandlers(
-  driver: any,
+  driver: unknown,
   sinks: BidiHandlerSinks
 ): Promise<boolean> {
-  const logInspectorFactory = loadSeleniumSubmodule('bidi/logInspector')
-  const networkInspectorFactory = loadSeleniumSubmodule('bidi/networkInspector')
-
-  let attached = 0
-
-  if (typeof logInspectorFactory === 'function') {
-    try {
-      const inspector = await logInspectorFactory(driver)
-      await inspector.onConsoleEntry((entry: any) => {
-        try {
-          const level = (entry?.level ?? entry?.type ?? 'info').toString()
-          const text = entry?.text ?? entry?.message ?? ''
-          sinks.pushConsoleLog({
-            timestamp: Number(entry?.timestamp) || Date.now(),
-            type: chromeLogLevelToLogLevel(level) as LogLevel,
-            args: [text],
-            source: LOG_SOURCES.BROWSER
-          })
-        } catch (err) {
-          log.warn(`onConsoleEntry handler threw: ${(err as Error).message}`)
-        }
-      })
-      await inspector.onJavascriptException((exception: any) => {
-        try {
-          const text =
-            exception?.text ?? exception?.message ?? String(exception)
-          const trimmed = String(text).replace(/\s+/g, ' ').slice(0, 200)
-          log.warn(
-            `🐛 JS error in page: ${trimmed}${String(text).length > 200 ? '…' : ''}`
-          )
-          sinks.pushConsoleLog({
-            timestamp: Date.now(),
-            type: 'error',
-            args: [text],
-            source: LOG_SOURCES.BROWSER
-          })
-        } catch (err) {
-          log.warn(
-            `onJavascriptException handler threw: ${(err as Error).message}`
-          )
-        }
-      })
-      attached++
-      log.info('✓ BiDi LogInspector attached (console + JS exceptions)')
-    } catch (err) {
-      log.warn(`BiDi LogInspector attach failed: ${(err as Error).message}`)
-    }
-  } else {
-    log.info('selenium-webdriver/bidi/logInspector not available — skipping')
-  }
-
-  if (typeof networkInspectorFactory === 'function') {
-    try {
-      const inspector = await networkInspectorFactory(driver)
-      const pending = new Map<string, NetworkRequest>()
-
-      await inspector.beforeRequestSent((event: any) => {
-        try {
-          const requestId = String(event?.request?.request ?? event?.id ?? '')
-          if (!requestId) {
-            return
-          }
-          const entry: NetworkRequest = {
-            id: requestId,
-            url: event?.request?.url ?? '',
-            method: event?.request?.method ?? 'GET',
-            requestHeaders: arrayHeadersToObject(event?.request?.headers),
-            timestamp: Date.now(),
-            startTime: Number(event?.timestamp ?? Date.now()),
-            type: getRequestType(event?.request?.url ?? '')
-          }
-          pending.set(requestId, entry)
-          sinks.pushNetworkRequest(entry)
-        } catch (err) {
-          log.warn(`beforeRequestSent threw: ${(err as Error).message}`)
-        }
-      })
-
-      await inspector.responseCompleted((event: any) => {
-        try {
-          const requestId = String(event?.request?.request ?? event?.id ?? '')
-          const previous = pending.get(requestId)
-          if (!previous) {
-            return
-          }
-          const finalized: NetworkRequest = {
-            ...previous,
-            status: Number(event?.response?.status) || previous.status,
-            statusText: event?.response?.statusText ?? previous.statusText,
-            responseHeaders: arrayHeadersToObject(event?.response?.headers),
-            type: getRequestType(previous.url, event?.response?.mimeType),
-            endTime: Number(event?.timestamp ?? Date.now()),
-            time: Number(event?.timestamp ?? Date.now()) - previous.startTime,
-            size: Number(event?.response?.bytesReceived) || undefined
-          }
-          pending.delete(requestId)
-          sinks.replaceNetworkRequest(requestId, finalized)
-        } catch (err) {
-          log.warn(`responseCompleted threw: ${(err as Error).message}`)
-        }
-      })
-
-      attached++
-      log.info('✓ BiDi NetworkInspector attached (request + response)')
-    } catch (err) {
-      log.warn(`BiDi NetworkInspector attach failed: ${(err as Error).message}`)
-    }
-  } else {
-    log.info(
-      'selenium-webdriver/bidi/networkInspector not available — skipping'
-    )
-  }
-
-  return attached > 0
-}
-
-// BiDi headers arrive as Array<{name, value:{value|type}}>; flatten to a
-// lowercased dictionary.
-function arrayHeadersToObject(
-  headers: any
-): Record<string, string> | undefined {
-  if (!Array.isArray(headers)) {
-    return undefined
-  }
-  const out: Record<string, string> = {}
-  for (const h of headers) {
-    const name = String(h?.name ?? '').toLowerCase()
-    if (!name) {
-      continue
-    }
-    const v = h?.value
-    out[name] =
-      typeof v === 'string'
-        ? v
-        : typeof v?.value === 'string'
-          ? v.value
-          : JSON.stringify(v ?? '')
-  }
-  return out
+  return attachBidiHandlersCore(driver, sinks, (level, message) =>
+    log[level](message)
+  )
 }
 
 export function buildBidiSinks(capturer: SessionCapturer): BidiHandlerSinks {
@@ -228,7 +124,9 @@ export function buildBidiSinks(capturer: SessionCapturer): BidiHandlerSinks {
       capturer.sendUpstream('networkRequests', [entry])
     },
     replaceNetworkRequest: (id, entry) => {
-      const idx = capturer.networkRequests.findIndex((r: any) => r.id === id)
+      const idx = capturer.networkRequests.findIndex(
+        (r: NetworkRequestWithId) => r.id === id
+      )
       if (idx !== -1) {
         capturer.networkRequests[idx] = entry
       } else {
@@ -238,3 +136,5 @@ export function buildBidiSinks(capturer: SessionCapturer): BidiHandlerSinks {
     }
   }
 }
+
+type NetworkRequestWithId = { id?: string }
diff --git a/packages/selenium-devtools/src/constants.ts b/packages/selenium-devtools/src/constants.ts
index c5077768..50457bea 100644
--- a/packages/selenium-devtools/src/constants.ts
+++ b/packages/selenium-devtools/src/constants.ts
@@ -64,72 +64,36 @@ export const NAVIGATION_COMMANDS = [
   'refresh'
 ] as const
 
-export const CONSOLE_METHODS = ['log', 'info', 'warn', 'error'] as const
+// Console capture constants are defined in @wdio/devtools-core; re-exported
+// here so existing imports from ./constants.js continue to work.
+export { ANSI_REGEX, CONSOLE_METHODS, LOG_SOURCES } from '@wdio/devtools-core'
 
-export const LOG_SOURCES = {
-  BROWSER: 'browser',
-  TEST: 'test',
-  TERMINAL: 'terminal'
-} as const
-
-export const ANSI_REGEX = /\x1b\[[?]?[0-9;]*[A-Za-z]/g
+export { SPINNER_RE } from '@wdio/devtools-core'
 
-export const SPINNER_RE = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/u
+import { DEFAULTS_BASE, TIMING_BASE } from '@wdio/devtools-shared'
 
 export const DEFAULTS = {
-  CID: '0-0',
+  ...DEFAULTS_BASE,
   SESSION_TITLE: 'Selenium Session',
-  FILE_NAME: 'selenium',
-  RETRIES: 0,
-  DURATION: 0
+  FILE_NAME: 'selenium'
 } as const
 
 export const TIMING = {
-  UI_RENDER_DELAY: 150,
-  TEST_START_DELAY: 100,
-  SUITE_COMPLETE_DELAY: 200,
-  UI_CONNECTION_WAIT: 2000,
-  BROWSER_CLOSE_WAIT: 2000,
-  INITIAL_CONNECTION_WAIT: 500,
-  BROWSER_POLL_INTERVAL: 1000
+  ...TIMING_BASE,
+  /** Selenium boots fast — 2s is enough for the dashboard to attach. */
+  UI_CONNECTION_WAIT: 2000
 } as const
 
-export const TEST_STATE = {
-  PENDING: 'pending',
-  RUNNING: 'running',
-  PASSED: 'passed',
-  FAILED: 'failed',
-  SKIPPED: 'skipped'
-} as const
+export { TEST_STATE } from '@wdio/devtools-shared'
 
-export const LOG_LEVEL_PATTERNS: ReadonlyArray<{
-  level: 'trace' | 'debug' | 'info' | 'warn' | 'error'
-  pattern: RegExp
-}> = [
-  { level: 'trace', pattern: /\btrace\b/i },
-  { level: 'debug', pattern: /\bdebug\b/i },
-  { level: 'info', pattern: /\binfo\b/i },
-  { level: 'warn', pattern: /\bwarn(ing)?\b/i },
-  { level: 'error', pattern: /\berror\b/i }
-] as const
+export { LOG_LEVEL_PATTERNS } from '@wdio/devtools-core'
 
-export const SCREENCAST_DEFAULTS = {
-  enabled: false,
-  captureFormat: 'jpeg' as const,
-  quality: 70,
-  maxWidth: 1280,
-  maxHeight: 720,
-  pollIntervalMs: 200
-}
+// SCREENCAST_DEFAULTS hoisted to @wdio/devtools-shared; re-exported for
+// backwards compatibility with existing selenium-internal imports.
+export { SCREENCAST_DEFAULTS } from '@wdio/devtools-shared'
 
 /** Test-state environment markers used by the rerun handshake. */
-export const REUSE_ENV = {
-  REUSE: 'DEVTOOLS_APP_REUSE',
-  HOST: 'DEVTOOLS_APP_HOST',
-  PORT: 'DEVTOOLS_APP_PORT',
-  RERUN_LABEL: 'DEVTOOLS_RERUN_LABEL',
-  RERUN_ENTRY_TYPE: 'DEVTOOLS_RERUN_ENTRY_TYPE'
-} as const
+export { REUSE_ENV } from '@wdio/devtools-shared'
 
 /**
  * Decoded JPEG bytes below which a frame is treated as blank/uniform
diff --git a/packages/selenium-devtools/src/driverPatcher.ts b/packages/selenium-devtools/src/driverPatcher.ts
index 2f39e85f..d4b4a1c5 100644
--- a/packages/selenium-devtools/src/driverPatcher.ts
+++ b/packages/selenium-devtools/src/driverPatcher.ts
@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module'
 import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
 import {
   INTERNAL_DRIVER_METHODS,
   PATCHED_SYMBOL,
@@ -9,7 +10,8 @@ import { getCallSourceFromStack } from './helpers/utils.js'
 import type {
   DriverOriginals,
   DriverPatcherHooks,
-  ElementOriginals
+  ElementOriginals,
+  SeleniumDriverLike
 } from './types.js'
 
 const log = logger('@wdio/selenium-devtools:driverPatcher')
@@ -25,34 +27,43 @@ export function getElementOriginals(): ElementOriginals {
   return elementOriginals
 }
 
+/** Shape of the selenium-webdriver module surface we touch. */
+interface SeleniumModule {
+  Builder?: ConstructorLike
+  WebDriver?: ConstructorLike
+  WebElement?: ConstructorLike
+}
+interface ConstructorLike {
+  prototype: object
+}
+
 // Resolve user's selenium-webdriver first, then fall back to our own.
-function loadSeleniumWebdriver(): any | null {
+function loadSeleniumWebdriver(): SeleniumModule | null {
   try {
     const userRequire = createRequire(`${process.cwd()}/`)
-    return userRequire('selenium-webdriver')
+    return userRequire('selenium-webdriver') as SeleniumModule
   } catch {
     try {
       const localRequire = createRequire(import.meta.url)
-      return localRequire('selenium-webdriver')
+      return localRequire('selenium-webdriver') as SeleniumModule
     } catch (err) {
       log.warn(
-        `selenium-webdriver not found — devtools auto-attach disabled. (${(err as Error).message})`
+        `selenium-webdriver not found — devtools auto-attach disabled. (${errorMessage(err)})`
       )
       return null
     }
   }
 }
 
-function isWebElementLike(v: any): boolean {
-  return (
-    v &&
-    typeof v === 'object' &&
-    typeof v.getId === 'function' &&
-    typeof v.click === 'function'
-  )
+export function isWebElementLike(v: unknown): boolean {
+  if (!v || typeof v !== 'object') {
+    return false
+  }
+  const o = v as { getId?: unknown; click?: unknown }
+  return typeof o.getId === 'function' && typeof o.click === 'function'
 }
 
-function safeSerialize(value: any): any {
+export function safeSerialize(value: unknown): unknown {
   if (value === null || value === undefined) {
     return value
   }
@@ -68,7 +79,8 @@ function safeSerialize(value: any): any {
     'value' in value &&
     Object.keys(value).length === 2
   ) {
-    return `By.${value.using}(${JSON.stringify(value.value)})`
+    const v = value as { using: string; value: unknown }
+    return `By.${v.using}(${JSON.stringify(v.value)})`
   }
   if (Array.isArray(value)) {
     if (value.length > 0 && value.every(isWebElementLike)) {
@@ -86,81 +98,261 @@ function safeSerialize(value: any): any {
   return value
 }
 
-function webElementSummary(el: any): string {
+export function webElementSummary(el: unknown): string {
   // `id_` is a Promise; some selenium versions stash the resolved value sync.
-  const peek = el?.id_?._value ?? el?.id_?.value ?? null
+  const id = (el as { id_?: { _value?: unknown; value?: unknown } } | null)?.id_
+  const peek = id?._value ?? id?.value ?? null
   return peek ? `<WebElement id=${peek}>` : '<WebElement>'
 }
 
+// Selenium prototypes (WebDriver/WebElement/Builder) carry methods we patch
+// dynamically — Reflect.{get,set} keeps the casts to a single location and
+// drops per-line `as any`.
+type Patchable = Record<string | symbol, unknown>
+
+function makeWrappedMethod(
+  original: (...args: unknown[]) => unknown,
+  methodName: string,
+  fromElement: boolean,
+  hooks: DriverPatcherHooks
+): (...args: unknown[]) => unknown {
+  return function (this: unknown, ...args: unknown[]): unknown {
+    const callInfo = getCallSourceFromStack()
+    const startedAt = Date.now()
+    const sanitizedArgs = args.map(safeSerialize)
+    const settle = (result: unknown, error: Error | undefined) => {
+      try {
+        hooks.onCommand({
+          command: methodName,
+          args: sanitizedArgs,
+          result: error ? undefined : safeSerialize(result),
+          rawResult: error ? undefined : result,
+          error,
+          callSource: callInfo.callSource,
+          timestamp: startedAt,
+          fromElement
+        })
+      } catch (hookErr) {
+        log.warn(
+          `onCommand hook threw for ${methodName}: ${(hookErr as Error).message}`
+        )
+      }
+    }
+
+    let result: unknown
+    try {
+      result = original.apply(this, args)
+    } catch (err) {
+      settle(undefined, err as Error)
+      throw err
+    }
+
+    // CRITICAL: return the original thenable. findElement returns a
+    // WebElementPromise that carries sendKeys/click for chaining; a plain
+    // Promise from `.then(...)` would break `findElement(...).sendKeys(...)`.
+    const thenable = result as { then?: PromiseLike<unknown>['then'] } | null
+    if (thenable && typeof thenable.then === 'function') {
+      thenable.then(
+        (v: unknown) => settle(v, undefined),
+        (err: unknown) => settle(undefined, err as Error)
+      )
+      return result
+    }
+    settle(result, undefined)
+    return result
+  }
+}
+
 function wrapPrototype(
   proto: object,
   methodNames: Iterable<string>,
   fromElement: boolean,
   hooks: DriverPatcherHooks
 ): string[] {
-  if ((proto as any)[PATCHED_SYMBOL]) {
+  const p = proto as Patchable
+  if (p[PATCHED_SYMBOL]) {
     return []
   }
-  ;(proto as any)[PATCHED_SYMBOL] = true
+  p[PATCHED_SYMBOL] = true
 
   const wrapped: string[] = []
   for (const methodName of methodNames) {
-    const original = (proto as any)[methodName]
+    const original = p[methodName]
     if (typeof original !== 'function') {
       continue
     }
     if (methodName === 'constructor' || methodName.startsWith('__')) {
       continue
     }
+    p[methodName] = makeWrappedMethod(
+      original as (...args: unknown[]) => unknown,
+      methodName,
+      fromElement,
+      hooks
+    )
+    wrapped.push(methodName)
+  }
+  return wrapped
+}
 
-    ;(proto as any)[methodName] = function (...args: any[]): any {
-      const callInfo = getCallSourceFromStack()
-      const startedAt = Date.now()
-      const sanitizedArgs = args.map(safeSerialize)
-      const settle = (result: any, error: Error | undefined) => {
-        try {
-          hooks.onCommand({
-            command: methodName,
-            args: sanitizedArgs,
-            result: error ? undefined : safeSerialize(result),
-            rawResult: error ? undefined : result,
-            error,
-            callSource: callInfo.callSource,
-            timestamp: startedAt,
-            fromElement
-          })
-        } catch (hookErr) {
-          log.warn(
-            `onCommand hook threw for ${methodName}: ${(hookErr as Error).message}`
-          )
-        }
-      }
+function stashDriverOriginals(driverProto: Patchable): void {
+  const ts = driverProto.takeScreenshot
+  if (typeof ts === 'function') {
+    const orig = ts as (this: unknown) => unknown
+    originals.takeScreenshot = (driver) => orig.call(driver) as Promise<string>
+  }
+  const es = driverProto.executeScript
+  if (typeof es === 'function') {
+    const orig = es as (
+      this: unknown,
+      script: string,
+      ...args: unknown[]
+    ) => unknown
+    originals.executeScript = (driver, script, ...args) =>
+      orig.call(driver, script, ...args) as Promise<unknown>
+  }
+  const mg = driverProto.manage
+  if (typeof mg === 'function') {
+    const orig = mg as (this: unknown) => unknown
+    originals.manage = (driver) =>
+      orig.call(driver) as ReturnType<typeof orig> & object
+  }
+}
 
-      let result: any
+// Lets onBeforeQuit flush async cleanup before runners that `process.exit()`
+// tear down (those bypass node's beforeExit).
+function patchDriverQuit(
+  driverProto: Patchable,
+  hooks: DriverPatcherHooks
+): void {
+  const quit = driverProto.quit
+  if (typeof quit !== 'function') {
+    return
+  }
+  const originalQuit = quit as (this: unknown) => unknown
+  driverProto.quit = async function patchedQuit(this: unknown) {
+    if (hooks.onBeforeQuit) {
       try {
-        result = original.apply(this, args)
+        await hooks.onBeforeQuit(this as SeleniumDriverLike)
       } catch (err) {
-        settle(undefined, err as Error)
-        throw err
+        log.warn(`onBeforeQuit hook threw: ${errorMessage(err)}`)
       }
+    }
+    return originalQuit.call(this)
+  }
+  log.info('Wrapped WebDriver.quit (cleanup hook)')
+}
 
-      // CRITICAL: return the original thenable. findElement returns a
-      // WebElementPromise that carries sendKeys/click for chaining; a plain
-      // Promise from `.then(...)` would break `findElement(...).sendKeys(...)`.
-      if (result && typeof result.then === 'function') {
-        result.then(
-          (v: any) => settle(v, undefined),
-          (err: any) => settle(undefined, err as Error)
-        )
-        return result
+function patchWebElement(
+  WebElement: ConstructorLike,
+  hooks: DriverPatcherHooks
+): void {
+  const elProto = WebElement.prototype as Patchable
+  const gt = elProto.getText
+  if (typeof gt === 'function') {
+    const orig = gt as (this: unknown) => unknown
+    elementOriginals.getText = (el) => orig.call(el) as Promise<string>
+  }
+  const gtn = elProto.getTagName
+  if (typeof gtn === 'function') {
+    const orig = gtn as (this: unknown) => unknown
+    elementOriginals.getTagName = (el) => orig.call(el) as Promise<string>
+  }
+  const wrappedEl = wrapPrototype(
+    WebElement.prototype,
+    TRACKED_ELEMENT_METHODS,
+    /* fromElement */ true,
+    hooks
+  )
+  log.info(`Wrapped ${wrappedEl.length} WebElement method(s)`)
+}
+
+function patchBuilder(
+  Builder: ConstructorLike,
+  hooks: DriverPatcherHooks
+): void {
+  const builderProto = Builder.prototype as Patchable
+  if (builderProto[PATCHED_SYMBOL]) {
+    return
+  }
+  builderProto[PATCHED_SYMBOL] = true
+  const originalBuild = builderProto.build as (
+    this: unknown,
+    ...args: unknown[]
+  ) => unknown
+  builderProto.build = function patchedBuild(
+    this: unknown,
+    ...args: unknown[]
+  ) {
+    if (hooks.onBeforeBuild) {
+      try {
+        hooks.onBeforeBuild(this)
+      } catch (err) {
+        log.warn(`onBeforeBuild hook threw: ${errorMessage(err)}`)
       }
-      settle(result, undefined)
-      return result
     }
+    const driver = originalBuild.apply(this, args) as SeleniumDriverLike
+    let onDriverCreatedPromise: Promise<unknown> | undefined
+    try {
+      const result = hooks.onDriverCreated(driver)
+      if (result && typeof (result as Promise<unknown>).then === 'function') {
+        // Capture so the `await new Builder().build()` thenable patch
+        // below can also wait on session setup (screencast / BiDi / metadata).
+        // Without this, the user's test body fires the moment waitForReady()
+        // resolves — which for the SECOND test is "immediately" because the
+        // dashboard UI is already connected — and races against an in-flight
+        // screencast.start(). Net effect: missing 2nd-test video.
+        const p = (result as Promise<unknown>).catch((err) => {
+          log.warn(`onDriverCreated hook rejected: ${errorMessage(err)}`)
+        })
+        onDriverCreatedPromise = p
+      }
+    } catch (err) {
+      log.warn(`onDriverCreated hook threw: ${errorMessage(err)}`)
+    }
+    extendDriverThenable(driver, hooks, onDriverCreatedPromise)
+    return driver
+  }
+  log.info('Patched Builder.prototype.build')
+}
 
-    wrapped.push(methodName)
+// Selenium 4: WebDriver is thenable. Extend `.then` so `await Builder.build()`
+// also waits for (a) the dashboard to connect AND (b) the in-flight session
+// setup from `onDriverCreated` (screencast + BiDi + metadata). Without (b),
+// the user's test body races against capture wiring on fast tests.
+// Selenium 3 may not be thenable — cast once.
+function extendDriverThenable(
+  driver: unknown,
+  hooks: DriverPatcherHooks,
+  onDriverCreatedPromise: Promise<unknown> | undefined
+): void {
+  const d = driver as Patchable
+  const isThenable = driver && typeof d.then === 'function'
+  if (!isThenable) {
+    return
+  }
+  if (!hooks.waitForReady && !onDriverCreatedPromise) {
+    return
+  }
+  const originalThen = (d.then as (...args: unknown[]) => unknown).bind(driver)
+  d.then = function patchedThen(
+    onFulfilled?: (value: unknown) => unknown,
+    onRejected?: (reason: unknown) => unknown
+  ) {
+    return originalThen(async (resolved: unknown) => {
+      // Wait for both UI readiness and session-setup completion in parallel.
+      // Either can fail — don't block forever on UI or capture issues.
+      const waiters: Promise<unknown>[] = []
+      if (hooks.waitForReady) {
+        waiters.push(hooks.waitForReady().catch(() => {}))
+      }
+      if (onDriverCreatedPromise) {
+        waiters.push(onDriverCreatedPromise.catch(() => {}))
+      }
+      await Promise.all(waiters)
+      return onFulfilled ? onFulfilled(resolved) : resolved
+    }, onRejected)
   }
-  return wrapped
 }
 
 export function patchSelenium(hooks: DriverPatcherHooks): boolean {
@@ -169,10 +361,7 @@ export function patchSelenium(hooks: DriverPatcherHooks): boolean {
     return false
   }
 
-  const Builder = sw.Builder
-  const WebDriver = sw.WebDriver
-  const WebElement = sw.WebElement
-
+  const { Builder, WebDriver, WebElement } = sw
   if (!Builder || !WebDriver) {
     log.warn(
       'selenium-webdriver loaded but Builder/WebDriver missing — version unsupported?'
@@ -181,24 +370,10 @@ export function patchSelenium(hooks: DriverPatcherHooks): boolean {
   }
 
   // Stash unwrapped originals before any patching.
-  const driverProto = WebDriver.prototype
-  if (typeof driverProto.takeScreenshot === 'function') {
-    const orig = driverProto.takeScreenshot
-    originals.takeScreenshot = (driver) => orig.call(driver)
-  }
-  if (typeof driverProto.executeScript === 'function') {
-    const orig = driverProto.executeScript
-    originals.executeScript = (driver, script, ...args) =>
-      orig.call(driver, script, ...args)
-  }
-  if (typeof driverProto.manage === 'function') {
-    const orig = driverProto.manage
-    originals.manage = (driver) => orig.call(driver)
-  }
+  stashDriverOriginals(WebDriver.prototype as Patchable)
 
-  const driverMethods = collectMethodNames(WebDriver.prototype)
-  const tracked = driverMethods.filter(
-    (m) => !INTERNAL_DRIVER_METHODS.includes(m as any)
+  const tracked = collectMethodNames(WebDriver.prototype).filter(
+    (m) => !(INTERNAL_DRIVER_METHODS as readonly string[]).includes(m)
   )
   const wrappedDriver = wrapPrototype(
     WebDriver.prototype,
@@ -208,90 +383,11 @@ export function patchSelenium(hooks: DriverPatcherHooks): boolean {
   )
   log.info(`Wrapped ${wrappedDriver.length} WebDriver method(s)`)
 
-  // Lets onBeforeQuit flush async cleanup before runners that `process.exit()`
-  // tear down (those bypass node's beforeExit).
-  if (typeof driverProto.quit === 'function') {
-    const originalQuit = driverProto.quit
-    driverProto.quit = async function patchedQuit(this: any) {
-      if (hooks.onBeforeQuit) {
-        try {
-          await hooks.onBeforeQuit(this)
-        } catch (err) {
-          log.warn(`onBeforeQuit hook threw: ${(err as Error).message}`)
-        }
-      }
-      return originalQuit.call(this)
-    }
-    log.info('Wrapped WebDriver.quit (cleanup hook)')
-  }
-
+  patchDriverQuit(WebDriver.prototype as Patchable, hooks)
   if (WebElement) {
-    const elProto = WebElement.prototype
-    if (typeof elProto.getText === 'function') {
-      const orig = elProto.getText
-      elementOriginals.getText = (el) => orig.call(el)
-    }
-    if (typeof elProto.getTagName === 'function') {
-      const orig = elProto.getTagName
-      elementOriginals.getTagName = (el) => orig.call(el)
-    }
-
-    const wrappedEl = wrapPrototype(
-      WebElement.prototype,
-      TRACKED_ELEMENT_METHODS,
-      /* fromElement */ true,
-      hooks
-    )
-    log.info(`Wrapped ${wrappedEl.length} WebElement method(s)`)
-  }
-
-  if (!(Builder.prototype as any)[PATCHED_SYMBOL]) {
-    ;(Builder.prototype as any)[PATCHED_SYMBOL] = true
-    const originalBuild = Builder.prototype.build
-    Builder.prototype.build = function patchedBuild(this: any, ...args: any[]) {
-      if (hooks.onBeforeBuild) {
-        try {
-          hooks.onBeforeBuild(this)
-        } catch (err) {
-          log.warn(`onBeforeBuild hook threw: ${(err as Error).message}`)
-        }
-      }
-      const driver = originalBuild.apply(this, args)
-      try {
-        const result = hooks.onDriverCreated(driver)
-        if (result && typeof (result as Promise<unknown>).then === 'function') {
-          ;(result as Promise<unknown>).catch((err) =>
-            log.warn(`onDriverCreated hook rejected: ${(err as Error).message}`)
-          )
-        }
-      } catch (err) {
-        log.warn(`onDriverCreated hook threw: ${(err as Error).message}`)
-      }
-
-      // Selenium 4: WebDriver is thenable. Extend `.then` so `await Builder.build()`
-      // also waits for the dashboard to connect.
-      const isThenable = driver && typeof (driver as any).then === 'function'
-      if (isThenable && hooks.waitForReady) {
-        const originalThen = (driver as any).then.bind(driver)
-        ;(driver as any).then = function patchedThen(
-          onFulfilled?: (value: any) => any,
-          onRejected?: (reason: any) => any
-        ) {
-          return originalThen(async (resolved: any) => {
-            try {
-              await hooks.waitForReady!()
-            } catch {
-              /* fall through — don't block forever on UI failures */
-            }
-            return onFulfilled ? onFulfilled(resolved) : resolved
-          }, onRejected)
-        }
-      }
-
-      return driver
-    }
-    log.info('Patched Builder.prototype.build')
+    patchWebElement(WebElement, hooks)
   }
+  patchBuilder(Builder, hooks)
 
   return true
 }
diff --git a/packages/selenium-devtools/src/helpers/captureOrReplaceCommand.ts b/packages/selenium-devtools/src/helpers/captureOrReplaceCommand.ts
new file mode 100644
index 00000000..39b35768
--- /dev/null
+++ b/packages/selenium-devtools/src/helpers/captureOrReplaceCommand.ts
@@ -0,0 +1,54 @@
+import { RetryTracker, toError } from '@wdio/devtools-core'
+import type { SessionCapturer } from '../session.js'
+import type { CapturedCommand, CommandLog, TestStats } from '../types.js'
+
+/**
+ * Capture (or replace, on a detected retry) a single CapturedCommand into the
+ * SessionCapturer's command log. Returns the resulting CommandLog entry with
+ * its internal `_id` so the caller can attach deferred async data (screenshots,
+ * trace results) and broadcast a replace later.
+ *
+ * Extracted from `SeleniumDevToolsPlugin.onCommand` — the retry-vs-fresh
+ * branching was the densest section of that 73-line method and is pure logic
+ * given a capturer + retry tracker + test handle.
+ */
+export async function captureOrReplaceCommand(opts: {
+  capturer: SessionCapturer
+  retryTracker: RetryTracker
+  test: TestStats
+  cmd: CapturedCommand
+}): Promise<CommandLog & { _id?: number }> {
+  const { capturer, retryTracker, test, cmd } = opts
+  const error = cmd.error ? toError(cmd.error) : undefined
+  const cmdSig = RetryTracker.signature(cmd.command, cmd.args, cmd.callSource)
+
+  if (retryTracker.isRetry(cmdSig)) {
+    const replaced = capturer.replaceCommand(
+      retryTracker.lastId!,
+      cmd.command,
+      cmd.args.map((a: unknown) => a),
+      error ? undefined : cmd.result,
+      error,
+      test.uid,
+      cmd.callSource,
+      cmd.timestamp
+    )
+    const entry = replaced.entry as CommandLog & { _id?: number }
+    retryTracker.setLastId(entry._id ?? null)
+    capturer.sendReplaceCommand(replaced.oldTimestamp, entry)
+    return entry
+  }
+
+  const entry = (await capturer.captureCommand(
+    cmd.command,
+    cmd.args,
+    cmd.result,
+    error,
+    test.uid,
+    cmd.callSource,
+    cmd.timestamp
+  )) as CommandLog & { _id?: number }
+  capturer.sendCommand(entry)
+  retryTracker.recordCapture(cmdSig, entry._id ?? null)
+  return entry
+}
diff --git a/packages/selenium-devtools/src/helpers/commandPostActions.ts b/packages/selenium-devtools/src/helpers/commandPostActions.ts
new file mode 100644
index 00000000..d90b9880
--- /dev/null
+++ b/packages/selenium-devtools/src/helpers/commandPostActions.ts
@@ -0,0 +1,217 @@
+import logger from '@wdio/logger'
+import {
+  CAPTURE_PERFORMANCE_SCRIPT,
+  applyPerformanceData,
+  errorMessage,
+  toError,
+  type CapturedPerformancePayload,
+  type RetryTracker
+} from '@wdio/devtools-core'
+import { getDriverOriginals, getElementOriginals } from '../driverPatcher.js'
+import { captureOrReplaceCommand } from './captureOrReplaceCommand.js'
+import type { SessionCapturer } from '../session.js'
+import type { TestManager } from './testManager.js'
+import type {
+  CapturedCommand,
+  CommandLog,
+  SeleniumDriverLike
+} from '../types.js'
+
+const log = logger('@wdio/selenium-devtools:commandPostActions')
+
+/**
+ * Helpers that run AFTER an `onCommand` capture/replace has fired. Kept out
+ * of the plugin class so the hot path stays readable and these are easier to
+ * test in isolation.
+ */
+
+/**
+ * For `findElement` / `findElements` commands, replace the opaque WebElement
+ * result with a "<tag>\"text\"" preview the UI can render. Uses the
+ * unwrapped element methods so the probes don't appear as phantom commands.
+ */
+export async function enrichFindResult(
+  capturer: SessionCapturer,
+  rawResult: unknown,
+  entry: CommandLog,
+  ts: number
+): Promise<void> {
+  const els = getElementOriginals()
+  const getTagName = els.getTagName
+  const getText = els.getText
+  if (!getTagName || !getText) {
+    return
+  }
+  try {
+    const elements = Array.isArray(rawResult) ? rawResult : [rawResult]
+    const previews = await Promise.all(
+      elements.slice(0, 5).map(async (el: unknown) => {
+        const tag = await getTagName(el).catch(() => 'element')
+        const text = await getText(el).catch(() => '')
+        const trimmed = text.length > 60 ? text.slice(0, 60) + '…' : text
+        return trimmed ? `<${tag}>"${trimmed}"` : `<${tag}>`
+      })
+    )
+    const more = elements.length > 5 ? `, +${elements.length - 5} more` : ''
+    const enriched = Array.isArray(rawResult)
+      ? `[${previews.join(', ')}${more}]`
+      : previews[0]
+    entry.result = enriched
+    capturer.sendReplaceCommand(ts, entry)
+  } catch {
+    // Element detached / stale — leave the original `<WebElement>` text.
+  }
+}
+
+/**
+ * On navigation commands, inject the page-side capture script (once per
+ * session), capture Performance API data onto the command entry, and pull
+ * the latest trace + browser logs. Fire-and-forget; errors are logged unless
+ * the session has already finalized (post-quit errors are expected and
+ * uninteresting).
+ *
+ * When `entry` is provided, the shared `CAPTURE_PERFORMANCE_SCRIPT` runs
+ * against the driver and attaches navigation / resources / cookies /
+ * documentInfo onto the entry — same shape nightwatch and service produce
+ * via `applyPerformanceData`.
+ */
+export function captureNavigationTrace(
+  capturer: SessionCapturer,
+  alreadyInjected: boolean,
+  onInjected: () => void,
+  isFinalized: () => boolean,
+  entry?: CommandLog,
+  args?: unknown[],
+  driver?: unknown
+): void {
+  void (async () => {
+    try {
+      if (!alreadyInjected) {
+        onInjected()
+        await capturer.injectScript()
+      }
+      if (entry && driver) {
+        await capturePerformance(capturer, driver, entry, args)
+      }
+      await capturer.captureTrace()
+      if (!capturer.bidiActive) {
+        await capturer.captureBrowserLogs()
+      }
+    } catch (err) {
+      if (!isFinalized()) {
+        log.warn(`Trace capture failed: ${errorMessage(err)}`)
+      }
+    }
+  })()
+}
+
+async function capturePerformance(
+  capturer: SessionCapturer,
+  driver: unknown,
+  entry: CommandLog,
+  args: unknown[] | undefined
+): Promise<void> {
+  const exec = getDriverOriginals().executeScript
+  if (!exec) {
+    return
+  }
+  try {
+    // Brief settle so navigation entries populate before we read them.
+    await new Promise((resolve) => setTimeout(resolve, 500))
+    const raw = (await exec(
+      driver as SeleniumDriverLike,
+      CAPTURE_PERFORMANCE_SCRIPT
+    )) as CapturedPerformancePayload | undefined
+    if (applyPerformanceData(entry, raw, args?.[0] as string | undefined)) {
+      capturer.sendReplaceCommand(entry.timestamp ?? Date.now(), entry)
+    }
+  } catch (err) {
+    const msg = errorMessage(err)
+    // Session torn down between the navigation command and the deferred
+    // perf-script execution — expected during teardown of the last test.
+    if (
+      msg.includes('ECONNREFUSED') ||
+      msg.includes('no such session') ||
+      msg.includes('invalid session id')
+    ) {
+      return
+    }
+    log.warn(`Performance capture failed: ${msg}`)
+  }
+}
+
+export interface OnCommandCtx {
+  readonly sessionCapturer: SessionCapturer | undefined
+  readonly testManager: TestManager | undefined
+  readonly retryTracker: RetryTracker
+  readonly options: { captureScreenshots: boolean }
+  readonly scriptInjected: boolean
+  readonly finalized: boolean
+  readonly driver: SeleniumDriverLike | undefined
+  setScriptInjected(v: boolean): void
+}
+
+function attachScreenshotAsync(
+  capturer: SessionCapturer,
+  entry: CommandLog
+): void {
+  const ts = entry.timestamp
+  capturer
+    .takeScreenshot()
+    .then((shot) => {
+      if (shot) {
+        entry.screenshot = shot
+        capturer.sendReplaceCommand(ts, entry)
+      }
+    })
+    .catch(() => {})
+}
+
+/**
+ * Plugin-side handler for a single command capture event. Pulled out of the
+ * plugin class so the hot path stays readable and the post-capture branches
+ * (screenshot, find-result enrichment, navigation trace) are easier to test.
+ */
+export async function handleOnCommand(
+  ctx: OnCommandCtx,
+  cmd: CapturedCommand
+): Promise<void> {
+  const capturer = ctx.sessionCapturer
+  const testManager = ctx.testManager
+  if (!capturer || !testManager) {
+    return
+  }
+  const test = testManager.getOrEnsureTest()
+  if (!test) {
+    return
+  }
+  const entry = await captureOrReplaceCommand({
+    capturer,
+    retryTracker: ctx.retryTracker,
+    test,
+    cmd
+  })
+  const error = cmd.error ? toError(cmd.error) : undefined
+  if (ctx.options.captureScreenshots && !error) {
+    attachScreenshotAsync(capturer, entry)
+  }
+  // Enrich opaque WebElement results with tag + text preview for the UI.
+  if (
+    !error &&
+    cmd.rawResult &&
+    (cmd.command === 'findElement' || cmd.command === 'findElements')
+  ) {
+    void enrichFindResult(capturer, cmd.rawResult, entry, entry.timestamp)
+  }
+  if (capturer.isNavigationCommand(cmd.command) && !cmd.fromElement) {
+    captureNavigationTrace(
+      capturer,
+      ctx.scriptInjected,
+      () => ctx.setScriptInjected(true),
+      () => ctx.finalized,
+      entry,
+      cmd.args,
+      ctx.driver
+    )
+  }
+}
diff --git a/packages/selenium-devtools/src/helpers/configSummary.ts b/packages/selenium-devtools/src/helpers/configSummary.ts
new file mode 100644
index 00000000..c942e406
--- /dev/null
+++ b/packages/selenium-devtools/src/helpers/configSummary.ts
@@ -0,0 +1,34 @@
+import logger from '@wdio/logger'
+import type { ScreencastOptions } from '../types.js'
+import type { RerunManager } from '../rerunManager.js'
+
+const log = logger('@wdio/selenium-devtools:configSummary')
+
+export interface ConfigSummaryInput {
+  openUi: boolean
+  headless: boolean
+  captureScreenshots: boolean
+  rerunCommand?: string
+  screencast: ScreencastOptions
+  rerunManager: RerunManager
+}
+
+/**
+ * Single-line summary of the plugin's effective config — useful when
+ * debugging a misconfigured env, gated so it runs at most once per process.
+ */
+export function logConfigSummary(input: ConfigSummaryInput): void {
+  const screencast = input.screencast.enabled
+    ? `${input.screencast.maxWidth}x${input.screencast.maxHeight}@q${input.screencast.quality}`
+    : 'off'
+  const rerun = input.rerunCommand
+    ? 'custom'
+    : input.rerunManager.rerunTemplate
+      ? 'auto'
+      : 'launch-only'
+  log.info(
+    `Configuration: openUi=${input.openUi}, headless=${input.headless}, ` +
+      `screencast=${screencast}, captureScreenshots=${input.captureScreenshots}, ` +
+      `rerun=${rerun}`
+  )
+}
diff --git a/packages/selenium-devtools/src/helpers/dashboardLauncher.ts b/packages/selenium-devtools/src/helpers/dashboardLauncher.ts
new file mode 100644
index 00000000..aa6b09d8
--- /dev/null
+++ b/packages/selenium-devtools/src/helpers/dashboardLauncher.ts
@@ -0,0 +1,92 @@
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+
+const log = logger('@wdio/selenium-devtools:dashboardLauncher')
+
+/**
+ * Spawn a detached Chrome window pointed at the DevTools UI. `open` would
+ * merge into an existing Chrome process and lose `--user-data-dir` isolation,
+ * so we invoke the binary directly via a double-fork — the intermediate Node
+ * process exits immediately and Chrome is reparented to launchd/init, so it
+ * survives tree-kill by the test runner (vitest's worker pool, jest
+ * --forceExit, mocha SIGINT). The unique user-data-dir is also used by
+ * gracefulShutdown's pkill to target only THIS run's window.
+ */
+export function openDashboard(host: string, port: number): boolean {
+  const url = `http://${host}:${port}`
+  const chromeBin = findChromeBinary()
+  if (!chromeBin) {
+    log.warn(`Chrome binary not found. Open manually: ${url}`)
+    return false
+  }
+
+  const userDataDir = path.join(
+    os.tmpdir(),
+    `selenium-devtools-ui-${port}-${Date.now()}`
+  )
+
+  log.info(`Chrome binary: ${chromeBin}`)
+  log.info(`💡 Opening DevTools UI: ${url}`)
+  const chromeArgs = [
+    `--user-data-dir=${userDataDir}`,
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--window-size=1600,1200',
+    '--new-window',
+    url
+  ]
+  try {
+    const code =
+      'require("child_process")' +
+      `.spawn(${JSON.stringify(chromeBin)}, ${JSON.stringify(chromeArgs)}, { detached: true, stdio: "ignore" }).unref()`
+    const intermediate = spawn(process.execPath, ['-e', code], {
+      detached: true,
+      stdio: 'ignore'
+    })
+    intermediate.unref()
+    intermediate.on('error', (err) => {
+      log.warn(
+        `Could not auto-open DevTools UI (${err.message}). Open manually: ${url}`
+      )
+    })
+    return true
+  } catch (err) {
+    log.warn(
+      `Could not auto-open DevTools UI (${errorMessage(err)}). Open manually: ${url}`
+    )
+    return false
+  }
+}
+
+function findChromeBinary(): string | null {
+  const candidates =
+    process.platform === 'darwin'
+      ? [
+          '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+          '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
+          '/Applications/Chromium.app/Contents/MacOS/Chromium',
+          `${os.homedir()}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`
+        ]
+      : process.platform === 'win32'
+        ? [
+            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+            `${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe`
+          ]
+        : [
+            '/usr/bin/google-chrome',
+            '/usr/bin/google-chrome-stable',
+            '/usr/bin/chromium-browser',
+            '/usr/bin/chromium'
+          ]
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) {
+      return c
+    }
+  }
+  return null
+}
diff --git a/packages/selenium-devtools/src/helpers/driverMetadata.ts b/packages/selenium-devtools/src/helpers/driverMetadata.ts
new file mode 100644
index 00000000..9b9367e0
--- /dev/null
+++ b/packages/selenium-devtools/src/helpers/driverMetadata.ts
@@ -0,0 +1,117 @@
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+import { TraceType } from '@wdio/devtools-shared'
+import type { SeleniumDriverLike } from '../types.js'
+
+const log = logger('@wdio/selenium-devtools:driverMetadata')
+
+export interface DriverMetadataInput {
+  driver: SeleniumDriverLike
+  driverReadyTs: number
+  runner: string | null
+  rerunCommand?: string
+  rerunTemplate?: string
+  launchCommand?: string
+}
+
+export interface DriverMetadataResult {
+  sessionId: string | undefined
+  /** Upstream `metadata` payload to forward to the dashboard. */
+  metadata: Record<string, unknown> | undefined
+}
+
+type CapGet = (k: string) => unknown
+
+function makeCapGet(capabilities: unknown): CapGet {
+  return (k: string) => {
+    const caps = capabilities as
+      | {
+          get?: (k: string) => unknown
+          serialize?: () => Record<string, unknown>
+        }
+      | undefined
+    if (caps?.get && typeof caps.get === 'function') {
+      return caps.get(k)
+    }
+    const serialized =
+      caps?.serialize?.() ?? (caps as Record<string, unknown>) ?? {}
+    return serialized[k]
+  }
+}
+
+function logBrowserBoot(
+  capGet: CapGet,
+  sessionId: string | undefined,
+  driverReadyTs: number
+): void {
+  const browserName = capGet('browserName') ?? 'unknown'
+  const browserVersion = capGet('browserVersion') ?? capGet('version') ?? ''
+  const platform = capGet('platformName') ?? capGet('platform') ?? ''
+  log.info(
+    `🌐 Browser: ${browserName}${browserVersion ? ' ' + browserVersion : ''}${platform ? ' on ' + platform : ''} (sessionId: ${sessionId ?? 'unknown'})`
+  )
+  const webSocketUrl = capGet('webSocketUrl')
+  const chromeOpts =
+    (capGet('goog:chromeOptions') as { args?: unknown } | undefined) ?? {}
+  const chromeArgs: string[] = Array.isArray(chromeOpts.args)
+    ? (chromeOpts.args as string[])
+    : []
+  const headlessArg = chromeArgs.find((a) => a.startsWith('--headless'))
+  log.info(
+    `📋 Capabilities sent: browserName=${browserName}, webSocketUrl=${webSocketUrl ? 'on' : 'off'}` +
+      (headlessArg ? `, ${headlessArg}` : '') +
+      (chromeArgs.length ? `, chromeArgs=${chromeArgs.length}` : '')
+  )
+  log.info(`Driver session created in ${Date.now() - driverReadyTs}ms`)
+}
+
+/**
+ * Extract session id + a fully-built upstream-metadata payload from a freshly
+ * created Selenium driver. Logs the standard `Browser:`/`Capabilities sent:`/
+ * `Driver session created in ...` lines as a side effect (these are part of
+ * the visible boot sequence; suppressing them would surprise users). Returns
+ * `metadata: undefined` if the driver couldn't be queried.
+ */
+export async function buildDriverMetadata(
+  input: DriverMetadataInput
+): Promise<DriverMetadataResult> {
+  const { driver, driverReadyTs, runner } = input
+  try {
+    const session = driver.getSession ? await driver.getSession() : undefined
+    const capabilities = driver.getCapabilities
+      ? await driver.getCapabilities()
+      : undefined
+    const sessionId = session?.getId?.() ?? undefined
+    const capGet = makeCapGet(capabilities)
+    logBrowserBoot(capGet, sessionId, driverReadyTs)
+    return {
+      sessionId,
+      metadata: {
+        type: TraceType.Testrunner,
+        capabilities:
+          (
+            capabilities as { serialize?: () => unknown } | undefined
+          )?.serialize?.() ??
+          capabilities ??
+          {},
+        sessionId,
+        options: {
+          framework: 'selenium-webdriver',
+          baseDir: process.cwd(),
+          rerunCommand: input.rerunCommand ?? input.rerunTemplate,
+          launchCommand: input.launchCommand,
+          // Cucumber `--name` filters scenarios but not Gherkin steps, so
+          // leaf-step rerun stays disabled there.
+          runCapabilities: {
+            canRunSuites: true,
+            canRunTests: runner !== 'cucumber',
+            canRunAll: true
+          }
+        }
+      }
+    }
+  } catch (err) {
+    log.warn(`Failed to send metadata: ${errorMessage(err)}`)
+    return { sessionId: undefined, metadata: undefined }
+  }
+}
diff --git a/packages/selenium-devtools/src/helpers/processHooks.ts b/packages/selenium-devtools/src/helpers/processHooks.ts
new file mode 100644
index 00000000..7226d170
--- /dev/null
+++ b/packages/selenium-devtools/src/helpers/processHooks.ts
@@ -0,0 +1,72 @@
+import { spawn } from 'node:child_process'
+
+/**
+ * Minimal shape the process hooks need from the selenium plugin. Keeps this
+ * helper from importing the plugin class (which would create a cycle).
+ */
+export interface ProcessHookPlugin {
+  isReuse: boolean
+  options: { port: number }
+  sessionCapturer?: { closeWebSocket: () => Promise<void>; cleanup: () => void }
+  clearKeepAlive: () => void
+  onSessionEnd: () => Promise<void>
+}
+
+/**
+ * Close the worker WS, restore captures, pkill the detached Chrome dashboard
+ * (skip in reuse mode — only the parent owns it), and `process.exit(code)`.
+ * Exported so the plugin can also call this when the dashboard disconnects
+ * post-tests (see `setClientDisconnectedHandler`).
+ */
+export async function gracefulShutdown(
+  plugin: ProcessHookPlugin,
+  code: number
+): Promise<void> {
+  try {
+    plugin.clearKeepAlive()
+    await plugin.sessionCapturer?.closeWebSocket()
+    plugin.sessionCapturer?.cleanup()
+    if (!plugin.isReuse) {
+      try {
+        spawn(
+          '/usr/bin/pkill',
+          ['-f', `selenium-devtools-ui-${plugin.options.port}-`],
+          { stdio: 'ignore' }
+        )
+      } catch {
+        /* pkill missing — accept stale Chrome */
+      }
+    }
+  } catch {
+    /* best-effort */
+  }
+  process.exit(code)
+}
+
+/**
+ * Wire up process-lifetime hooks for the selenium plugin:
+ *  - `exit`/`beforeExit`: trigger idempotent session end + (on beforeExit)
+ *    close the worker WS so the event loop can drain.
+ *  - `SIGINT`/`SIGTERM`: graceful shutdown — close WS, cleanup capture, and
+ *    in non-reuse mode pkill the detached Chrome dashboard for THIS run.
+ */
+export function registerProcessHooks(plugin: ProcessHookPlugin): void {
+  process.on('exit', () => {
+    void plugin.onSessionEnd()
+  })
+  process.on('beforeExit', () => {
+    // onSessionEnd is idempotent — re-firing it after per-scenario quit is a
+    // no-op. The real work here is the deferred WS close (see onSessionEnd
+    // non-interactive branch). closeWebSocket() returns immediately if
+    // already closed, so this is safe for both reuse mode and the dashboard
+    // path.
+    void plugin.onSessionEnd()
+    void plugin.sessionCapturer?.closeWebSocket()
+  })
+  process.on('SIGINT', () => {
+    void gracefulShutdown(plugin, 130)
+  })
+  process.on('SIGTERM', () => {
+    void gracefulShutdown(plugin, 143)
+  })
+}
diff --git a/packages/selenium-devtools/src/helpers/suiteManager.ts b/packages/selenium-devtools/src/helpers/suiteManager.ts
index 54277ec0..892b827a 100644
--- a/packages/selenium-devtools/src/helpers/suiteManager.ts
+++ b/packages/selenium-devtools/src/helpers/suiteManager.ts
@@ -1,4 +1,9 @@
-import { DEFAULTS, TEST_STATE } from '../constants.js'
+import {
+  computeSuiteFinalStatePermissive,
+  createSuiteStats,
+  stampSuiteEnd
+} from '@wdio/devtools-core'
+import { DEFAULTS } from '../constants.js'
 import type { SuiteStats, TestStats } from '../types.js'
 import type { TestReporter } from '../reporter.js'
 import { generateStableUid } from './utils.js'
@@ -17,21 +22,12 @@ export class SuiteManager {
       return this.rootSuite
     }
 
-    const suite: SuiteStats = {
+    const suite = createSuiteStats({
       uid: generateStableUid(file, title),
       cid: DEFAULTS.CID,
       title,
-      fullTitle: title,
-      file,
-      type: 'suite',
-      start: new Date(),
-      state: TEST_STATE.RUNNING,
-      end: null,
-      tests: [],
-      suites: [],
-      hooks: [],
-      _duration: DEFAULTS.DURATION
-    }
+      file
+    })
 
     this.rootSuite = suite
     this.currentParent = suite
@@ -52,30 +48,23 @@ export class SuiteManager {
   startScenarioSuite(
     name: string,
     file: string,
-    callSource?: string
+    callSource?: string,
+    featureFile?: string
   ): SuiteStats | null {
     if (!this.rootSuite) {
       return null
     }
-    const sub: SuiteStats = {
+    const sub = createSuiteStats({
       uid: generateStableUid(file, `${this.rootSuite.uid}::${name}`),
       cid: DEFAULTS.CID,
       title: name,
-      fullTitle: name,
       file,
-      type: 'suite',
-      start: new Date(),
-      state: TEST_STATE.RUNNING,
-      end: null,
-      tests: [],
-      suites: [],
-      hooks: [],
-      _duration: DEFAULTS.DURATION,
       callSource,
+      featureFile,
       // Without `parent`, the dashboard's `!suite.parent` filter renders this
       // sub-suite at the root too, duplicating it next to the feature.
       parent: this.rootSuite.uid
-    }
+    })
     this.rootSuite.suites = this.rootSuite.suites ?? []
     this.rootSuite.suites.push(sub)
     this.currentParent = sub
@@ -88,9 +77,7 @@ export class SuiteManager {
     if (!cur || cur === this.rootSuite || cur.end) {
       return
     }
-    cur.end = new Date()
-    cur._duration =
-      cur.end.getTime() - (cur.start?.getTime() || cur.end.getTime())
+    stampSuiteEnd(cur)
     cur.state = state
     this.testReporter.onSuiteEnd(cur)
     this.currentParent = this.rootSuite
@@ -128,19 +115,8 @@ export class SuiteManager {
     if (!this.rootSuite || this.rootSuite.end) {
       return
     }
-    this.rootSuite.end = new Date()
-    this.rootSuite._duration =
-      this.rootSuite.end.getTime() -
-      (this.rootSuite.start?.getTime() || this.rootSuite.end.getTime())
-
-    const failedDirect = this.rootSuite.tests.some(
-      (t) => typeof t !== 'string' && t.state === TEST_STATE.FAILED
-    )
-    const failedNested = (this.rootSuite.suites ?? []).some(
-      (s) => s.state === TEST_STATE.FAILED
-    )
-    this.rootSuite.state =
-      failedDirect || failedNested ? TEST_STATE.FAILED : TEST_STATE.PASSED
+    stampSuiteEnd(this.rootSuite)
+    this.rootSuite.state = computeSuiteFinalStatePermissive(this.rootSuite)
     this.testReporter.onSuiteEnd(this.rootSuite)
   }
 
diff --git a/packages/selenium-devtools/src/helpers/testManager.ts b/packages/selenium-devtools/src/helpers/testManager.ts
index 2cc0ee47..fc3bfebf 100644
--- a/packages/selenium-devtools/src/helpers/testManager.ts
+++ b/packages/selenium-devtools/src/helpers/testManager.ts
@@ -1,4 +1,5 @@
 import logger from '@wdio/logger'
+import { createTestStats, stampTestEnd } from '@wdio/devtools-core'
 import { DEFAULTS, TEST_STATE } from '../constants.js'
 import type { SuiteStats, TestStats } from '../types.js'
 import type { TestReporter } from '../reporter.js'
@@ -60,21 +61,13 @@ export class TestManager {
 
     log.info('Creating synthetic session test (no startTest called yet)')
     const title = DEFAULTS.SESSION_TITLE
-    const test: TestStats = {
+    const test = createTestStats({
       uid: deterministicUid(this.suite.file, `session:${this.suite.uid}`),
       cid: DEFAULTS.CID,
       title,
-      fullTitle: title,
-      parent: this.suite.uid,
-      state: TEST_STATE.RUNNING,
-      start: new Date(),
-      end: null,
-      type: 'test',
       file: this.suite.file,
-      retries: DEFAULTS.RETRIES,
-      _duration: DEFAULTS.DURATION,
-      hooks: []
-    }
+      parent: this.suite.uid
+    })
     this.suite.tests.push(test)
     this.#currentTest = test
     this.testReporter.onTestStart(test)
@@ -120,24 +113,16 @@ export class TestManager {
 
     this.#mode = 'marked'
     const file = opts.file || this.suite.file
-    const test: TestStats = {
-      // Scope by parent so two suites with the same test/step name don't
-      // collide on signatureCounter disambiguation across rerun processes.
+    // Scope by parent so two suites with the same test/step name don't
+    // collide on signatureCounter disambiguation across rerun processes.
+    const test = createTestStats({
       uid: generateStableUid(file, `${this.suite.uid}::${name}`),
       cid: DEFAULTS.CID,
       title: name,
-      fullTitle: name,
-      parent: this.suite.uid,
-      state: TEST_STATE.RUNNING,
-      start: new Date(),
-      end: null,
-      type: 'test',
       file,
-      retries: DEFAULTS.RETRIES,
-      _duration: DEFAULTS.DURATION,
-      hooks: [],
+      parent: this.suite.uid,
       callSource: opts.callSource
-    }
+    })
     log.info(
       `Started marked test "${name}" (callSource: ${opts.callSource || 'n/a'})`
     )
@@ -154,8 +139,7 @@ export class TestManager {
       return
     }
     test.state = state
-    test.end = new Date()
-    test._duration = test.end.getTime() - (test.start?.getTime() ?? Date.now())
+    stampTestEnd(test)
     this.testReporter.onTestEnd(test)
     this.#currentTest = null
   }
diff --git a/packages/selenium-devtools/src/helpers/utils.ts b/packages/selenium-devtools/src/helpers/utils.ts
index 89b8dbf9..88d0961b 100644
--- a/packages/selenium-devtools/src/helpers/utils.ts
+++ b/packages/selenium-devtools/src/helpers/utils.ts
@@ -1,172 +1,27 @@
-import * as net from 'node:net'
-import { parse as parseStackTrace } from 'stacktrace-parser'
-import logger from '@wdio/logger'
-import { ANSI_REGEX, LOG_LEVEL_PATTERNS, LOG_SOURCES } from '../constants.js'
-import type { ConsoleLog, LogLevel } from '../types.js'
+// Console helpers come from @wdio/devtools-core. `stripAnsiCodes` is the
+// local name kept for backwards compatibility with existing import sites.
+export {
+  stripAnsi as stripAnsiCodes,
+  detectLogLevel,
+  createConsoleLogEntry
+} from '@wdio/devtools-core'
 
-const log = logger('@wdio/selenium-devtools:utils')
+export { chromeLogLevelToLogLevel } from '@wdio/devtools-core'
 
-export const stripAnsiCodes = (text: string): string =>
-  text.replace(ANSI_REGEX, '')
+export {
+  generateStableUid,
+  deterministicUid,
+  resetSignatureCounters
+} from '@wdio/devtools-core'
 
-export function detectLogLevel(text: string): LogLevel {
-  const normalised = stripAnsiCodes(text).toLowerCase()
-  for (const { level, pattern } of LOG_LEVEL_PATTERNS) {
-    if (pattern.test(normalised)) {
-      return level
-    }
-  }
-  return 'log'
-}
-
-export function createConsoleLogEntry(
-  type: LogLevel,
-  args: any[],
-  source: string = LOG_SOURCES.TEST
-): ConsoleLog {
-  return { timestamp: Date.now(), type, args, source }
-}
-
-export function chromeLogLevelToLogLevel(
-  level: string | { value?: number; name?: string }
-): LogLevel {
-  const levelName = (
-    typeof level === 'object' ? (level?.name ?? '') : (level ?? '')
-  ).toUpperCase()
-  switch (levelName) {
-    case 'SEVERE':
-      return 'error'
-    case 'WARNING':
-      return 'warn'
-    case 'INFO':
-      return 'info'
-    case 'DEBUG':
-      return 'debug'
-    default:
-      return 'log'
-  }
-}
-
-const signatureCounters = new Map<string, number>()
-
-export function generateStableUid(file: string, name: string): string {
-  const signature = `${file}::${name}`
-  const count = signatureCounters.get(signature) || 0
-  signatureCounters.set(signature, count + 1)
-  const hashInput = count > 0 ? `${signature}::${count}` : signature
-  const hash = hashInput
-    .split('')
-    .reduce((acc, char) => ((acc << 5) - acc + char.charCodeAt(0)) | 0, 0)
-  return `stable-${Math.abs(hash).toString(36)}`
-}
-
-export function deterministicUid(...parts: string[]): string {
-  const hash = parts
-    .join('::')
-    .split('')
-    .reduce((acc, char) => ((acc << 5) - acc + char.charCodeAt(0)) | 0, 0)
-  return `stable-${Math.abs(hash).toString(36)}`
-}
-
-export function resetSignatureCounters() {
-  signatureCounters.clear()
-}
-
-function isUserCodeFrame(frame: {
-  file?: string | null
-}): frame is { file: string } {
-  const { file } = frame
-  return !!(
-    file &&
-    !file.includes('/node_modules/') &&
-    !file.includes('<anonymous>') &&
-    !file.includes('node:internal') &&
-    !file.includes('/dist/') &&
-    !file.endsWith('/index.js')
-  )
-}
-
-function normalizeFilePath(filePath: string): string {
-  // Node's stack traces in ESM use file:// URLs, which URL-encode spaces and
-  // other characters. Strip the prefix, drop the line:col suffix, and decode
-  // — otherwise `fs.readFile` hits ENOENT on any path containing a space.
-  const stripped = filePath.replace(/^file:\/\//, '').split(':')[0]
-  try {
-    return decodeURIComponent(stripped)
-  } catch {
-    // Malformed percent-encoding — keep the literal path rather than throw.
-    return stripped
-  }
-}
-
-export function getCallSourceFromStack(): {
-  filePath: string | undefined
-  callSource: string
-} {
-  const stack = new Error().stack
-  if (!stack) {
-    return { filePath: undefined, callSource: 'unknown:0' }
-  }
-
-  const frame = parseStackTrace(stack).find(isUserCodeFrame)
-  if (!frame?.file) {
-    return { filePath: undefined, callSource: 'unknown:0' }
-  }
-
-  const filePath = normalizeFilePath(frame.file)
-  return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` }
-}
+export { getCallSourceFromStack } from '@wdio/devtools-core'
 
 // Source-scan for `it/test/specify('title', ...)` (or `describe/context/suite`
 // when kind='suite'). Stack-walking from inside the runner's beforeEach
 // hooks doesn't reach the user's test body.
-import * as fs from 'node:fs'
+export { findTestLineInFile } from '@wdio/devtools-core'
 
-export function findTestLineInFile(
-  filePath: string,
-  title: string,
-  kind: 'test' | 'suite' = 'test'
-): number | null {
-  try {
-    if (!fs.existsSync(filePath)) {
-      return null
-    }
-    const lines = fs.readFileSync(filePath, 'utf-8').split('\n')
-    const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-    const keywords =
-      kind === 'suite' ? 'describe|context|suite' : 'it|test|specify'
-    const re = new RegExp(`\\b(?:${keywords})\\s*\\(\\s*['"\`]${escaped}['"\`]`)
-    for (let i = 0; i < lines.length; i++) {
-      if (re.test(lines[i])) {
-        return i + 1
-      }
-    }
-  } catch {
-    /* ignore — fall back to file:0 */
-  }
-  return null
-}
-
-export function isPortInUse(port: number, hostname: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const server = net.createServer()
-    server.once('error', () => resolve(true))
-    server.once('listening', () => server.close(() => resolve(false)))
-    server.listen(port, hostname)
-  })
-}
-
-export async function findFreePort(
-  startPort: number,
-  hostname: string
-): Promise<number> {
-  let port = startPort
-  while (await isPortInUse(port, hostname)) {
-    log.warn(`Port ${port} is in use, trying ${port + 1}...`)
-    port++
-  }
-  return port
-}
+export { isPortInUse, findFreePort } from '@wdio/devtools-core'
 
 /**
  * Capture the command line that launched the current process so the UI's
@@ -174,47 +29,7 @@ export async function findFreePort(
  * argv when npm script context is unavailable.
  */
 /** Derive a human-readable request type from URL and MIME type. */
-export function getRequestType(url: string, mimeType?: string): string {
-  const contentType = mimeType?.toLowerCase() ?? ''
-  const urlLower = url.toLowerCase()
-  if (contentType.includes('text/html')) {
-    return 'document'
-  }
-  if (contentType.includes('text/css')) {
-    return 'stylesheet'
-  }
-  if (
-    contentType.includes('javascript') ||
-    contentType.includes('ecmascript')
-  ) {
-    return 'script'
-  }
-  if (contentType.includes('image/')) {
-    return 'image'
-  }
-  if (contentType.includes('font/') || contentType.includes('woff')) {
-    return 'font'
-  }
-  if (contentType.includes('application/json')) {
-    return 'fetch'
-  }
-  if (urlLower.endsWith('.html') || urlLower.endsWith('.htm')) {
-    return 'document'
-  }
-  if (urlLower.endsWith('.css')) {
-    return 'stylesheet'
-  }
-  if (urlLower.endsWith('.js') || urlLower.endsWith('.mjs')) {
-    return 'script'
-  }
-  if (/\.(png|jpg|jpeg|gif|svg|webp|ico)$/.test(urlLower)) {
-    return 'image'
-  }
-  if (/\.(woff|woff2|ttf|eot|otf)$/.test(urlLower)) {
-    return 'font'
-  }
-  return 'xhr'
-}
+export { getRequestType } from '@wdio/devtools-core'
 
 export function captureLaunchCommand(): string {
   const npmScript = process.env.npm_lifecycle_event
diff --git a/packages/selenium-devtools/src/helpers/videoEncoder.ts b/packages/selenium-devtools/src/helpers/videoEncoder.ts
deleted file mode 100644
index ef662bf0..00000000
--- a/packages/selenium-devtools/src/helpers/videoEncoder.ts
+++ /dev/null
@@ -1,123 +0,0 @@
-// VP8/WebM encoder for screencast frames.
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import os from 'node:os'
-import { createRequire } from 'node:module'
-
-import logger from '@wdio/logger'
-
-import type { ScreencastFrame, ScreencastOptions } from '../types.js'
-
-const require = createRequire(import.meta.url)
-const log = logger('@wdio/selenium-devtools:VideoEncoder')
-
-export async function encodeToVideo(
-  frames: ScreencastFrame[],
-  outputPath: string,
-  options: Pick<ScreencastOptions, 'captureFormat'> = {}
-): Promise<void> {
-  if (frames.length === 0) {
-    throw new Error('VideoEncoder: no frames to encode')
-  }
-
-  const span = frames[frames.length - 1].timestamp - frames[0].timestamp
-  const totalBytes = frames.reduce(
-    (sum, f) => sum + Math.floor((f.data?.length ?? 0) * 0.75),
-    0
-  )
-  log.info(
-    `🎬 Encoding ${frames.length} frame(s), captured over ${(span / 1000).toFixed(1)}s ` +
-      `(~${(totalBytes / 1024 / 1024).toFixed(1)} MB raw)`
-  )
-
-  let ffmpeg: any
-  try {
-    ffmpeg = require('fluent-ffmpeg')
-  } catch {
-    throw new Error(
-      'VideoEncoder: fluent-ffmpeg is required for screencast encoding. ' +
-        'Install it with: npm install fluent-ffmpeg'
-    )
-  }
-
-  const ext = options.captureFormat === 'png' ? 'png' : 'jpg'
-  const tmpDir = await fs.mkdtemp(
-    path.join(os.tmpdir(), 'selenium-devtools-screencast-')
-  )
-
-  try {
-    const manifestLines: string[] = ['ffconcat version 1.0']
-
-    for (let i = 0; i < frames.length; i++) {
-      const frameName = `frame-${String(i).padStart(6, '0')}.${ext}`
-      const framePath = path.join(tmpDir, frameName)
-      await fs.writeFile(framePath, Buffer.from(frames[i].data, 'base64'))
-      const nextTs = frames[i + 1]?.timestamp ?? frames[i].timestamp + 100
-      const durationSecs = Math.max((nextTs - frames[i].timestamp) / 1000, 0.01)
-      manifestLines.push(`file '${framePath}'`)
-      manifestLines.push(`duration ${durationSecs.toFixed(6)}`)
-    }
-
-    const lastFramePath = path.join(
-      tmpDir,
-      `frame-${String(frames.length - 1).padStart(6, '0')}.${ext}`
-    )
-    manifestLines.push(`file '${lastFramePath}'`)
-
-    const manifestPath = path.join(tmpDir, 'manifest.txt')
-    await fs.writeFile(manifestPath, manifestLines.join('\n'))
-
-    log.info(`encoding ${frames.length} frames → ${outputPath}`)
-
-    await new Promise<void>((resolve, reject) => {
-      ffmpeg()
-        .input(manifestPath)
-        .inputOptions(['-f', 'concat', '-safe', '0'])
-        .videoCodec('libvpx')
-        .outputOptions([
-          '-b:v',
-          '1M',
-          '-pix_fmt',
-          'yuv420p',
-          // CFR @ 10fps — VFR WebMs don't write Cues reliably, so the
-          // dashboard's <video> can't read duration/seek.
-          '-vsync',
-          'cfr',
-          '-r',
-          '10',
-          '-auto-alt-ref',
-          '0',
-          '-disposition:v',
-          'default'
-        ])
-        .output(outputPath)
-        .on('end', () => resolve())
-        .on('error', (err: Error) => {
-          const msg = err.message || ''
-          if (
-            msg.includes('Cannot find ffmpeg') ||
-            msg.includes('ENOENT') ||
-            msg.includes('spawn') ||
-            msg.includes('not found')
-          ) {
-            reject(
-              new Error(
-                'VideoEncoder: ffmpeg binary not found on PATH. ' +
-                  'Install ffmpeg: https://ffmpeg.org/download.html'
-              )
-            )
-          } else {
-            reject(new Error(`VideoEncoder: ffmpeg error — ${msg}`))
-          }
-        })
-        .run()
-    })
-
-    log.info(`✓ video saved: ${outputPath}`)
-  } finally {
-    await fs.rm(tmpDir, { recursive: true, force: true }).catch((rmErr) => {
-      log.warn(`failed to clean temp dir — ${rmErr.message}`)
-    })
-  }
-}
diff --git a/packages/selenium-devtools/src/index.ts b/packages/selenium-devtools/src/index.ts
index 03553a59..0e95b7de 100644
--- a/packages/selenium-devtools/src/index.ts
+++ b/packages/selenium-devtools/src/index.ts
@@ -3,46 +3,53 @@
 
 // MUST be the first import — see setupConsole.ts.
 import './setupConsole.js'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
-import { spawn } from 'node:child_process'
 import logger from '@wdio/logger'
 import { startDetachedBackend } from './helpers/detachedBackend.js'
-import { patchSelenium, getElementOriginals } from './driverPatcher.js'
-import {
-  ensureBidiCapability,
-  ensureHeadlessChrome,
-  attachBidiHandlers,
-  buildBidiSinks
-} from './bidi.js'
-import { SessionCapturer } from './session.js'
-import { TestReporter } from './reporter.js'
-import { SuiteManager } from './helpers/suiteManager.js'
-import { TestManager } from './helpers/testManager.js'
+import { openDashboard } from './helpers/dashboardLauncher.js'
+import { handleOnCommand } from './helpers/commandPostActions.js'
+import { logConfigSummary } from './helpers/configSummary.js'
+import { registerProcessHooks } from './helpers/processHooks.js'
+import { patchSelenium } from './driverPatcher.js'
+import { ensureBidiCapability, ensureHeadlessChrome } from './bidi.js'
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { TestManager } from './helpers/testManager.js'
 import { RerunManager } from './rerunManager.js'
-import { ScreencastRecorder } from './screencast.js'
-import { encodeToVideo } from './helpers/videoEncoder.js'
+import type { ScreencastRecorder } from './screencast.js'
+import {
+  onDriverCreated as sessionOnDriverCreated,
+  onDriverEnd as sessionOnDriverEnd,
+  onSessionEnd as sessionOnSessionEnd,
+  setPluginRef
+} from './session-lifecycle.js'
+import {
+  startTest as tmStartTest,
+  endTest as tmEndTest,
+  startScenario as tmStartScenario,
+  endScenario as tmEndScenario,
+  flushPendingTestActions as tmFlushPendingTestActions,
+  type StartTestMeta,
+  type StartScenarioMeta
+} from './test-management.js'
+import type { PluginInternals } from './plugin-internals.js'
 import {
   detectOwnVersion,
   detectRunner,
   detectSeleniumVersion
 } from './helpers/runtime.js'
-import { findFreePort, getCallSourceFromStack } from './helpers/utils.js'
+import { findFreePort } from './helpers/utils.js'
+import { RetryTracker, errorMessage } from '@wdio/devtools-core'
 import { tryRegisterRunnerHooks } from './runnerHooks.js'
 import { patchNodeAssert } from './assertPatcher.js'
 import {
-  DEFAULTS,
   REUSE_ENV,
   SCREENCAST_DEFAULTS,
-  TIMING,
   TEST_STATE,
   NAVIGATION_COMMANDS
 } from './constants.js'
 import {
-  TraceType,
   type CapturedCommand,
-  type CommandLog,
   type DevToolsOptions,
   type ScreencastOptions,
   type SeleniumDriverLike,
@@ -76,13 +83,12 @@ class SeleniumDevToolsPlugin {
   #scriptInjected = false
   #isReuse = false
   // Coalesce internal retries: same {command,args,src} replaces prior entry.
-  #lastCapturedSig: string | null = null
-  #lastCapturedId: number | null = null
+  #retryTracker = new RetryTracker()
   #screencast?: ScreencastRecorder
   #screencastOptions: ScreencastOptions
   #sessionId?: string
   #uiUrlOpened = false
-  #testFileDir?: string
+  #testFilePath?: string
   #keepAliveTimer?: ReturnType<typeof setInterval>
   #uiReadyPromise?: Promise<void>
   // First it() body fires before onDriverCreated's async setup completes —
@@ -124,32 +130,7 @@ class SeleniumDevToolsPlugin {
       ...SCREENCAST_DEFAULTS,
       ...(options.screencast ?? {})
     }
-    this.#detectReuseMode()
-  }
-
-  #configSummaryLogged = false
-
-  #logConfigSummary() {
-    if (this.#configSummaryLogged) {
-      return
-    }
-    this.#configSummaryLogged = true
-    const screencast = this.#screencastOptions.enabled
-      ? `${this.#screencastOptions.maxWidth}x${this.#screencastOptions.maxHeight}@q${this.#screencastOptions.quality}`
-      : 'off'
-    const rerun = this.#options.rerunCommand
-      ? 'custom'
-      : this.#rerunManager.rerunTemplate
-        ? 'auto'
-        : 'launch-only'
-    log.info(
-      `Configuration: openUi=${this.#options.openUi}, headless=${this.#options.headless}, ` +
-        `screencast=${screencast}, captureScreenshots=${this.#options.captureScreenshots}, ` +
-        `rerun=${rerun}`
-    )
-  }
-
-  #detectReuseMode() {
+    // Reuse mode: rerun child inherits the parent's backend host/port.
     if (
       process.env[REUSE_ENV.REUSE] === '1' &&
       process.env[REUSE_ENV.HOST] &&
@@ -164,6 +145,22 @@ class SeleniumDevToolsPlugin {
     }
   }
 
+  #configSummaryLogged = false
+  #logConfigSummary() {
+    if (this.#configSummaryLogged) {
+      return
+    }
+    this.#configSummaryLogged = true
+    logConfigSummary({
+      openUi: this.#options.openUi,
+      headless: this.#options.headless,
+      captureScreenshots: this.#options.captureScreenshots,
+      rerunCommand: this.#options.rerunCommand,
+      screencast: this.#screencastOptions,
+      rerunManager: this.#rerunManager
+    })
+  }
+
   async ensureBackendStarted(): Promise<void> {
     if (this.#backendStarted) {
       return
@@ -195,7 +192,7 @@ class SeleniumDevToolsPlugin {
           this.#openUiWindow()
         }
       } catch (err) {
-        log.error(`Failed to start backend: ${(err as Error).message}`)
+        log.error(`Failed to start backend: ${errorMessage(err)}`)
       }
     })()
     return this.#backendStartPromise
@@ -256,474 +253,156 @@ class SeleniumDevToolsPlugin {
     return this.#options
   }
 
-  /** Public API: start a marked test. */
-  startTest(
-    name: string,
-    meta: {
-      file?: string
-      callSource?: string
-      suiteName?: string
-      suiteCallSource?: string
-    } = {}
-  ) {
-    if (!this.#testFileDir && meta.file) {
-      this.#testFileDir = path.dirname(meta.file)
-    }
-    const stackInfo = getCallSourceFromStack()
-    const file = meta.file || stackInfo.filePath
-    const callSource = meta.callSource || stackInfo.callSource
-    const resolvedMeta: { file?: string; callSource?: string } = {}
-    if (file) {
-      resolvedMeta.file = file
-    }
-    if (callSource && callSource !== 'unknown:0') {
-      resolvedMeta.callSource = callSource
-    }
-    if (!this.#suiteManager || !this.#testReporter) {
-      this.#pendingTestActions.push({
-        kind: 'start',
-        name,
-        meta: resolvedMeta,
-        suiteName: meta.suiteName,
-        suiteCallSource: meta.suiteCallSource
-      })
-      return
-    }
-
-    this.#ensureSuiteAndTestManager(
-      meta.suiteName ?? DEFAULTS.SESSION_TITLE,
-      meta.suiteCallSource
-    )
-    if (meta.suiteName || meta.suiteCallSource) {
-      this.#suiteManager.setRootSuiteTitle(
-        meta.suiteName ?? '',
-        meta.suiteCallSource
-      )
-    }
+  // Single internals "bag" — structurally satisfies both lifecycle ctx
+  // interfaces. Lifecycle modules cast it to their narrow type at call time.
+  #internals: PluginInternals | undefined
+  // Declarative accessor map — splitting this purely to satisfy the
+  // line-count rule hurts readability; the body is mechanical wiring.
+  // eslint-disable-next-line max-lines-per-function
+  #getInternals(): PluginInternals {
+    if (this.#internals) {
+      return this.#internals
+    }
+    const self = this
+    this.#internals = {
+      get options() {
+        return self.#options
+      },
+      get screencastOptions() {
+        return self.#screencastOptions
+      },
+      get runner() {
+        return RUNNER
+      },
+      get rerunTemplate() {
+        return self.#rerunManager.rerunTemplate
+      },
+      get launchCommand() {
+        return self.#rerunManager.launchCommand
+      },
+      get isReuse() {
+        return self.#isReuse
+      },
+      get finalized() {
+        return self.#finalized
+      },
+      get retryTracker() {
+        return self.#retryTracker
+      },
+      get driver() {
+        return self.#driver
+      },
+      set driver(v) {
+        self.#driver = v
+      },
+      get sessionCapturer() {
+        return self.#sessionCapturer
+      },
+      set sessionCapturer(v) {
+        self.#sessionCapturer = v
+      },
+      get testReporter() {
+        return self.#testReporter
+      },
+      set testReporter(v) {
+        self.#testReporter = v
+      },
+      get suiteManager() {
+        return self.#suiteManager
+      },
+      set suiteManager(v) {
+        self.#suiteManager = v
+      },
+      get testManager() {
+        return self.#testManager
+      },
+      set testManager(v) {
+        self.#testManager = v
+      },
+      get screencast() {
+        return self.#screencast
+      },
+      set screencast(v) {
+        self.#screencast = v
+      },
+      get sessionId() {
+        return self.#sessionId
+      },
+      set sessionId(v) {
+        self.#sessionId = v
+      },
+      get scriptInjected() {
+        return self.#scriptInjected
+      },
+      set scriptInjected(v) {
+        self.#scriptInjected = v
+      },
+      get testFilePath() {
+        return self.#testFilePath
+      },
+      set testFilePath(v) {
+        self.#testFilePath = v
+      },
+      get keepAliveTimer() {
+        return self.#keepAliveTimer
+      },
+      set keepAliveTimer(v) {
+        self.#keepAliveTimer = v
+      },
+      get pendingTestActions() {
+        return self.#pendingTestActions
+      },
+      set pendingTestActions(v) {
+        self.#pendingTestActions = v
+      },
+      get pendingScenario() {
+        return self.#pendingScenario
+      },
+      set pendingScenario(v) {
+        self.#pendingScenario = v
+      },
+      setFinalized: (v) => {
+        self.#finalized = v
+      },
+      setScriptInjected: (v) => {
+        self.#scriptInjected = v
+      },
+      ensureBackendStarted: () => self.ensureBackendStarted(),
+      flushPendingTestActions: () => self.#flushPendingTestActions(),
+      resetRetryTracker: () => self.#retryTracker.reset(),
+      clearKeepAlive: () => self.clearKeepAlive()
+    }
+    setPluginRef(this.#internals, this)
+    return this.#internals
+  }
 
-    this.#testManager!.startMarkedTest(name, resolvedMeta)
-    this.#lastCapturedSig = null
-    this.#lastCapturedId = null
-    if (file) {
-      this.#sessionCapturer?.captureSource(file).catch(() => {})
-    }
+  /** Public API: start a marked test. */
+  startTest(name: string, meta: StartTestMeta = {}) {
+    tmStartTest(this.#getInternals(), name, meta)
   }
 
   endTest(state: TestStats['state'] = 'passed') {
-    if (!this.#testManager) {
-      this.#pendingTestActions.push({ kind: 'end', state })
-      return
-    }
-    this.#testManager.endCurrent(state)
+    tmEndTest(this.#getInternals(), state)
   }
 
-  /** Cucumber scenario boundary — opens a sub-suite under the feature root. */
-  startScenario(
-    name: string,
-    meta: {
-      file?: string
-      callSource?: string
-      featureName?: string
-      featureCallSource?: string
-    } = {}
-  ) {
-    if (!this.#suiteManager || !this.#testReporter) {
-      this.#pendingScenario = { name, ...meta }
-      return
-    }
-    this.#ensureSuiteAndTestManager(
-      meta.featureName ?? DEFAULTS.SESSION_TITLE,
-      meta.featureCallSource
-    )
-    if (meta.featureName || meta.featureCallSource) {
-      this.#suiteManager.setRootSuiteTitle(
-        meta.featureName ?? '',
-        meta.featureCallSource
-      )
-    }
-    const file =
-      meta.file ?? this.#suiteManager.getRootSuite()?.file ?? process.cwd()
-    this.#suiteManager.startScenarioSuite(name, file, meta.callSource)
-    this.#lastCapturedSig = null
-    this.#lastCapturedId = null
-    if (meta.file) {
-      this.#sessionCapturer?.captureSource(meta.file).catch(() => {})
-    }
+  startScenario(name: string, meta: StartScenarioMeta = {}) {
+    tmStartScenario(this.#getInternals(), name, meta)
   }
 
   endScenario(state: TestStats['state'] = 'passed') {
-    if (!this.#suiteManager) {
-      return
-    }
-    this.#testManager?.endCurrent(state)
-    this.#suiteManager.endScenarioSuite(state)
-    this.#lastCapturedSig = null
-    this.#lastCapturedId = null
+    tmEndScenario(this.#getInternals(), state)
   }
 
-  /** Lazy-create rootSuite + testManager so they take the real describe title. */
-  #ensureSuiteAndTestManager(title: string, callSource?: string): void {
-    if (!this.#suiteManager || !this.#testReporter) {
-      return
-    }
-    let rootSuite = this.#suiteManager.getRootSuite()
-    const created = !rootSuite
-    if (!rootSuite) {
-      const effectiveTitle = this.#pendingScenario?.featureName ?? title
-      rootSuite = this.#suiteManager.getOrCreateRootSuite(
-        process.cwd(),
-        effectiveTitle
-      )
-      const cs = this.#pendingScenario?.featureCallSource ?? callSource
-      if (cs) {
-        rootSuite.callSource = cs
-      }
-    }
-    if (!this.#testManager) {
-      this.#testManager = new TestManager(
-        rootSuite,
-        this.#testReporter,
-        this.#suiteManager
-      )
-    }
-    if (created && this.#pendingScenario) {
-      const p = this.#pendingScenario
-      this.#pendingScenario = null
-      const file = p.file ?? rootSuite.file
-      this.#suiteManager.startScenarioSuite(p.name, file, p.callSource)
-      if (p.file) {
-        this.#sessionCapturer?.captureSource(p.file).catch(() => {})
-      }
-    }
-  }
-
-  /** Apply any startTest/endTest calls buffered before testManager existed. */
   #flushPendingTestActions() {
-    if (this.#pendingTestActions.length === 0) {
-      return
-    }
-    for (const action of this.#pendingTestActions) {
-      if (action.kind === 'start') {
-        this.#ensureSuiteAndTestManager(
-          action.suiteName ?? DEFAULTS.SESSION_TITLE,
-          action.suiteCallSource
-        )
-        if (!this.#testManager) {
-          continue
-        }
-        if (action.suiteName || action.suiteCallSource) {
-          this.#suiteManager?.setRootSuiteTitle(
-            action.suiteName ?? '',
-            action.suiteCallSource
-          )
-        }
-        this.#testManager.startMarkedTest(action.name, action.meta)
-        if (action.meta.file) {
-          this.#sessionCapturer?.captureSource(action.meta.file).catch(() => {})
-        }
-      } else {
-        this.#testManager?.endCurrent(action.state)
-      }
-    }
-    this.#pendingTestActions = []
+    tmFlushPendingTestActions(this.#getInternals())
   }
 
   async onDriverCreated(driver: SeleniumDriverLike) {
-    const driverReadyTs = Date.now()
-    await this.ensureBackendStarted()
-
-    if (this.#driver === driver) {
-      return
-    }
-
-    // Fresh-driver-per-test: re-target capturer; reuse suite/reporter/testManager.
-    if (this.#driver || this.#sessionCapturer) {
-      log.info('New driver detected — re-targeting capturer for next test')
-      this.#driver = driver
-      this.#sessionCapturer?.setDriver(driver)
-      await this.#initPerDriverCapture(driver, driverReadyTs)
-      return
-    }
-
-    this.#driver = driver
-
-    this.#sessionCapturer = new SessionCapturer(
-      { hostname: this.#options.hostname, port: this.#options.port },
-      driver
-    )
-    // Dashboard closed AFTER tests finished → wind the runner down so the
-    // user doesn't have to Ctrl+C. Ignore during a live run: a momentary
-    // reconnect blip during tests must not abort them.
-    this.#sessionCapturer.setClientDisconnectedHandler(() => {
-      if (this.finalized) {
-        void gracefulShutdown(0)
-      }
-    })
-    await this.#sessionCapturer.waitForConnection(TIMING.UI_CONNECTION_WAIT)
-
-    this.#testReporter = new TestReporter((suitesData) => {
-      this.#sessionCapturer?.sendUpstream('suites', suitesData)
-    })
-    this.#suiteManager = new SuiteManager(this.#testReporter)
-    this.#flushPendingTestActions()
-
-    await this.#initPerDriverCapture(driver, driverReadyTs)
-  }
-
-  async #initPerDriverCapture(
-    driver: SeleniumDriverLike,
-    driverReadyTs: number
-  ) {
-    if (!this.#sessionCapturer) {
-      return
-    }
-
-    try {
-      const session = driver.getSession ? await driver.getSession() : undefined
-      const capabilities = driver.getCapabilities
-        ? await driver.getCapabilities()
-        : undefined
-      this.#sessionId = session?.getId?.() ?? undefined
-      const capGet = (k: string): any => {
-        if (capabilities?.get && typeof capabilities.get === 'function') {
-          return capabilities.get(k)
-        }
-        const serialized = capabilities?.serialize?.() ?? capabilities ?? {}
-        return serialized[k]
-      }
-      const browserName = capGet('browserName') ?? 'unknown'
-      const browserVersion = capGet('browserVersion') ?? capGet('version') ?? ''
-      const platform = capGet('platformName') ?? capGet('platform') ?? ''
-      log.info(
-        `🌐 Browser: ${browserName}${browserVersion ? ' ' + browserVersion : ''}${platform ? ' on ' + platform : ''} (sessionId: ${this.#sessionId ?? 'unknown'})`
-      )
-      const webSocketUrl = capGet('webSocketUrl')
-      const chromeOpts = capGet('goog:chromeOptions') ?? {}
-      const chromeArgs: string[] = Array.isArray(chromeOpts?.args)
-        ? chromeOpts.args
-        : []
-      const headlessArg = chromeArgs.find((a) => a.startsWith('--headless'))
-      log.info(
-        `📋 Capabilities sent: browserName=${browserName}, webSocketUrl=${webSocketUrl ? 'on' : 'off'}` +
-          (headlessArg ? `, ${headlessArg}` : '') +
-          (chromeArgs.length ? `, chromeArgs=${chromeArgs.length}` : '')
-      )
-      log.info(`Driver session created in ${Date.now() - driverReadyTs}ms`)
-      this.#sessionCapturer.sendUpstream('metadata', {
-        type: TraceType.Testrunner,
-        capabilities: capabilities?.serialize?.() ?? capabilities ?? {},
-        sessionId: this.#sessionId,
-        options: {
-          framework: 'selenium-webdriver',
-          baseDir: process.cwd(),
-          rerunCommand:
-            this.#options.rerunCommand ?? this.#rerunManager.rerunTemplate,
-          launchCommand: this.#rerunManager.launchCommand,
-          // Cucumber `--name` filters scenarios but not Gherkin steps, so
-          // leaf-step rerun stays disabled there.
-          runCapabilities: {
-            canRunSuites: true,
-            canRunTests: RUNNER !== 'cucumber',
-            canRunAll: true
-          }
-        }
-      })
-    } catch (err) {
-      log.warn(`Failed to send metadata: ${(err as Error).message}`)
-    }
-
-    // Parallel — serial attach misses frames on fast tests.
-    const screencastPromise = this.#screencastOptions.enabled
-      ? (async () => {
-          try {
-            this.#screencast = new ScreencastRecorder(this.#screencastOptions)
-            await this.#screencast.start(driver)
-          } catch (err) {
-            log.warn(`Screencast start failed: ${(err as Error).message}`)
-          }
-        })()
-      : Promise.resolve()
-
-    const bidiPromise = (async () => {
-      try {
-        const sinks = buildBidiSinks(this.#sessionCapturer!)
-        const ok = await attachBidiHandlers(driver, sinks)
-        if (ok) {
-          this.#sessionCapturer!.bidiActive = true
-          log.info(
-            '✓ BiDi data flow active — script-injected console/network suppressed'
-          )
-        }
-      } catch (err) {
-        log.warn(`BiDi attach threw: ${(err as Error).message}`)
-      }
-    })()
-
-    await Promise.all([screencastPromise, bidiPromise])
+    await sessionOnDriverCreated(this.#getInternals(), driver)
   }
 
   async onCommand(cmd: CapturedCommand) {
-    const capturer = this.#sessionCapturer
-    const testManager = this.#testManager
-    if (!capturer || !testManager) {
-      return
-    }
-
-    const test = testManager.getOrEnsureTest()
-    if (!test) {
-      return
-    }
-
-    const error =
-      cmd.error && cmd.error instanceof Error
-        ? cmd.error
-        : cmd.error
-          ? new Error(String(cmd.error))
-          : undefined
-
-    const cmdSig = JSON.stringify({
-      command: cmd.command,
-      args: cmd.args,
-      src: cmd.callSource ?? null
-    })
-    const isRetry =
-      this.#lastCapturedSig === cmdSig && this.#lastCapturedId !== null
-
-    let entry: CommandLog & { _id?: number }
-    if (isRetry) {
-      const replaced = capturer.replaceCommand(
-        this.#lastCapturedId!,
-        cmd.command,
-        cmd.args.map((a: any) => a),
-        error ? undefined : cmd.result,
-        error,
-        test.uid,
-        cmd.callSource,
-        cmd.timestamp
-      )
-      entry = replaced.entry as CommandLog & { _id?: number }
-      this.#lastCapturedId = entry._id ?? null
-      capturer.sendReplaceCommand(replaced.oldTimestamp, entry)
-    } else {
-      entry = (await capturer.captureCommand(
-        cmd.command,
-        cmd.args,
-        cmd.result,
-        error,
-        test.uid,
-        cmd.callSource,
-        cmd.timestamp
-      )) as CommandLog & { _id?: number }
-      capturer.sendCommand(entry)
-      this.#lastCapturedSig = cmdSig
-      this.#lastCapturedId = entry._id ?? null
-    }
-
-    if (this.#options.captureScreenshots && !error) {
-      const ts = entry.timestamp
-      capturer
-        .takeScreenshot()
-        .then((shot) => {
-          if (shot) {
-            entry.screenshot = shot
-            capturer.sendReplaceCommand(ts, entry)
-          }
-        })
-        .catch(() => {})
-    }
-
-    // Enrich opaque WebElement results with tag + text preview for the UI.
-    if (
-      !error &&
-      cmd.rawResult &&
-      (cmd.command === 'findElement' || cmd.command === 'findElements')
-    ) {
-      const ts = entry.timestamp
-      void this.#enrichFindResult(cmd.rawResult, entry, ts)
-    }
-
-    if (capturer.isNavigationCommand(cmd.command) && !cmd.fromElement) {
-      void (async () => {
-        try {
-          if (!this.#scriptInjected) {
-            this.#scriptInjected = true
-            await capturer.injectScript()
-          }
-          await capturer.captureTrace()
-          if (!capturer.bidiActive) {
-            await capturer.captureBrowserLogs()
-          }
-        } catch (err) {
-          if (!this.#finalized) {
-            log.warn(`Trace capture failed: ${(err as Error).message}`)
-          }
-        }
-      })()
-    }
-  }
-
-  async #enrichFindResult(rawResult: any, entry: any, ts: number) {
-    const capturer = this.#sessionCapturer
-    if (!capturer) {
-      return
-    }
-    // Unwrapped methods so these probes don't appear as phantom commands.
-    const els = getElementOriginals()
-    const getTagName = els.getTagName
-    const getText = els.getText
-    if (!getTagName || !getText) {
-      return
-    }
-    try {
-      const elements = Array.isArray(rawResult) ? rawResult : [rawResult]
-      const previews = await Promise.all(
-        elements.slice(0, 5).map(async (el: any) => {
-          const tag = await getTagName(el).catch(() => 'element')
-          const text = await getText(el).catch(() => '')
-          const trimmed = text.length > 60 ? text.slice(0, 60) + '…' : text
-          return trimmed ? `<${tag}>"${trimmed}"` : `<${tag}>`
-        })
-      )
-      const more = elements.length > 5 ? `, +${elements.length - 5} more` : ''
-      const enriched = Array.isArray(rawResult)
-        ? `[${previews.join(', ')}${more}]`
-        : previews[0]
-      entry.result = enriched
-      capturer.sendReplaceCommand(ts, entry)
-    } catch {
-      // Element detached / stale — leave the original `<WebElement>` text.
-    }
-  }
-
-  // `open` merges windows into an existing Chrome process and loses
-  // `--user-data-dir` isolation, so we spawn the binary directly.
-  #findChromeBinary(): string | null {
-    const candidates =
-      process.platform === 'darwin'
-        ? [
-            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-            '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
-            '/Applications/Chromium.app/Contents/MacOS/Chromium',
-            `${os.homedir()}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`
-          ]
-        : process.platform === 'win32'
-          ? [
-              'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
-              'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
-              `${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe`
-            ]
-          : [
-              '/usr/bin/google-chrome',
-              '/usr/bin/google-chrome-stable',
-              '/usr/bin/chromium-browser',
-              '/usr/bin/chromium'
-            ]
-    for (const c of candidates) {
-      if (c && fs.existsSync(c)) {
-        return c
-      }
-    }
-    return null
+    await handleOnCommand(this.#getInternals(), cmd)
   }
 
   #openUiWindow() {
@@ -731,52 +410,7 @@ class SeleniumDevToolsPlugin {
       return
     }
     this.#uiUrlOpened = true
-    const url = `http://${this.#options.hostname}:${this.#options.port}`
-
-    const chromeBin = this.#findChromeBinary()
-    if (!chromeBin) {
-      log.warn(`Chrome binary not found. Open manually: ${url}`)
-      return
-    }
-
-    const userDataDir = path.join(
-      os.tmpdir(),
-      `selenium-devtools-ui-${this.#options.port}-${Date.now()}`
-    )
-
-    log.info(`Chrome binary: ${chromeBin}`)
-    log.info(`💡 Opening DevTools UI: ${url}`)
-    const chromeArgs = [
-      `--user-data-dir=${userDataDir}`,
-      '--no-first-run',
-      '--no-default-browser-check',
-      '--window-size=1600,1200',
-      '--new-window',
-      url
-    ]
-    try {
-      // Double-fork: a short-lived Node intermediate spawns Chrome detached
-      // and exits, so Chrome is reparented to launchd/init and survives any
-      // tree-kill the test runner does on its descendants (vitest's pool,
-      // jest --forceExit, mocha SIGINT). Same path for every runner.
-      const code =
-        'require("child_process")' +
-        `.spawn(${JSON.stringify(chromeBin)}, ${JSON.stringify(chromeArgs)}, { detached: true, stdio: "ignore" }).unref()`
-      const intermediate = spawn(process.execPath, ['-e', code], {
-        detached: true,
-        stdio: 'ignore'
-      })
-      intermediate.unref()
-      intermediate.on('error', (err) => {
-        log.warn(
-          `Could not auto-open DevTools UI (${err.message}). Open manually: ${url}`
-        )
-      })
-    } catch (err) {
-      log.warn(
-        `Could not auto-open DevTools UI (${(err as Error).message}). Open manually: ${url}`
-      )
-    }
+    openDashboard(this.#options.hostname, this.#options.port)
   }
 
   #finalized = false
@@ -786,100 +420,47 @@ class SeleniumDevToolsPlugin {
 
   /** Per-driver cleanup; keeps capturer/suite/testManager/backend alive. */
   async onDriverEnd() {
-    if (this.#screencast) {
-      try {
-        await this.#screencast.stop()
-        const frames = this.#screencast.frames
-        if (frames.length > 0 && this.#sessionId) {
-          const fileName = `selenium-video-${this.#sessionId}.webm`
-          // Output dir priority: test-file dir → cwd → os.tmpdir().
-          const candidate = this.#testFileDir || process.cwd()
-          let videoPath = path.join(candidate, fileName)
-          try {
-            fs.accessSync(candidate, fs.constants.W_OK)
-          } catch {
-            videoPath = path.join(os.tmpdir(), fileName)
-          }
-          try {
-            await encodeToVideo(frames, videoPath, {
-              captureFormat: this.#screencastOptions.captureFormat
-            })
-            log.info(`📹 Screencast video: ${videoPath}`)
-            this.#sessionCapturer?.sendUpstream('screencast', {
-              sessionId: this.#sessionId,
-              videoPath,
-              videoFile: fileName,
-              frameCount: frames.length
-            })
-          } catch (err) {
-            log.warn(`Screencast encode failed: ${(err as Error).message}`)
-          }
-        }
-      } catch (err) {
-        log.warn(`Screencast stop failed: ${(err as Error).message}`)
-      }
-    }
-    this.#driver = undefined
-    this.#screencast = undefined
-    this.#scriptInjected = false
-    this.#sessionId = undefined
-    this.#lastCapturedSig = null
-    this.#lastCapturedId = null
+    await sessionOnDriverEnd(this.#getInternals())
   }
 
-  /** Final teardown. Idempotent. */
   async onSessionEnd() {
-    if (this.#finalized) {
-      return
-    }
-    this.#finalized = true
-    const shutdownStart = Date.now()
-    try {
-      await this.onDriverEnd().catch(() => {})
-
-      this.#testManager?.finalizeSession()
-      this.#suiteManager?.finalize()
-      this.#testReporter?.updateSuites()
-
-      const cmdCount = this.#sessionCapturer?.commandsLog.length ?? 0
-      const consoleCount = this.#sessionCapturer?.consoleLogs.length ?? 0
-      const networkCount = this.#sessionCapturer?.networkRequests.length ?? 0
-      log.info(
-        `📊 Session summary — ${cmdCount} command(s), ${networkCount} network request(s), ${consoleCount} console log(s)`
-      )
-      this.#sessionCapturer?.cleanup()
-      // Keep the worker WS open while the dashboard is up — it's the
-      // channel the backend uses to tell us "the user closed the
-      // dashboard, time to exit". gracefulShutdown closes it on real exit.
-      if (!this.#options.openUi || this.#isReuse) {
-        await this.#sessionCapturer?.closeWebSocket()
-      }
-
-      if (this.#options.openUi && !this.#isReuse) {
-        log.info(
-          `💡 Tests complete — DevTools UI: http://${this.#options.hostname}:${this.#options.port}`
-        )
-      }
-      log.info(`🛑 Shutdown complete (${Date.now() - shutdownStart}ms)`)
-    } catch (err) {
-      log.warn(`Cleanup error: ${(err as Error).message}`)
-    }
+    await sessionOnSessionEnd(this.#getInternals())
   }
 
   async onProcessExit() {
     return this.onSessionEnd()
   }
 
-  /** Mark suite finished on after-all so the dashboard updates pre-exit. */
-  finalizeTestRun() {
+  /**
+   * Cucumber / mocha / jest after-all hook. Mark the suite finished so the
+   * dashboard updates pre-exit, then run the session-wide teardown
+   * (`onSessionEnd`) — capturer cleanup, summary log, interactive shutdown
+   * path. `onBeforeQuit` already handled the PER-driver finalize for each
+   * scenario; this is the one-time finish.
+   *
+   * onTestRunComplete fires AFTER per-scenario `After` hooks, so any state
+   * updates queued in the cucumber lifecycle have already flushed by here.
+   */
+  async finalizeTestRun() {
     this.#testManager?.finalizeSession()
     this.#suiteManager?.finalize()
     this.#testReporter?.updateSuites()
+    if (this.#isReuse) {
+      // Reuse mode (rerun child): close the WS now so the child's event
+      // loop can drain and the process exits on its own. Skip
+      // onSessionEnd's interactive shutdown branch.
+      void this.#sessionCapturer?.closeWebSocket()
+      return
+    }
+    await this.onSessionEnd()
   }
 
   get sessionCapturer() {
     return this.#sessionCapturer
   }
+  get isReuse() {
+    return this.#isReuse
+  }
   get rerunManager() {
     return this.#rerunManager
   }
@@ -903,7 +484,14 @@ const patched = patchSelenium({
   },
   onDriverCreated: (driver) => plugin.onDriverCreated(driver),
   onCommand: (cmd) => plugin.onCommand(cmd),
-  onBeforeQuit: () => plugin.onSessionEnd(),
+  // Per-scenario cleanup ONLY here (finalizes that driver's screencast,
+  // clears per-driver state). The session-wide teardown — set-finalized,
+  // session summary, capturer cleanup, interactive shutdown — lives in
+  // `finalizeTestRun` (cucumber/mocha/jest `onTestRunComplete`) and the
+  // beforeExit/exit handlers in processHooks. Wiring `onSessionEnd` here
+  // broke multi-scenario runs: its `if (finalized) return` guard meant
+  // scenario 2+ never got their per-driver finalize → missing screencast.
+  onBeforeQuit: () => plugin.onDriverEnd(),
   // Block `await Builder.build()` until the dashboard is connected.
   waitForReady: () => plugin.waitForUiReady()
 })
@@ -960,7 +548,7 @@ function registerHooks() {
       plugin.endScenario(state === 'pending' ? 'skipped' : state)
     },
     onTestRunComplete: () => {
-      plugin.finalizeTestRun()
+      void plugin.finalizeTestRun()
     }
   })
 }
@@ -974,42 +562,7 @@ if (!registerHooks()) {
   }, 100)
 }
 
-process.on('exit', () => {
-  void plugin.onSessionEnd()
-})
-process.on('beforeExit', () => {
-  void plugin.onSessionEnd()
-})
-
-async function gracefulShutdown(code: number) {
-  try {
-    plugin.clearKeepAlive()
-    await plugin.sessionCapturer?.closeWebSocket()
-    plugin.sessionCapturer?.cleanup()
-    // Best-effort: kill the detached Chrome dashboard. Each session's
-    // --user-data-dir contains the unique `selenium-devtools-ui-${port}`
-    // marker, so a pattern match lands on this run's window only.
-    try {
-      spawn(
-        '/usr/bin/pkill',
-        ['-f', `selenium-devtools-ui-${plugin.options.port}-`],
-        { stdio: 'ignore' }
-      )
-    } catch {
-      /* pkill missing — accept stale Chrome */
-    }
-  } catch {
-    /* best-effort */
-  }
-  process.exit(code)
-}
-
-process.on('SIGINT', () => {
-  void gracefulShutdown(130)
-})
-process.on('SIGTERM', () => {
-  void gracefulShutdown(143)
-})
+registerProcessHooks(plugin)
 
 export const DevTools = {
   configure: (opts: { rerunCommand?: string }) => plugin.configure(opts),
diff --git a/packages/selenium-devtools/src/plugin-internals.ts b/packages/selenium-devtools/src/plugin-internals.ts
new file mode 100644
index 00000000..9484d07b
--- /dev/null
+++ b/packages/selenium-devtools/src/plugin-internals.ts
@@ -0,0 +1,59 @@
+/**
+ * Single internals "bag" the Selenium plugin exposes to its lifecycle modules.
+ *
+ * Each lifecycle module declares its own narrow `Ctx` interface; the plugin
+ * builds ONE `PluginInternals` object that structurally satisfies all of
+ * them. Keeps the plugin file compact while letting each lifecycle module
+ * narrow its dependencies.
+ */
+
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { TestManager } from './helpers/testManager.js'
+import type { ScreencastRecorder } from './screencast.js'
+import type { ScreencastOptions, SeleniumDriverLike } from './types.js'
+import type { RetryTracker } from '@wdio/devtools-core'
+import type { PendingTestAction, PendingScenario } from './test-management.js'
+
+export interface PluginInternals {
+  // Config
+  readonly options: {
+    hostname: string
+    port: number
+    openUi: boolean
+    captureScreenshots: boolean
+    rerunCommand?: string
+  }
+  readonly screencastOptions: ScreencastOptions
+  readonly runner: string
+  readonly rerunTemplate: string | undefined
+  readonly launchCommand: string | undefined
+  readonly isReuse: boolean
+  readonly finalized: boolean
+  readonly retryTracker: RetryTracker
+
+  // Mutable runtime instances
+  driver: SeleniumDriverLike | undefined
+  sessionCapturer: SessionCapturer | undefined
+  testReporter: TestReporter | undefined
+  suiteManager: SuiteManager | undefined
+  testManager: TestManager | undefined
+  screencast: ScreencastRecorder | undefined
+  sessionId: string | undefined
+  scriptInjected: boolean
+  testFilePath: string | undefined
+  keepAliveTimer: ReturnType<typeof setInterval> | undefined
+
+  // Test management buffers
+  pendingTestActions: PendingTestAction[]
+  pendingScenario: PendingScenario | null
+
+  // Plugin-side delegates
+  setFinalized(v: boolean): void
+  setScriptInjected(v: boolean): void
+  ensureBackendStarted(): Promise<void>
+  flushPendingTestActions(): void
+  resetRetryTracker(): void
+  clearKeepAlive(): void
+}
diff --git a/packages/selenium-devtools/src/reporter.ts b/packages/selenium-devtools/src/reporter.ts
index d1ac0155..300c040c 100644
--- a/packages/selenium-devtools/src/reporter.ts
+++ b/packages/selenium-devtools/src/reporter.ts
@@ -1,5 +1,5 @@
 import logger from '@wdio/logger'
-import { resetSignatureCounters } from './helpers/utils.js'
+import { TestReporterBase } from '@wdio/devtools-core'
 import type { SuiteStats, TestStats } from './types.js'
 
 const log = logger('@wdio/selenium-devtools:Reporter')
@@ -9,32 +9,16 @@ const log = logger('@wdio/selenium-devtools:Reporter')
  * upstream callback. The shape of each upstream payload is identical to the
  * Nightwatch plugin so the existing UI renders both transparently.
  */
-export class TestReporter {
-  #report: (data: any) => void
-  #allSuites: SuiteStats[] = []
-
-  constructor(report: (data: any) => void) {
-    this.#report = report
-    resetSignatureCounters()
-  }
-
-  updateUpstream(report: (data: any) => void) {
-    this.#report = report
-  }
-
-  onSuiteStart(suite: SuiteStats) {
-    if (!this.#allSuites.find((s) => s.uid === suite.uid)) {
-      this.#allSuites.push(suite)
+export class TestReporter extends TestReporterBase {
+  onSuiteStart(suite: SuiteStats): void {
+    if (!this.allSuites.find((s) => s.uid === suite.uid)) {
+      this.allSuites.push(suite)
     }
-    this.#sendUpstream()
-  }
-
-  onSuiteEnd(_suite: SuiteStats) {
-    this.#sendUpstream()
+    this.sendUpstream()
   }
 
-  onTestStart(test: TestStats) {
-    for (const suite of this.#allSuites) {
+  onTestStart(test: TestStats): void {
+    for (const suite of this.allSuites) {
       if (suite.uid !== test.parent) {
         continue
       }
@@ -45,44 +29,11 @@ export class TestReporter {
         suite.tests[idx] = test
       }
     }
-    this.#sendUpstream()
+    this.sendUpstream()
   }
 
-  onTestEnd(test: TestStats) {
-    for (const suite of this.#allSuites) {
-      const idx = suite.tests.findIndex(
-        (t) => typeof t !== 'string' && t.uid === test.uid
-      )
-      if (idx !== -1) {
-        suite.tests[idx] = test
-      }
-    }
-    this.#sendUpstream()
-  }
-
-  updateSuites() {
-    this.#sendUpstream()
-  }
-
-  clearExecutionData() {
-    this.#allSuites = []
-    resetSignatureCounters()
+  override clearExecutionData(): void {
+    super.clearExecutionData()
     log.info('Cleared execution data')
   }
-
-  #sendUpstream() {
-    const payload: Record<string, SuiteStats>[] = []
-    for (const suite of this.#allSuites) {
-      if (suite.uid) {
-        payload.push({ [suite.uid]: suite })
-      }
-    }
-    if (payload.length > 0) {
-      this.#report(payload)
-    }
-  }
-
-  get report() {
-    return this.#allSuites
-  }
 }
diff --git a/packages/selenium-devtools/src/runnerHooks.ts b/packages/selenium-devtools/src/runnerHooks.ts
index 181422d8..27c6db9e 100644
--- a/packages/selenium-devtools/src/runnerHooks.ts
+++ b/packages/selenium-devtools/src/runnerHooks.ts
@@ -1,15 +1,22 @@
-import { createRequire } from 'node:module'
-import logger from '@wdio/logger'
-import { findTestLineInFile } from './helpers/utils.js'
-import type { MochaTestCtx, RunnerHookCallbacks } from './types.js'
+import type { RunnerHookCallbacks } from './types.js'
+import { tryRegisterMochaHooks } from './runnerHooks/mocha.js'
+import { tryRegisterJestHooks } from './runnerHooks/jest.js'
+import { tryRegisterCucumberHooks } from './runnerHooks/cucumber.js'
 
-const log = logger('@wdio/selenium-devtools:runnerHooks')
+export { tryRegisterMochaHooks, tryRegisterJestHooks, tryRegisterCucumberHooks }
 
 // Jest is identified by `expect.getState()` (Chai's `expect` lacks it).
 // Mocha is identified by `it`+`describe`+`beforeEach` without that.
 // Cucumber doesn't expose globals — we detect via argv + a require probe.
 export function detectRunner(): 'jest' | 'mocha' | 'cucumber' | null {
-  const g = globalThis as any
+  // Double-cast: built-in `globalThis` lacks the runner globals; kept local
+  // (not `declare global`) so consumers don't get them as ambient types.
+  const g = globalThis as unknown as {
+    beforeEach?: unknown
+    expect?: { getState?: unknown }
+    it?: unknown
+    describe?: unknown
+  }
   if ((process.argv[1] || '').toLowerCase().includes('cucumber')) {
     return 'cucumber'
   }
@@ -41,621 +48,3 @@ export function tryRegisterRunnerHooks(
   }
   return false
 }
-
-// Use beforeEach/afterEach — wrapping `it()` breaks `it.skip` / `it.only`.
-export function tryRegisterMochaHooks(callbacks: RunnerHookCallbacks): boolean {
-  const g = globalThis as any
-  if (typeof g.beforeEach !== 'function' || typeof g.afterEach !== 'function') {
-    return false
-  }
-  // Counters used by the run-level before/after hooks below.
-  let runStartTs = 0
-  let testsStarted = 0
-  let testsPassed = 0
-  let testsFailed = 0
-  let testsPending = 0
-  try {
-    if (typeof g.before === 'function' && typeof g.after === 'function') {
-      g.before(function () {
-        runStartTs = Date.now()
-        log.info('🧪 Test run starting')
-      })
-      g.after(function () {
-        const durationMs = Date.now() - runStartTs
-        const duration = (durationMs / 1000).toFixed(2)
-        log.info(
-          `🧪 Test run complete: ${testsPassed} passed, ${testsFailed} failed` +
-            (testsPending ? `, ${testsPending} pending` : '') +
-            ` (${duration}s, ${testsStarted} total)`
-        )
-        callbacks.onTestRunComplete?.({
-          passed: testsPassed,
-          failed: testsFailed,
-          pending: testsPending,
-          durationMs
-        })
-      })
-    }
-    g.beforeEach(function (this: any) {
-      // Fallback when `before` registered too late to fire.
-      if (runStartTs === 0) {
-        runStartTs = Date.now()
-      }
-      const test: MochaTestCtx | undefined = this?.currentTest
-      if (!test?.title) {
-        return
-      }
-      let callSource: string | undefined
-      if (test.file) {
-        const line = findTestLineInFile(test.file, test.title)
-        callSource = line ? `${test.file}:${line}` : `${test.file}:0`
-      }
-      log.info(`▶ Test: "${test.title}"`)
-      testsStarted++
-      // Mocha's root suite has an empty title — skip so we don't blank the dashboard.
-      const parentTitle =
-        typeof test.parent?.title === 'string' && test.parent.title.length > 0
-          ? test.parent.title
-          : undefined
-      let suiteCallSource: string | undefined
-      if (parentTitle && test.file) {
-        const line = findTestLineInFile(test.file, parentTitle, 'suite')
-        suiteCallSource = line ? `${test.file}:${line}` : `${test.file}:0`
-      }
-      callbacks.onTestStart(
-        test.title,
-        test.file,
-        callSource,
-        parentTitle,
-        suiteCallSource
-      )
-    })
-    g.afterEach(function (this: any) {
-      const test: MochaTestCtx | undefined = this?.currentTest
-      const state =
-        test?.state === 'failed'
-          ? 'failed'
-          : test?.state === 'passed'
-            ? 'passed'
-            : test?.state === 'pending'
-              ? 'pending'
-              : 'passed'
-      const icon = state === 'passed' ? '✓' : state === 'failed' ? '✗' : '○'
-      const duration =
-        typeof test?.duration === 'number' ? ` (${test.duration}ms)` : ''
-      log.info(`${icon} Test: "${test?.title ?? 'unknown'}"${duration}`)
-      if (state === 'passed') {
-        testsPassed++
-      } else if (state === 'failed') {
-        testsFailed++
-      } else if (state === 'pending') {
-        testsPending++
-      }
-      callbacks.onTestEnd(state)
-    })
-    log.info(
-      '✓ Mocha hooks registered — startTest/endTest will fire automatically per it()'
-    )
-    return true
-  } catch (err) {
-    log.warn(`Failed to register mocha hooks: ${(err as Error).message}`)
-    return false
-  }
-}
-
-// `suppressedErrors` only catches failed expect()s; we track thrown errors
-// (e.g. selenium TimeoutError) separately to mark those tests failed too.
-export function tryRegisterJestHooks(callbacks: RunnerHookCallbacks): boolean {
-  const g = globalThis as any
-  if (
-    typeof g.beforeEach !== 'function' ||
-    typeof g.afterEach !== 'function' ||
-    typeof g.expect?.getState !== 'function'
-  ) {
-    return false
-  }
-  let runStartTs = 0
-  let testsStarted = 0
-  let testsPassed = 0
-  let testsFailed = 0
-  let currentName = ''
-  // `currentTestName` is the space-joined describe path + test name (ambiguous);
-  // we capture the describe stack at registration to recover suite + inner name.
-  const describeStack: string[] = []
-  const testToDescribeStack = new Map<string, string[]>()
-  const testFailures = new Map<string, Error>()
-  const wrapWithDescribePush = <T extends (...args: any[]) => any>(
-    orig: T
-  ): T => {
-    const wrapped = ((name: string, fn: () => void, ...rest: any[]) => {
-      describeStack.push(name)
-      try {
-        return (orig as any).call(g, name, fn, ...rest)
-      } finally {
-        describeStack.pop()
-      }
-    }) as any as T
-    // Preserve .skip / .only / .each modifiers.
-    for (const k of Reflect.ownKeys(orig as any)) {
-      try {
-        ;(wrapped as any)[k] = (orig as any)[k]
-      } catch {
-        /* read-only own keys */
-      }
-    }
-    return wrapped
-  }
-  const wrapTestRegistrar = <T extends (...args: any[]) => any>(orig: T): T => {
-    const wrapped = ((name: string, fn: any, timeout?: number) => {
-      const stackAtRegistration = [...describeStack]
-      const jestKey = [...stackAtRegistration, name].join(' ')
-      const vitestKey = [...stackAtRegistration, name].join(' > ')
-      testToDescribeStack.set(jestKey, stackAtRegistration)
-      testToDescribeStack.set(vitestKey, stackAtRegistration)
-      let wrappedFn = fn
-      if (typeof fn === 'function') {
-        wrappedFn = function (this: any, ...fnArgs: any[]) {
-          // Key by inner test name — under Vitest the describe-stack
-          // capture isn't reliable (Vitest doesn't run describe bodies
-          // through our globalThis wrap), so the only stable identifier
-          // we share with afterEach is `name` itself.
-          const recordFailure = (err: Error) => {
-            testFailures.set(name, err)
-            testFailures.set(jestKey, err)
-            testFailures.set(vitestKey, err)
-          }
-          let result: unknown
-          try {
-            result = fn.apply(this, fnArgs)
-          } catch (err) {
-            recordFailure(err as Error)
-            throw err
-          }
-          if (result && typeof (result as any).then === 'function') {
-            return (result as Promise<unknown>).catch((err: unknown) => {
-              recordFailure(err as Error)
-              throw err
-            })
-          }
-          return result
-        }
-      }
-      return (orig as any).call(g, name, wrappedFn, timeout)
-    }) as any as T
-    for (const k of Reflect.ownKeys(orig as any)) {
-      try {
-        ;(wrapped as any)[k] = (orig as any)[k]
-      } catch {
-        /* read-only own keys */
-      }
-    }
-    return wrapped
-  }
-  if (typeof g.describe === 'function') {
-    g.describe = wrapWithDescribePush(g.describe)
-  }
-  if (typeof g.test === 'function') {
-    g.test = wrapTestRegistrar(g.test)
-  }
-  if (typeof g.it === 'function') {
-    g.it = wrapTestRegistrar(g.it)
-  }
-  try {
-    if (typeof g.beforeAll === 'function' && typeof g.afterAll === 'function') {
-      g.beforeAll(() => {
-        runStartTs = Date.now()
-        log.info('🧪 Test run starting')
-      })
-      g.afterAll(() => {
-        const durationMs = Date.now() - runStartTs
-        const duration = (durationMs / 1000).toFixed(2)
-        log.info(
-          `🧪 Test run complete: ${testsPassed} passed, ${testsFailed} failed ` +
-            `(${duration}s, ${testsStarted} total)`
-        )
-        callbacks.onTestRunComplete?.({
-          passed: testsPassed,
-          failed: testsFailed,
-          pending: 0,
-          durationMs
-        })
-      })
-    }
-    g.beforeEach(() => {
-      if (runStartTs === 0) {
-        runStartTs = Date.now()
-      }
-      const state = g.expect.getState() as {
-        currentTestName?: string
-        testPath?: string
-      }
-      const fullName = state?.currentTestName || ''
-      const file = state?.testPath || undefined
-      if (!fullName) {
-        return
-      }
-      // currentTestName: Jest joins describes with ' ', Vitest with ' > '.
-      const stack = testToDescribeStack.get(fullName) ?? []
-      let innerName = fullName
-      let suiteName: string | undefined
-      if (stack.length > 0) {
-        const jestPath = stack.join(' ')
-        const vitestPath = stack.join(' > ')
-        if (fullName.startsWith(jestPath + ' ')) {
-          innerName = fullName.slice(jestPath.length + 1)
-        } else if (fullName.startsWith(vitestPath + ' > ')) {
-          innerName = fullName.slice(vitestPath.length + 3)
-        }
-        suiteName = stack[0]
-      } else if (fullName.includes(' > ')) {
-        const segments = fullName.split(' > ')
-        innerName = segments[segments.length - 1]
-        suiteName = segments[0]
-      }
-      currentName = innerName
-      let callSource: string | undefined
-      if (file) {
-        const line = findTestLineInFile(file, innerName)
-        callSource = line ? `${file}:${line}` : `${file}:0`
-      }
-      let suiteCallSource: string | undefined
-      if (suiteName && file) {
-        const line = findTestLineInFile(file, suiteName, 'suite')
-        suiteCallSource = line ? `${file}:${line}` : `${file}:0`
-      }
-      log.info(`▶ Test: "${innerName}"`)
-      testsStarted++
-      callbacks.onTestStart(
-        innerName,
-        file,
-        callSource,
-        suiteName,
-        suiteCallSource
-      )
-    })
-    g.afterEach(() => {
-      const state = g.expect.getState() as {
-        suppressedErrors?: unknown[]
-        currentTestName?: string
-      }
-      const fullName = state?.currentTestName || ''
-      // Try the recorded full-path keys first, then the inner test name —
-      // under Vitest the stack capture is empty so we keyed by inner name.
-      const innerKey =
-        fullName.split(' > ').pop() ?? fullName.split(' ').pop() ?? fullName
-      const thrown =
-        testFailures.get(fullName) ??
-        testFailures.get(fullName.replace(/ > /g, ' ')) ??
-        testFailures.get(fullName.replace(/ /g, ' > ')) ??
-        testFailures.get(innerKey)
-      const expectFailed =
-        Array.isArray(state?.suppressedErrors) &&
-        state.suppressedErrors.length > 0
-      const failed = !!thrown || expectFailed
-      if (thrown) {
-        testFailures.delete(fullName)
-        testFailures.delete(fullName.replace(/ > /g, ' '))
-        testFailures.delete(fullName.replace(/ /g, ' > '))
-        testFailures.delete(innerKey)
-      }
-      const finalState: 'passed' | 'failed' = failed ? 'failed' : 'passed'
-      const icon = finalState === 'passed' ? '✓' : '✗'
-      log.info(`${icon} Test: "${currentName || 'unknown'}"`)
-      if (finalState === 'passed') {
-        testsPassed++
-      } else {
-        testsFailed++
-      }
-      callbacks.onTestEnd(finalState)
-    })
-    log.info(
-      '✓ Jest hooks registered — startTest/endTest will fire automatically per test()'
-    )
-    return true
-  } catch (err) {
-    log.warn(`Failed to register jest hooks: ${(err as Error).message}`)
-    return false
-  }
-}
-
-// Loads `@cucumber/cucumber` from the user's install (peer-dep style) and
-// registers BeforeAll/Before/After/AfterAll. The hook receives the full
-// pickle so we can surface scenario name + feature name in the dashboard.
-export function tryRegisterCucumberHooks(
-  callbacks: RunnerHookCallbacks
-): boolean {
-  const tryLoad = (): any | null => {
-    try {
-      return createRequire(`${process.cwd()}/`)('@cucumber/cucumber')
-    } catch {
-      try {
-        return createRequire(import.meta.url)('@cucumber/cucumber')
-      } catch {
-        return null
-      }
-    }
-  }
-  const cucumber = tryLoad()
-  if (!cucumber) {
-    return false
-  }
-  const { Before, After, BeforeAll, AfterAll, BeforeStep, AfterStep } = cucumber
-  if (typeof Before !== 'function' || typeof After !== 'function') {
-    return false
-  }
-
-  // BeforeStep doesn't expose which step definition matched, so we wrap the
-  // Given/When/Then registrars to snapshot (pattern → uri:line) at registration.
-  const stepDefinitions: Array<{
-    pattern: string | RegExp
-    uri: string
-    line: number
-  }> = []
-
-  const selfUrl = (() => {
-    try {
-      return import.meta.url
-    } catch {
-      return ''
-    }
-  })()
-  const selfPath = selfUrl.replace(/^file:\/\//, '')
-  const isSelfFrame = (line: string): boolean => {
-    if (!selfPath) {
-      return false
-    }
-    return line.includes(selfPath) || line.includes(selfUrl)
-  }
-
-  const captureCallSite = (): { uri: string; line: number } | null => {
-    const stack = new Error().stack || ''
-    for (const raw of stack.split('\n')) {
-      const line = raw.trim()
-      if (!line.startsWith('at ')) {
-        continue
-      }
-      if (
-        line.includes('@cucumber/') ||
-        line.includes('node:internal') ||
-        isSelfFrame(line)
-      ) {
-        continue
-      }
-      const m =
-        /\(([^)]+):(\d+):\d+\)$/.exec(line) || /at\s+(.+):(\d+):\d+$/.exec(line)
-      if (m) {
-        let uri = m[1]
-        if (uri.startsWith('file://')) {
-          uri = uri.replace(/^file:\/\//, '')
-        }
-        return { uri, line: Number(m[2]) }
-      }
-    }
-    return null
-  }
-
-  for (const name of ['Given', 'When', 'Then', 'defineStep'] as const) {
-    if (typeof cucumber[name] !== 'function') {
-      continue
-    }
-    const orig = cucumber[name]
-    cucumber[name] = function patchedRegistrar(...args: any[]) {
-      const callSite = captureCallSite()
-      if (callSite && args.length > 0) {
-        stepDefinitions.push({
-          pattern: args[0],
-          uri: callSite.uri,
-          line: callSite.line
-        })
-      }
-      return orig.apply(this, args)
-    }
-    Object.assign(cucumber[name], orig)
-  }
-
-  // Cucumber-expression → regex. Handles built-in placeholders only; custom
-  // types fall through to wildcard. Braces MUST be in the escape set so the
-  // subsequent `\{string\}`-shaped replacements can match.
-  const patternToRegex = (pattern: string): RegExp => {
-    const escaped = pattern.replace(/[{}.*+?^$|()[\]\\]/g, '\\$&')
-    const expanded = escaped
-      .replace(/\\\{string\\\}/g, '"([^"]*)"')
-      .replace(/\\\{int\\\}/g, '(-?\\d+)')
-      .replace(/\\\{float\\\}/g, '(-?\\d*\\.?\\d+)')
-      .replace(/\\\{word\\\}/g, '([^\\s]+)')
-      .replace(/\\\{[^}]*\\\}/g, '(.+?)')
-    return new RegExp(`^${expanded}$`)
-  }
-
-  const findStepDefinition = (
-    text: string
-  ): { uri: string; line: number } | null => {
-    for (const def of stepDefinitions) {
-      let regex: RegExp
-      try {
-        regex =
-          def.pattern instanceof RegExp
-            ? def.pattern
-            : patternToRegex(String(def.pattern))
-      } catch {
-        continue
-      }
-      if (regex.test(text)) {
-        return { uri: def.uri, line: def.line }
-      }
-    }
-    return null
-  }
-
-  let runStartTs = 0
-  let testsStarted = 0
-  let testsPassed = 0
-  let testsFailed = 0
-  let testsPending = 0
-
-  try {
-    if (typeof BeforeAll === 'function' && typeof AfterAll === 'function') {
-      BeforeAll(() => {
-        runStartTs = Date.now()
-        log.info('🧪 Test run starting')
-      })
-      AfterAll(() => {
-        const durationMs = Date.now() - runStartTs
-        const duration = (durationMs / 1000).toFixed(2)
-        log.info(
-          `🧪 Test run complete: ${testsPassed} passed, ${testsFailed} failed` +
-            (testsPending ? `, ${testsPending} pending` : '') +
-            ` (${duration}s, ${testsStarted} total)`
-        )
-        callbacks.onTestRunComplete?.({
-          passed: testsPassed,
-          failed: testsFailed,
-          pending: testsPending,
-          durationMs
-        })
-      })
-    }
-
-    // PickleStep has no `location.line`; only the gherkinDocument AST does.
-    // These maps bridge astNodeId → line for the dashboard's test-lens.
-    let stepKeywordById = new Map<string, string>()
-    let stepLineById = new Map<string, number>()
-    let scenarioLineById = new Map<string, number>()
-
-    Before(function (testCase: any) {
-      if (runStartTs === 0) {
-        runStartTs = Date.now()
-      }
-      const pickle = testCase?.pickle
-      const name: string = pickle?.name ?? 'unknown scenario'
-      const file: string | undefined = pickle?.uri
-      const featureName: string | undefined =
-        testCase?.gherkinDocument?.feature?.name
-      const featureLine = testCase?.gherkinDocument?.feature?.location?.line
-
-      stepKeywordById = new Map<string, string>()
-      stepLineById = new Map<string, number>()
-      scenarioLineById = new Map<string, number>()
-      const featureChildren = testCase?.gherkinDocument?.feature?.children ?? []
-      for (const child of featureChildren) {
-        if (child?.scenario?.id && child?.scenario?.location?.line) {
-          scenarioLineById.set(child.scenario.id, child.scenario.location.line)
-        }
-        const steps = child?.scenario?.steps ?? child?.background?.steps ?? []
-        for (const step of steps) {
-          if (step?.id && typeof step?.keyword === 'string') {
-            stepKeywordById.set(step.id, step.keyword)
-          }
-          if (step?.id && step?.location?.line) {
-            stepLineById.set(step.id, step.location.line)
-          }
-        }
-      }
-
-      const scenarioLineFromMap =
-        Array.isArray(pickle?.astNodeIds) &&
-        scenarioLineById.get(pickle.astNodeIds[0])
-      const scenarioLine = scenarioLineFromMap || pickle?.location?.line
-      const callSource = file
-        ? scenarioLine
-          ? `${file}:${scenarioLine}`
-          : `${file}:0`
-        : undefined
-      const featureCallSource = file
-        ? featureLine
-          ? `${file}:${featureLine}`
-          : `${file}:1`
-        : undefined
-
-      log.info(`▶ Scenario: "${name}"`)
-      testsStarted++
-      callbacks.onScenarioStart?.(
-        name,
-        file,
-        callSource,
-        featureName,
-        featureCallSource
-      )
-    })
-
-    if (typeof BeforeStep === 'function') {
-      BeforeStep(function (arg: any) {
-        const pickleStep = arg?.pickleStep
-        if (!pickleStep) {
-          return
-        }
-        const astId =
-          Array.isArray(pickleStep.astNodeIds) && pickleStep.astNodeIds[0]
-        const keyword = (astId && stepKeywordById.get(astId)) || ''
-        const text: string = pickleStep.text ?? ''
-        const title = `${keyword}${text}`.trim()
-        // Prefer the step-definition source over the .feature line — the
-        // dashboard's Source panel loads `file`, not `callSource`.
-        const stepDef = findStepDefinition(text)
-        const featureFile: string | undefined = arg?.pickle?.uri
-        const featureLineForStep =
-          (astId && stepLineById.get(astId)) || pickleStep?.location?.line
-        const file = stepDef ? stepDef.uri : featureFile
-        const callSource = stepDef
-          ? `${stepDef.uri}:${stepDef.line}`
-          : featureFile
-            ? featureLineForStep
-              ? `${featureFile}:${featureLineForStep}`
-              : `${featureFile}:0`
-            : undefined
-        callbacks.onTestStart(title, file, callSource)
-      })
-    }
-
-    if (typeof AfterStep === 'function') {
-      AfterStep(function (arg: any) {
-        const status = String(arg?.result?.status ?? '').toUpperCase()
-        let state: 'passed' | 'failed' | 'pending' | 'skipped' = 'passed'
-        if (
-          status === 'FAILED' ||
-          status === 'UNDEFINED' ||
-          status === 'AMBIGUOUS'
-        ) {
-          state = 'failed'
-        } else if (status === 'PENDING') {
-          state = 'pending'
-        } else if (status === 'SKIPPED') {
-          state = 'skipped'
-        }
-        callbacks.onTestEnd(state)
-      })
-    }
-
-    After(function (testCase: any) {
-      const status = String(testCase?.result?.status ?? '').toUpperCase()
-      let state: 'passed' | 'failed' | 'pending' = 'passed'
-      if (
-        status === 'FAILED' ||
-        status === 'UNDEFINED' ||
-        status === 'AMBIGUOUS'
-      ) {
-        state = 'failed'
-      } else if (status === 'PENDING' || status === 'SKIPPED') {
-        state = 'pending'
-      }
-      const icon = state === 'passed' ? '✓' : state === 'failed' ? '✗' : '○'
-      log.info(`${icon} Scenario: "${testCase?.pickle?.name ?? 'unknown'}"`)
-      if (state === 'passed') {
-        testsPassed++
-      } else if (state === 'failed') {
-        testsFailed++
-      } else {
-        testsPending++
-      }
-      callbacks.onScenarioEnd?.(state)
-    })
-
-    log.info(
-      '✓ Cucumber hooks registered — Before/After=scenario sub-suite, BeforeStep/AfterStep=Gherkin step tests'
-    )
-    return true
-  } catch (err) {
-    log.warn(`Failed to register cucumber hooks: ${(err as Error).message}`)
-    return false
-  }
-}
diff --git a/packages/selenium-devtools/src/runnerHooks/cucumber.ts b/packages/selenium-devtools/src/runnerHooks/cucumber.ts
new file mode 100644
index 00000000..cffc6c76
--- /dev/null
+++ b/packages/selenium-devtools/src/runnerHooks/cucumber.ts
@@ -0,0 +1,444 @@
+import { createRequire } from 'node:module'
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+import type { RunnerHookCallbacks } from '../types.js'
+
+const log = logger('@wdio/selenium-devtools:runnerHooks:cucumber')
+
+type CucumberModule = Record<string, unknown> & {
+  Before?: (fn: (testCase: unknown) => void) => void
+  After?: (fn: (testCase: unknown) => void) => void
+  BeforeAll?: (fn: () => void) => void
+  AfterAll?: (fn: () => void) => void
+  BeforeStep?: (fn: (arg: unknown) => void) => void
+  AfterStep?: (fn: (arg: unknown) => void) => void
+}
+
+interface StepDefinition {
+  pattern: string | RegExp
+  uri: string
+  line: number
+}
+
+interface GherkinIndex {
+  stepKeywordById: Map<string, string>
+  stepLineById: Map<string, number>
+  scenarioLineById: Map<string, number>
+}
+
+interface RunCounters {
+  runStartTs: number
+  started: number
+  passed: number
+  failed: number
+  pending: number
+}
+
+function loadCucumber(): CucumberModule | null {
+  try {
+    return createRequire(`${process.cwd()}/`)('@cucumber/cucumber')
+  } catch {
+    try {
+      return createRequire(import.meta.url)('@cucumber/cucumber')
+    } catch {
+      return null
+    }
+  }
+}
+
+// Cucumber-expression → regex. Handles built-in placeholders only; custom
+// types fall through to wildcard.
+function patternToRegex(pattern: string): RegExp {
+  const escaped = pattern.replace(/[{}.*+?^$|()[\]\\]/g, '\\$&')
+  const expanded = escaped
+    .replace(/\\\{string\\\}/g, '"([^"]*)"')
+    .replace(/\\\{int\\\}/g, '(-?\\d+)')
+    .replace(/\\\{float\\\}/g, '(-?\\d*\\.?\\d+)')
+    .replace(/\\\{word\\\}/g, '([^\\s]+)')
+    .replace(/\\\{[^}]*\\\}/g, '(.+?)')
+  return new RegExp(`^${expanded}$`)
+}
+
+function makeCallSiteCapturer(): () => { uri: string; line: number } | null {
+  const selfUrl = (() => {
+    try {
+      return import.meta.url
+    } catch {
+      return ''
+    }
+  })()
+  const selfPath = selfUrl.replace(/^file:\/\//, '')
+  const isSelfFrame = (line: string): boolean =>
+    !!selfPath && (line.includes(selfPath) || line.includes(selfUrl))
+
+  return () => {
+    const stack = new Error().stack || ''
+    for (const raw of stack.split('\n')) {
+      const line = raw.trim()
+      if (!line.startsWith('at ')) {
+        continue
+      }
+      if (
+        line.includes('@cucumber/') ||
+        line.includes('node:internal') ||
+        isSelfFrame(line)
+      ) {
+        continue
+      }
+      const m =
+        /\(([^)]+):(\d+):\d+\)$/.exec(line) || /at\s+(.+):(\d+):\d+$/.exec(line)
+      if (m) {
+        const uri = m[1].startsWith('file://')
+          ? m[1].replace(/^file:\/\//, '')
+          : m[1]
+        return { uri, line: Number(m[2]) }
+      }
+    }
+    return null
+  }
+}
+
+// BeforeStep doesn't expose which step definition matched. Wraps Given/When/Then
+// to snapshot (pattern → uri:line) at registration time.
+function createStepDefinitionRegistry(cucumber: CucumberModule): {
+  find: (text: string) => { uri: string; line: number } | null
+} {
+  const defs: StepDefinition[] = []
+  const captureCallSite = makeCallSiteCapturer()
+
+  for (const name of ['Given', 'When', 'Then', 'defineStep'] as const) {
+    const orig = cucumber[name]
+    if (typeof orig !== 'function') {
+      continue
+    }
+    const fn = orig as (...a: unknown[]) => unknown
+    const wrapped = function patchedRegistrar(
+      this: unknown,
+      ...args: unknown[]
+    ) {
+      const callSite = captureCallSite()
+      if (callSite && args.length > 0) {
+        defs.push({
+          pattern: args[0] as string | RegExp,
+          uri: callSite.uri,
+          line: callSite.line
+        })
+      }
+      return fn.apply(this, args)
+    }
+    Object.assign(wrapped, orig)
+    cucumber[name] = wrapped
+  }
+
+  return {
+    find(text) {
+      for (const def of defs) {
+        let regex: RegExp
+        try {
+          regex =
+            def.pattern instanceof RegExp
+              ? def.pattern
+              : patternToRegex(String(def.pattern))
+        } catch {
+          continue
+        }
+        if (regex.test(text)) {
+          return { uri: def.uri, line: def.line }
+        }
+      }
+      return null
+    }
+  }
+}
+
+function makeGherkinIndex(): GherkinIndex {
+  return {
+    stepKeywordById: new Map<string, string>(),
+    stepLineById: new Map<string, number>(),
+    scenarioLineById: new Map<string, number>()
+  }
+}
+
+interface GherkinStep {
+  id?: string
+  keyword?: string
+  location?: { line?: number }
+}
+interface GherkinScenario {
+  id?: string
+  location?: { line?: number }
+  steps?: GherkinStep[]
+}
+interface GherkinFeatureChild {
+  scenario?: GherkinScenario
+  background?: { steps?: GherkinStep[] }
+}
+interface GherkinFeature {
+  name?: string
+  location?: { line?: number }
+  children?: GherkinFeatureChild[]
+}
+interface CucumberPickleStep {
+  text?: string
+  astNodeIds?: string[]
+  location?: { line?: number }
+}
+interface CucumberPickle {
+  name?: string
+  uri?: string
+  location?: { line?: number }
+  astNodeIds?: string[]
+}
+interface CucumberTestCase {
+  gherkinDocument?: { feature?: GherkinFeature }
+  pickle?: CucumberPickle
+  result?: { status?: string }
+}
+interface CucumberStepArg {
+  pickleStep?: CucumberPickleStep
+  pickle?: CucumberPickle
+  result?: { status?: string }
+}
+
+function populateGherkinIndex(
+  index: GherkinIndex,
+  testCase: CucumberTestCase
+): void {
+  index.stepKeywordById.clear()
+  index.stepLineById.clear()
+  index.scenarioLineById.clear()
+  const featureChildren = testCase?.gherkinDocument?.feature?.children ?? []
+  for (const child of featureChildren) {
+    if (child?.scenario?.id && child?.scenario?.location?.line) {
+      index.scenarioLineById.set(
+        child.scenario.id,
+        child.scenario.location.line
+      )
+    }
+    const steps = child?.scenario?.steps ?? child?.background?.steps ?? []
+    for (const step of steps) {
+      if (step?.id && typeof step?.keyword === 'string') {
+        index.stepKeywordById.set(step.id, step.keyword)
+      }
+      if (step?.id && step?.location?.line) {
+        index.stepLineById.set(step.id, step.location.line)
+      }
+    }
+  }
+}
+
+type ScenarioState = 'passed' | 'failed' | 'pending'
+
+function mapCucumberStatus(status: string): ScenarioState | 'skipped' {
+  const s = status.toUpperCase()
+  if (s === 'FAILED' || s === 'UNDEFINED' || s === 'AMBIGUOUS') {
+    return 'failed'
+  }
+  if (s === 'PENDING') {
+    return 'pending'
+  }
+  if (s === 'SKIPPED') {
+    return 'skipped'
+  }
+  return 'passed'
+}
+
+function registerRunLifecycleHooks(
+  cucumber: CucumberModule,
+  counters: RunCounters,
+  callbacks: RunnerHookCallbacks
+): void {
+  const { BeforeAll, AfterAll } = cucumber
+  if (typeof BeforeAll !== 'function' || typeof AfterAll !== 'function') {
+    return
+  }
+  BeforeAll(() => {
+    counters.runStartTs = Date.now()
+    log.info('🧪 Test run starting')
+  })
+  AfterAll(() => {
+    const durationMs = Date.now() - counters.runStartTs
+    const duration = (durationMs / 1000).toFixed(2)
+    log.info(
+      `🧪 Test run complete: ${counters.passed} passed, ${counters.failed} failed` +
+        (counters.pending ? `, ${counters.pending} pending` : '') +
+        ` (${duration}s, ${counters.started} total)`
+    )
+    callbacks.onTestRunComplete?.({
+      passed: counters.passed,
+      failed: counters.failed,
+      pending: counters.pending,
+      durationMs
+    })
+  })
+}
+
+function handleScenarioStart(
+  testCase: CucumberTestCase,
+  index: GherkinIndex,
+  counters: RunCounters,
+  callbacks: RunnerHookCallbacks
+): void {
+  if (counters.runStartTs === 0) {
+    counters.runStartTs = Date.now()
+  }
+  populateGherkinIndex(index, testCase)
+  const pickle = testCase?.pickle
+  const name: string = pickle?.name ?? 'unknown scenario'
+  const file: string | undefined = pickle?.uri
+  const featureName: string | undefined =
+    testCase?.gherkinDocument?.feature?.name
+  const featureLine = testCase?.gherkinDocument?.feature?.location?.line
+  const scenarioLineFromMap =
+    pickle?.astNodeIds && Array.isArray(pickle.astNodeIds)
+      ? index.scenarioLineById.get(pickle.astNodeIds[0])
+      : undefined
+  const scenarioLine = scenarioLineFromMap || pickle?.location?.line
+  const callSource = file
+    ? scenarioLine
+      ? `${file}:${scenarioLine}`
+      : `${file}:0`
+    : undefined
+  const featureCallSource = file
+    ? featureLine
+      ? `${file}:${featureLine}`
+      : `${file}:1`
+    : undefined
+  log.info(`▶ Scenario: "${name}"`)
+  counters.started++
+  callbacks.onScenarioStart?.(
+    name,
+    file,
+    callSource,
+    featureName,
+    featureCallSource
+  )
+}
+
+function handleScenarioEnd(
+  testCase: CucumberTestCase,
+  counters: RunCounters,
+  callbacks: RunnerHookCallbacks
+): void {
+  const state = mapCucumberStatus(String(testCase?.result?.status ?? ''))
+  const scenarioState: ScenarioState = state === 'skipped' ? 'pending' : state
+  const icon =
+    scenarioState === 'passed' ? '✓' : scenarioState === 'failed' ? '✗' : '○'
+  log.info(`${icon} Scenario: "${testCase?.pickle?.name ?? 'unknown'}"`)
+  if (scenarioState === 'passed') {
+    counters.passed++
+  } else if (scenarioState === 'failed') {
+    counters.failed++
+  } else {
+    counters.pending++
+  }
+  callbacks.onScenarioEnd?.(scenarioState)
+}
+
+function registerScenarioHooks(
+  cucumber: CucumberModule,
+  index: GherkinIndex,
+  counters: RunCounters,
+  callbacks: RunnerHookCallbacks
+): void {
+  const { Before, After } = cucumber
+  if (typeof Before !== 'function' || typeof After !== 'function') {
+    return
+  }
+  Before((testCase) =>
+    handleScenarioStart(
+      testCase as CucumberTestCase,
+      index,
+      counters,
+      callbacks
+    )
+  )
+  After((testCase) =>
+    handleScenarioEnd(testCase as CucumberTestCase, counters, callbacks)
+  )
+}
+
+function registerStepHooks(
+  cucumber: CucumberModule,
+  index: GherkinIndex,
+  stepDefs: { find: (text: string) => { uri: string; line: number } | null },
+  callbacks: RunnerHookCallbacks
+): void {
+  const { BeforeStep, AfterStep } = cucumber
+  if (typeof BeforeStep === 'function') {
+    BeforeStep(function (raw) {
+      const arg = raw as CucumberStepArg
+      const pickleStep = arg?.pickleStep
+      if (!pickleStep) {
+        return
+      }
+      const astId = Array.isArray(pickleStep.astNodeIds)
+        ? pickleStep.astNodeIds[0]
+        : undefined
+      const keyword = (astId && index.stepKeywordById.get(astId)) || ''
+      const text: string = pickleStep.text ?? ''
+      const title = `${keyword}${text}`.trim()
+      const stepDef = stepDefs.find(text)
+      const featureFile: string | undefined = arg?.pickle?.uri
+      const featureLineForStep =
+        (astId && index.stepLineById.get(astId)) || pickleStep?.location?.line
+      const file = stepDef ? stepDef.uri : featureFile
+      const callSource = stepDef
+        ? `${stepDef.uri}:${stepDef.line}`
+        : featureFile
+          ? featureLineForStep
+            ? `${featureFile}:${featureLineForStep}`
+            : `${featureFile}:0`
+          : undefined
+      callbacks.onTestStart(title, file, callSource)
+    })
+  }
+  if (typeof AfterStep === 'function') {
+    AfterStep(function (raw) {
+      const arg = raw as CucumberStepArg
+      const state = mapCucumberStatus(String(arg?.result?.status ?? ''))
+      callbacks.onTestEnd(state)
+    })
+  }
+}
+
+// Loads `@cucumber/cucumber` from the user's install (peer-dep style) and
+// registers BeforeAll/Before/After/AfterAll. The hook receives the full
+// pickle so we can surface scenario name + feature name in the dashboard.
+export function tryRegisterCucumberHooks(
+  callbacks: RunnerHookCallbacks
+): boolean {
+  const cucumber = loadCucumber()
+  if (!cucumber) {
+    return false
+  }
+  if (
+    typeof cucumber.Before !== 'function' ||
+    typeof cucumber.After !== 'function'
+  ) {
+    return false
+  }
+
+  const stepDefs = createStepDefinitionRegistry(cucumber)
+  const counters: RunCounters = {
+    runStartTs: 0,
+    started: 0,
+    passed: 0,
+    failed: 0,
+    pending: 0
+  }
+
+  try {
+    registerRunLifecycleHooks(cucumber, counters, callbacks)
+    const index = makeGherkinIndex()
+    registerScenarioHooks(cucumber, index, counters, callbacks)
+    registerStepHooks(cucumber, index, stepDefs, callbacks)
+    log.info(
+      '✓ Cucumber hooks registered — Before/After=scenario sub-suite, BeforeStep/AfterStep=Gherkin step tests'
+    )
+    return true
+  } catch (err) {
+    log.warn(`Failed to register cucumber hooks: ${errorMessage(err)}`)
+    return false
+  }
+}
diff --git a/packages/selenium-devtools/src/runnerHooks/jest.ts b/packages/selenium-devtools/src/runnerHooks/jest.ts
new file mode 100644
index 00000000..24477e06
--- /dev/null
+++ b/packages/selenium-devtools/src/runnerHooks/jest.ts
@@ -0,0 +1,310 @@
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+import { findTestLineInFile } from '../helpers/utils.js'
+import type { RunnerHookCallbacks } from '../types.js'
+
+const log = logger('@wdio/selenium-devtools:runnerHooks:jest')
+
+// Jest/Vitest globals — kept as a local shape rather than a `declare global`
+// so consumers of this package don't pick up `describe`/`it` as ambient
+// globals when they may not actually be present.
+type JestFn = (...args: unknown[]) => unknown
+type JestGlobals = {
+  describe?: JestFn
+  test?: JestFn
+  it?: JestFn
+  beforeAll?: JestFn
+  afterAll?: JestFn
+  beforeEach?: JestFn
+  afterEach?: JestFn
+  expect?: { getState?: () => unknown }
+}
+
+interface JestState {
+  describeStack: string[]
+  testToDescribeStack: Map<string, string[]>
+  testFailures: Map<string, Error>
+  runStartTs: number
+  testsStarted: number
+  testsPassed: number
+  testsFailed: number
+  currentName: string
+}
+
+function copyModifiers<T extends object>(wrapped: T, orig: T): void {
+  const wrappedObj = wrapped as unknown as Record<string | symbol, unknown>
+  const origObj = orig as unknown as Record<string | symbol, unknown>
+  for (const k of Reflect.ownKeys(origObj)) {
+    try {
+      wrappedObj[k] = origObj[k]
+    } catch {
+      /* read-only own keys */
+    }
+  }
+}
+
+function wrapDescribe<T extends JestFn>(
+  orig: T,
+  g: JestGlobals,
+  state: JestState
+): T {
+  const wrapped = ((name: string, fn: () => void, ...rest: unknown[]) => {
+    state.describeStack.push(name)
+    try {
+      return (orig as (...args: unknown[]) => unknown).call(
+        g,
+        name,
+        fn,
+        ...rest
+      )
+    } finally {
+      state.describeStack.pop()
+    }
+  }) as unknown as T
+  copyModifiers(wrapped, orig)
+  return wrapped
+}
+
+function wrapTestRegistrar<T extends JestFn>(
+  orig: T,
+  g: JestGlobals,
+  state: JestState
+): T {
+  const wrapped = ((name: string, fn: unknown, timeout?: number) => {
+    const stackAtRegistration = [...state.describeStack]
+    const jestKey = [...stackAtRegistration, name].join(' ')
+    const vitestKey = [...stackAtRegistration, name].join(' > ')
+    state.testToDescribeStack.set(jestKey, stackAtRegistration)
+    state.testToDescribeStack.set(vitestKey, stackAtRegistration)
+    const wrappedFn =
+      typeof fn === 'function'
+        ? wrapTestFn(fn as JestFn, name, jestKey, vitestKey, state)
+        : fn
+    return (orig as (...args: unknown[]) => unknown).call(
+      g,
+      name,
+      wrappedFn,
+      timeout
+    )
+  }) as unknown as T
+  copyModifiers(wrapped, orig)
+  return wrapped
+}
+
+function wrapTestFn(
+  fn: JestFn,
+  name: string,
+  jestKey: string,
+  vitestKey: string,
+  state: JestState
+): JestFn {
+  return function (this: unknown, ...fnArgs: unknown[]) {
+    // Key by inner test name — under Vitest the describe-stack capture isn't
+    // reliable, so `name` is the only stable identifier shared with afterEach.
+    const recordFailure = (err: Error) => {
+      state.testFailures.set(name, err)
+      state.testFailures.set(jestKey, err)
+      state.testFailures.set(vitestKey, err)
+    }
+    let result: unknown
+    try {
+      result = fn.apply(this, fnArgs)
+    } catch (err) {
+      recordFailure(err as Error)
+      throw err
+    }
+    if (result && typeof (result as Promise<unknown>).then === 'function') {
+      return (result as Promise<unknown>).catch((err: unknown) => {
+        recordFailure(err as Error)
+        throw err
+      })
+    }
+    return result
+  }
+}
+
+function resolveTestNames(
+  fullName: string,
+  state: JestState
+): { innerName: string; suiteName: string | undefined } {
+  const stack = state.testToDescribeStack.get(fullName) ?? []
+  if (stack.length > 0) {
+    const jestPath = stack.join(' ')
+    const vitestPath = stack.join(' > ')
+    let innerName = fullName
+    if (fullName.startsWith(jestPath + ' ')) {
+      innerName = fullName.slice(jestPath.length + 1)
+    } else if (fullName.startsWith(vitestPath + ' > ')) {
+      innerName = fullName.slice(vitestPath.length + 3)
+    }
+    return { innerName, suiteName: stack[0] }
+  }
+  if (fullName.includes(' > ')) {
+    const segments = fullName.split(' > ')
+    return {
+      innerName: segments[segments.length - 1],
+      suiteName: segments[0]
+    }
+  }
+  return { innerName: fullName, suiteName: undefined }
+}
+
+function registerJestRunLifecycle(
+  g: JestGlobals,
+  state: JestState,
+  callbacks: RunnerHookCallbacks
+): void {
+  if (typeof g.beforeAll !== 'function' || typeof g.afterAll !== 'function') {
+    return
+  }
+  g.beforeAll(() => {
+    state.runStartTs = Date.now()
+    log.info('🧪 Test run starting')
+  })
+  g.afterAll(() => {
+    const durationMs = Date.now() - state.runStartTs
+    const duration = (durationMs / 1000).toFixed(2)
+    log.info(
+      `🧪 Test run complete: ${state.testsPassed} passed, ${state.testsFailed} failed ` +
+        `(${duration}s, ${state.testsStarted} total)`
+    )
+    callbacks.onTestRunComplete?.({
+      passed: state.testsPassed,
+      failed: state.testsFailed,
+      pending: 0,
+      durationMs
+    })
+  })
+}
+
+function registerJestBeforeEach(
+  g: JestGlobals,
+  state: JestState,
+  callbacks: RunnerHookCallbacks
+): void {
+  g.beforeEach!(() => {
+    if (state.runStartTs === 0) {
+      state.runStartTs = Date.now()
+    }
+    const expectState = g.expect!.getState!() as {
+      currentTestName?: string
+      testPath?: string
+    }
+    const fullName = expectState?.currentTestName || ''
+    const file = expectState?.testPath || undefined
+    if (!fullName) {
+      return
+    }
+
+    const { innerName, suiteName } = resolveTestNames(fullName, state)
+    state.currentName = innerName
+    const callSource = file
+      ? `${file}:${findTestLineInFile(file, innerName) || 0}`
+      : undefined
+    const suiteCallSource =
+      suiteName && file
+        ? `${file}:${findTestLineInFile(file, suiteName, 'suite') || 0}`
+        : undefined
+
+    log.info(`▶ Test: "${innerName}"`)
+    state.testsStarted++
+    callbacks.onTestStart(
+      innerName,
+      file,
+      callSource,
+      suiteName,
+      suiteCallSource
+    )
+  })
+}
+
+// `suppressedErrors` only catches failed expect()s; thrown errors (e.g.
+// selenium TimeoutError) are tracked separately to mark those tests failed too.
+function registerJestAfterEach(
+  g: JestGlobals,
+  state: JestState,
+  callbacks: RunnerHookCallbacks
+): void {
+  g.afterEach!(() => {
+    const expectState = g.expect!.getState!() as {
+      suppressedErrors?: unknown[]
+      currentTestName?: string
+    }
+    const fullName = expectState?.currentTestName || ''
+    // Try recorded full-path keys first, then inner test name — under Vitest
+    // the stack capture is empty so we keyed by inner name.
+    const innerKey =
+      fullName.split(' > ').pop() ?? fullName.split(' ').pop() ?? fullName
+    const thrown =
+      state.testFailures.get(fullName) ??
+      state.testFailures.get(fullName.replace(/ > /g, ' ')) ??
+      state.testFailures.get(fullName.replace(/ /g, ' > ')) ??
+      state.testFailures.get(innerKey)
+    const expectFailed =
+      Array.isArray(expectState?.suppressedErrors) &&
+      expectState.suppressedErrors.length > 0
+    const failed = !!thrown || expectFailed
+    if (thrown) {
+      state.testFailures.delete(fullName)
+      state.testFailures.delete(fullName.replace(/ > /g, ' '))
+      state.testFailures.delete(fullName.replace(/ /g, ' > '))
+      state.testFailures.delete(innerKey)
+    }
+    const finalState: 'passed' | 'failed' = failed ? 'failed' : 'passed'
+    const icon = finalState === 'passed' ? '✓' : '✗'
+    log.info(`${icon} Test: "${state.currentName || 'unknown'}"`)
+    if (finalState === 'passed') {
+      state.testsPassed++
+    } else {
+      state.testsFailed++
+    }
+    callbacks.onTestEnd(finalState)
+  })
+}
+
+export function tryRegisterJestHooks(callbacks: RunnerHookCallbacks): boolean {
+  // Double-cast required: built-in `globalThis` type doesn't include the
+  // runner globals, and they aren't structurally compatible.
+  const g = globalThis as unknown as JestGlobals
+  if (
+    typeof g.beforeEach !== 'function' ||
+    typeof g.afterEach !== 'function' ||
+    typeof g.expect?.getState !== 'function'
+  ) {
+    return false
+  }
+
+  const state: JestState = {
+    describeStack: [],
+    testToDescribeStack: new Map(),
+    testFailures: new Map(),
+    runStartTs: 0,
+    testsStarted: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    currentName: ''
+  }
+
+  if (typeof g.describe === 'function') {
+    g.describe = wrapDescribe(g.describe, g, state)
+  }
+  if (typeof g.test === 'function') {
+    g.test = wrapTestRegistrar(g.test, g, state)
+  }
+  if (typeof g.it === 'function') {
+    g.it = wrapTestRegistrar(g.it, g, state)
+  }
+
+  try {
+    registerJestRunLifecycle(g, state, callbacks)
+    registerJestBeforeEach(g, state, callbacks)
+    registerJestAfterEach(g, state, callbacks)
+    log.info(
+      '✓ Jest hooks registered — startTest/endTest will fire automatically per test()'
+    )
+    return true
+  } catch (err) {
+    log.warn(`Failed to register jest hooks: ${errorMessage(err)}`)
+    return false
+  }
+}
diff --git a/packages/selenium-devtools/src/runnerHooks/mocha.ts b/packages/selenium-devtools/src/runnerHooks/mocha.ts
new file mode 100644
index 00000000..5f2ad0f5
--- /dev/null
+++ b/packages/selenium-devtools/src/runnerHooks/mocha.ts
@@ -0,0 +1,156 @@
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+import { findTestLineInFile } from '../helpers/utils.js'
+import type { MochaTestCtx, RunnerHookCallbacks } from '../types.js'
+
+const log = logger('@wdio/selenium-devtools:runnerHooks:mocha')
+
+type MochaGlobals = {
+  beforeEach?: (fn: (this: { currentTest?: MochaTestCtx }) => void) => void
+  afterEach?: (fn: (this: { currentTest?: MochaTestCtx }) => void) => void
+  before?: (fn: () => void) => void
+  after?: (fn: () => void) => void
+}
+
+interface MochaCounters {
+  runStartTs: number
+  started: number
+  passed: number
+  failed: number
+  pending: number
+}
+
+function registerMochaRunLifecycle(
+  g: MochaGlobals,
+  counters: MochaCounters,
+  callbacks: RunnerHookCallbacks
+): void {
+  if (typeof g.before !== 'function' || typeof g.after !== 'function') {
+    return
+  }
+  g.before(() => {
+    counters.runStartTs = Date.now()
+    log.info('🧪 Test run starting')
+  })
+  g.after(() => {
+    const durationMs = Date.now() - counters.runStartTs
+    const duration = (durationMs / 1000).toFixed(2)
+    log.info(
+      `🧪 Test run complete: ${counters.passed} passed, ${counters.failed} failed` +
+        (counters.pending ? `, ${counters.pending} pending` : '') +
+        ` (${duration}s, ${counters.started} total)`
+    )
+    callbacks.onTestRunComplete?.({
+      passed: counters.passed,
+      failed: counters.failed,
+      pending: counters.pending,
+      durationMs
+    })
+  })
+}
+
+function resolveCallSource(
+  file: string | undefined,
+  title: string,
+  kind?: 'suite'
+): string | undefined {
+  if (!file) {
+    return undefined
+  }
+  const line = findTestLineInFile(file, title, kind)
+  return line ? `${file}:${line}` : `${file}:0`
+}
+
+function makeMochaBeforeEach(
+  counters: MochaCounters,
+  callbacks: RunnerHookCallbacks
+): (this: { currentTest?: MochaTestCtx }) => void {
+  return function (this: { currentTest?: MochaTestCtx }) {
+    if (counters.runStartTs === 0) {
+      counters.runStartTs = Date.now()
+    }
+    const test = this?.currentTest
+    if (!test?.title) {
+      return
+    }
+    log.info(`▶ Test: "${test.title}"`)
+    counters.started++
+    // Mocha's root suite has an empty title — skip so we don't blank the dashboard.
+    const parentTitle =
+      typeof test.parent?.title === 'string' && test.parent.title.length > 0
+        ? test.parent.title
+        : undefined
+    callbacks.onTestStart(
+      test.title,
+      test.file,
+      resolveCallSource(test.file, test.title),
+      parentTitle,
+      parentTitle
+        ? resolveCallSource(test.file, parentTitle, 'suite')
+        : undefined
+    )
+  }
+}
+
+function resolveMochaState(
+  test: MochaTestCtx | undefined
+): 'passed' | 'failed' | 'pending' {
+  if (test?.state === 'failed') {
+    return 'failed'
+  }
+  if (test?.state === 'pending') {
+    return 'pending'
+  }
+  return 'passed'
+}
+
+function makeMochaAfterEach(
+  counters: MochaCounters,
+  callbacks: RunnerHookCallbacks
+): (this: { currentTest?: MochaTestCtx }) => void {
+  return function (this: { currentTest?: MochaTestCtx }) {
+    const test = this?.currentTest
+    const state = resolveMochaState(test)
+    const icon = state === 'passed' ? '✓' : state === 'failed' ? '✗' : '○'
+    const duration =
+      typeof test?.duration === 'number' ? ` (${test.duration}ms)` : ''
+    log.info(`${icon} Test: "${test?.title ?? 'unknown'}"${duration}`)
+    if (state === 'passed') {
+      counters.passed++
+    } else if (state === 'failed') {
+      counters.failed++
+    } else {
+      counters.pending++
+    }
+    callbacks.onTestEnd(state)
+  }
+}
+
+// Use beforeEach/afterEach — wrapping `it()` breaks `it.skip` / `it.only`.
+export function tryRegisterMochaHooks(callbacks: RunnerHookCallbacks): boolean {
+  // Double-cast: built-in `globalThis` lacks the mocha globals; kept local
+  // (not `declare global`) so consumers don't get them as ambient types.
+  const g = globalThis as unknown as MochaGlobals
+  if (typeof g.beforeEach !== 'function' || typeof g.afterEach !== 'function') {
+    return false
+  }
+  const counters: MochaCounters = {
+    runStartTs: 0,
+    started: 0,
+    passed: 0,
+    failed: 0,
+    pending: 0
+  }
+  try {
+    registerMochaRunLifecycle(g, counters, callbacks)
+    g.beforeEach!(makeMochaBeforeEach(counters, callbacks))
+    g.afterEach!(makeMochaAfterEach(counters, callbacks))
+    log.info(
+      '✓ Mocha hooks registered — startTest/endTest will fire automatically per it()'
+    )
+    return true
+  } catch (err) {
+    log.warn(`Failed to register mocha hooks: ${errorMessage(err)}`)
+    return false
+  }
+}
diff --git a/packages/selenium-devtools/src/screencast.ts b/packages/selenium-devtools/src/screencast.ts
index 2f6287b6..7198b920 100644
--- a/packages/selenium-devtools/src/screencast.ts
+++ b/packages/selenium-devtools/src/screencast.ts
@@ -1,155 +1,196 @@
 import logger from '@wdio/logger'
-import {
-  BLANK_FRAME_THRESHOLD_BYTES,
-  SCREENCAST_DEFAULTS
-} from './constants.js'
+import { ScreencastRecorderBase, errorMessage } from '@wdio/devtools-core'
+import { BLANK_FRAME_THRESHOLD_BYTES } from './constants.js'
 import { getDriverOriginals } from './driverPatcher.js'
-import type {
-  ScreencastFrame,
-  ScreencastOptions,
-  SeleniumDriverLike
-} from './types.js'
+import type { SeleniumDriverLike } from './types.js'
 
 const log = logger('@wdio/selenium-devtools:ScreencastRecorder')
 
-// Two strategies:
-//   1. CDP push (Chromium): listens to `Page.screencastFrame` events.
-//   2. Polling fallback: calls unwrapped `takeScreenshot()` at pollIntervalMs.
-// Frames buffer in memory and encode to WebM at stop().
-export class ScreencastRecorder {
-  #frames: ScreencastFrame[] = []
-  #cdp: any = undefined
-  #cdpFrameListener: ((data: any) => void) | undefined
-  #pollTimer: ReturnType<typeof setInterval> | undefined
-  #isRecording = false
-  #options: Required<ScreencastOptions>
-  #startIndex = 0
-  #startMarkerSet = false
+/** Selenium 4's CDP connection helper — shape stable across patch releases.
+ *  IMPORTANT: `execute(method, params)` in selenium-webdriver is fire-and-
+ *  forget — it writes to the underlying WebSocket and returns `undefined`,
+ *  not a Promise. Don't await it and don't call `.then`/`.catch` on the
+ *  return value. To know when Chrome actually starts pushing frames, gate
+ *  on the first `Page.screencastFrame` message instead. */
+interface SeleniumCdpWebSocket {
+  on(event: 'message', listener: (data: unknown) => void): void
+  off?: (event: 'message', listener: (data: unknown) => void) => void
+}
+interface SeleniumCdpConnection {
+  _wsConnection?: SeleniumCdpWebSocket
+  execute(method: string, params?: Record<string, unknown>): void
+}
 
-  constructor(options: ScreencastOptions = {}) {
-    this.#options = { ...SCREENCAST_DEFAULTS, ...options }
+/** Max time to wait for Chrome's first screencast frame before declaring
+ *  recording active anyway. Most tests see the first frame in <100ms; the
+ *  ceiling protects against a totally unresponsive CDP target. */
+const FIRST_FRAME_TIMEOUT_MS = 2000
+
+/**
+ * Selenium-specific screencast recorder. Inherits the frame buffer, polling
+ * fallback, and public API from {@link ScreencastRecorderBase}; overrides the
+ * CDP hooks to use selenium-webdriver's `createCDPConnection('page')` API and
+ * listens directly on the underlying CDP WebSocket for `Page.screencastFrame`.
+ */
+export class ScreencastRecorder extends ScreencastRecorderBase<SeleniumDriverLike> {
+  #cdp: SeleniumCdpConnection | undefined
+  #cdpFrameListener: ((data: unknown) => void) | undefined
+  /** Resolved by `#makeCdpFrameHandler` on the first arriving frame. Lets
+   *  `tryStartCdp` await actual readiness instead of returning eagerly. */
+  #firstFrameResolve: (() => void) | undefined
+
+  protected override onPollingStarted(intervalMs: number): void {
+    log.info(
+      `✓ Screencast recording started (polling mode, ${intervalMs} ms interval)`
+    )
   }
 
-  async start(driver: SeleniumDriverLike): Promise<void> {
-    if (this.#isRecording) {
-      return
-    }
-    const cdpOk = await this.#startCdp(driver)
-    if (!cdpOk) {
-      await this.#startPolling(driver)
-    }
+  protected override onPollingStopped(frameCount: number): void {
+    log.info(`✓ Screencast stopped — ${frameCount} frame(s) collected`)
   }
 
-  async stop(): Promise<void> {
-    if (!this.#isRecording) {
-      return
-    }
-    if (this.#cdp) {
-      await this.#stopCdp()
-    } else if (this.#pollTimer !== undefined) {
-      this.#stopPolling()
-    }
-    this.#isRecording = false
+  protected override onUnavailable(err: unknown): void {
+    log.warn(
+      `Screencast unavailable (${errorMessage(err)}). Recording skipped.`
+    )
   }
 
-  setStartMarker() {
-    if (!this.#startMarkerSet) {
-      this.#startMarkerSet = true
-      this.#startIndex = this.#frames.length
+  protected override async takeScreenshot(): Promise<string | null> {
+    const driver = this.driver
+    const takeShot = getDriverOriginals().takeScreenshot
+    if (!driver || !takeShot) {
+      return null
     }
+    return takeShot(driver)
   }
 
-  get frames(): ScreencastFrame[] {
-    return this.#frames.slice(this.#startIndex)
-  }
-
-  get duration(): number {
-    const f = this.frames
-    if (f.length < 2) {
-      return 0
+  #makeCdpFrameHandler(cdp: SeleniumCdpConnection): (raw: unknown) => void {
+    return (raw: unknown) => {
+      let parsed: {
+        method?: string
+        params?: {
+          data?: string
+          sessionId?: number
+          metadata?: { timestamp?: number }
+        }
+      }
+      try {
+        parsed = JSON.parse(String(raw))
+      } catch {
+        return // non-JSON message — ignore
+      }
+      if (parsed.method !== 'Page.screencastFrame') {
+        return
+      }
+      const params = parsed.params ?? {}
+      this.pushCdpFrame(params.data ?? '', params.metadata?.timestamp)
+      // Anchor frame 0 at the first content-bearing frame to trim the
+      // leading about:blank dead-air. Approximate decoded size: base64
+      // expands by ~33%, so multiply by 0.75 for a rough decoded byte count.
+      if (!this.hasStartMarker) {
+        const decodedSize = Math.floor((params.data?.length ?? 0) * 0.75)
+        if (decodedSize >= BLANK_FRAME_THRESHOLD_BYTES) {
+          this.markStartAtLatest()
+        }
+      }
+      // Tell tryStartCdp that Chrome is actively pushing frames now. Cleared
+      // after firing so subsequent frames don't reach for a missing resolver.
+      if (this.#firstFrameResolve) {
+        this.#firstFrameResolve()
+        this.#firstFrameResolve = undefined
+      }
+      // Chrome throttles/stops sending frames if acks lag — keep this fire-
+      // and-forget but DON'T treat the return as a Promise. selenium-webdriver's
+      // CDPConnection.execute() returns `undefined` synchronously, so any
+      // .then/.catch on it throws a TypeError (was crashing test runs).
+      if (params.sessionId !== undefined) {
+        try {
+          cdp.execute('Page.screencastFrameAck', {
+            sessionId: params.sessionId
+          })
+        } catch (err) {
+          log.warn(`Screencast: failed to ack frame — ${errorMessage(err)}`)
+        }
+      }
     }
-    return f[f.length - 1].timestamp - f[0].timestamp
-  }
-
-  get isRecording(): boolean {
-    return this.#isRecording
   }
 
-  // ─── CDP path (Chromium) ─────────────────────────────────────────────────
-
-  async #startCdp(driver: SeleniumDriverLike): Promise<boolean> {
-    if (typeof driver.createCDPConnection !== 'function') {
+  protected override async tryStartCdp(): Promise<boolean> {
+    const driver = this.driver
+    if (!driver || typeof driver.createCDPConnection !== 'function') {
       return false
     }
     try {
-      const cdp = await driver.createCDPConnection('page')
+      // selenium-webdriver types createCDPConnection() as Promise<unknown>;
+      // the runtime shape is stable across patch releases and captured by
+      // SeleniumCdpConnection above.
+      const cdp = (await driver.createCDPConnection(
+        'page'
+      )) as SeleniumCdpConnection
       this.#cdp = cdp
-
-      // Listen for frames on the underlying WebSocket. Each CDP event arrives
-      // as a JSON message with method='Page.screencastFrame' and embedded
-      // params. We push to the frame buffer and ack so Chrome keeps streaming.
       const ws = cdp._wsConnection
       if (!ws || typeof ws.on !== 'function') {
         log.warn('CDP connection has no underlying WebSocket — falling back')
         return false
       }
-      const onMessage = (raw: any) => {
-        try {
-          const payload = JSON.parse(raw.toString())
-          if (payload.method !== 'Page.screencastFrame') {
-            return
-          }
-          const params = payload.params || {}
-          const ts =
-            params.metadata?.timestamp !== undefined &&
-            params.metadata?.timestamp !== null
-              ? Math.round(params.metadata.timestamp * 1000)
-              : Date.now()
-          this.#frames.push({ data: params.data, timestamp: ts })
-          // Anchor frame 0 at the first content-bearing frame to trim the
-          // leading about:blank dead-air.
-          if (!this.#startMarkerSet) {
-            const decodedSize = Math.floor((params.data?.length ?? 0) * 0.75)
-            if (decodedSize >= BLANK_FRAME_THRESHOLD_BYTES) {
-              this.#startIndex = Math.max(0, this.#frames.length - 1)
-              this.#startMarkerSet = true
-            }
-          }
-          if (params.sessionId !== undefined) {
-            cdp.execute('Page.screencastFrameAck', {
-              sessionId: params.sessionId
-            })
-          }
-        } catch {
-          // ignore non-JSON / non-screencast messages
-        }
-      }
+      const onMessage = this.#makeCdpFrameHandler(cdp)
       this.#cdpFrameListener = onMessage
       ws.on('message', onMessage)
-
+      // Arm the first-frame promise BEFORE firing Page.startScreencast so we
+      // don't miss the race where Chrome pushes its first frame before we
+      // start awaiting.
+      const firstFrame = new Promise<void>((resolve) => {
+        this.#firstFrameResolve = resolve
+      })
+      // cdp.execute is fire-and-forget (returns void) in selenium-webdriver
+      // — see the SeleniumCdpConnection comment above. Wait on the actual
+      // first-frame arrival instead: that's the unambiguous signal that
+      // Chrome is pushing. Timeout-capped so an unresponsive target falls
+      // through to the polling path rather than hanging the test.
       cdp.execute('Page.startScreencast', {
-        format: this.#options.captureFormat,
-        quality: this.#options.quality,
-        maxWidth: this.#options.maxWidth,
-        maxHeight: this.#options.maxHeight
+        format: this.options.captureFormat,
+        quality: this.options.quality,
+        maxWidth: this.options.maxWidth,
+        maxHeight: this.options.maxHeight
       })
-
-      this.#isRecording = true
+      let timeoutHandle: ReturnType<typeof setTimeout> | undefined
+      const timeout = new Promise<void>((resolve) => {
+        timeoutHandle = setTimeout(resolve, FIRST_FRAME_TIMEOUT_MS)
+      })
+      await Promise.race([firstFrame, timeout])
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle)
+      }
+      this.#firstFrameResolve = undefined
       log.info('✓ Screencast recording started (CDP mode)')
       return true
     } catch (err) {
       log.info(
-        `CDP screencast unavailable (${(err as Error).message}); will try polling`
+        `CDP screencast unavailable (${errorMessage(err)}); will try polling`
       )
       return false
     }
   }
 
-  async #stopCdp(): Promise<void> {
+  protected override async tryStopCdp(): Promise<void> {
     try {
-      this.#cdp.execute('Page.stopScreencast')
+      // cdp.execute is fire-and-forget (returns void) — see the
+      // SeleniumCdpConnection comment. The buffer is already populated
+      // synchronously by the frame handler; we just need to stop new frames
+      // arriving. Session/Target-closed throws here are expected during
+      // driver.quit teardown.
+      this.#cdp?.execute('Page.stopScreencast')
     } catch (err) {
-      log.warn(`Screencast: error stopping CDP — ${(err as Error).message}`)
+      const msg = errorMessage(err)
+      if (
+        msg.includes('Session closed') ||
+        msg.includes('Target closed') ||
+        msg.includes('no such session')
+      ) {
+        // expected during teardown
+      } else {
+        log.warn(`Screencast: error stopping CDP — ${msg}`)
+      }
     }
     try {
       if (this.#cdpFrameListener && this.#cdp?._wsConnection?.off) {
@@ -158,51 +199,15 @@ export class ScreencastRecorder {
     } catch {
       // detach best-effort
     }
-    log.info(`✓ Screencast stopped — ${this.#frames.length} frame(s) collected`)
+    // If start was called but the first frame never arrived (timeout path),
+    // the resolver is still set. Releasing it lets any pending Promise.race
+    // unblock the test teardown cleanly.
+    if (this.#firstFrameResolve) {
+      this.#firstFrameResolve()
+      this.#firstFrameResolve = undefined
+    }
+    log.info(`✓ Screencast stopped — ${this.buffer.length} frame(s) collected`)
     this.#cdp = undefined
     this.#cdpFrameListener = undefined
   }
-
-  // ─── Polling fallback (any browser) ──────────────────────────────────────
-
-  async #startPolling(driver: SeleniumDriverLike): Promise<void> {
-    const takeShot = getDriverOriginals().takeScreenshot
-    if (!takeShot) {
-      log.warn('Screencast unavailable — driver lacks takeScreenshot')
-      return
-    }
-    try {
-      const first = await takeShot(driver)
-      this.#frames.push({ data: first, timestamp: Date.now() })
-
-      const intervalMs = this.#options.pollIntervalMs
-      this.#pollTimer = setInterval(async () => {
-        try {
-          const data = await takeShot(driver)
-          this.#frames.push({ data, timestamp: Date.now() })
-        } catch {
-          this.#stopPolling()
-        }
-      }, intervalMs)
-
-      this.#isRecording = true
-      log.info(
-        `✓ Screencast recording started (polling mode, ${intervalMs} ms interval)`
-      )
-    } catch (err) {
-      log.warn(
-        `Screencast unavailable (${(err as Error).message}). Recording skipped.`
-      )
-    }
-  }
-
-  #stopPolling(): void {
-    if (this.#pollTimer !== undefined) {
-      clearInterval(this.#pollTimer)
-      this.#pollTimer = undefined
-      log.info(
-        `✓ Screencast stopped — ${this.#frames.length} frame(s) collected`
-      )
-    }
-  }
 }
diff --git a/packages/selenium-devtools/src/session-lifecycle.ts b/packages/selenium-devtools/src/session-lifecycle.ts
new file mode 100644
index 00000000..59c823e5
--- /dev/null
+++ b/packages/selenium-devtools/src/session-lifecycle.ts
@@ -0,0 +1,276 @@
+/**
+ * Session lifecycle for the Selenium plugin — driver bringup, per-driver
+ * capture wiring (metadata + screencast + BiDi), per-driver teardown, and
+ * end-of-run shutdown.
+ *
+ * Extracted from `index.ts` to keep that file under the file-size cap. The
+ * plugin passes itself as a `SessionLifecycleCtx` — a narrow interface
+ * exposing only the fields and methods these helpers need.
+ */
+
+import logger from '@wdio/logger'
+import {
+  errorMessage,
+  finalizeScreencast,
+  resolveAdapterOutputDir
+} from '@wdio/devtools-core'
+import { TIMING } from './constants.js'
+import { SessionCapturer } from './session.js'
+import { TestReporter } from './reporter.js'
+import { SuiteManager } from './helpers/suiteManager.js'
+import { ScreencastRecorder } from './screencast.js'
+import { buildDriverMetadata } from './helpers/driverMetadata.js'
+import { attachBidiHandlers, buildBidiSinks } from './bidi.js'
+import { gracefulShutdown } from './helpers/processHooks.js'
+import type { ScreencastOptions, SeleniumDriverLike } from './types.js'
+import type { TestManager } from './helpers/testManager.js'
+
+const log = logger('@wdio/selenium-devtools:session-lifecycle')
+
+export interface SessionLifecycleCtx {
+  readonly options: {
+    hostname: string
+    port: number
+    openUi: boolean
+    captureScreenshots: boolean
+    rerunCommand?: string
+  }
+  readonly screencastOptions: ScreencastOptions
+  readonly runner: string
+  readonly rerunTemplate: string | undefined
+  readonly launchCommand: string | undefined
+  readonly isReuse: boolean
+  readonly finalized: boolean
+
+  driver: SeleniumDriverLike | undefined
+  sessionCapturer: SessionCapturer | undefined
+  testReporter: TestReporter | undefined
+  suiteManager: SuiteManager | undefined
+  testManager: TestManager | undefined
+  screencast: ScreencastRecorder | undefined
+  sessionId: string | undefined
+  scriptInjected: boolean
+  testFilePath: string | undefined
+  keepAliveTimer: ReturnType<typeof setInterval> | undefined
+
+  setFinalized(v: boolean): void
+  ensureBackendStarted(): Promise<void>
+  flushPendingTestActions(): void
+  resetRetryTracker(): void
+  clearKeepAlive(): void
+}
+
+export async function onDriverCreated(
+  ctx: SessionLifecycleCtx,
+  driver: SeleniumDriverLike
+): Promise<void> {
+  const driverReadyTs = Date.now()
+  await ctx.ensureBackendStarted()
+
+  if (ctx.driver === driver) {
+    return
+  }
+
+  // Fresh-driver-per-test: re-target capturer; reuse suite/reporter/testManager.
+  if (ctx.driver || ctx.sessionCapturer) {
+    log.info('New driver detected — re-targeting capturer for next test')
+    ctx.driver = driver
+    ctx.sessionCapturer?.setDriver(driver)
+    await initPerDriverCapture(ctx, driver, driverReadyTs)
+    return
+  }
+
+  ctx.driver = driver
+  ctx.sessionCapturer = new SessionCapturer(
+    { hostname: ctx.options.hostname, port: ctx.options.port },
+    driver
+  )
+  // Dashboard closed AFTER tests finished → wind the runner down so the user
+  // doesn't have to Ctrl+C. Ignore during a live run: a momentary reconnect
+  // blip during tests must not abort them.
+  ctx.sessionCapturer.setClientDisconnectedHandler(() => {
+    if (ctx.finalized) {
+      void gracefulShutdown(
+        ctxPluginRef(ctx) as Parameters<typeof gracefulShutdown>[0],
+        0
+      )
+    }
+  })
+  await ctx.sessionCapturer.waitForConnection(TIMING.UI_CONNECTION_WAIT)
+
+  ctx.testReporter = new TestReporter((suitesData) => {
+    ctx.sessionCapturer?.sendUpstream('suites', suitesData)
+  })
+  ctx.suiteManager = new SuiteManager(ctx.testReporter)
+  ctx.flushPendingTestActions()
+
+  await initPerDriverCapture(ctx, driver, driverReadyTs)
+}
+
+// gracefulShutdown signature takes the whole plugin instance, not the ctx.
+// We pass the plugin through ctx's closure by attaching it under a symbol.
+const PLUGIN_REF = Symbol.for('@wdio/selenium-devtools/plugin-ref')
+export function setPluginRef(ctx: SessionLifecycleCtx, plugin: unknown): void {
+  ;(ctx as unknown as Record<symbol, unknown>)[PLUGIN_REF] = plugin
+}
+function ctxPluginRef(ctx: SessionLifecycleCtx): unknown {
+  return (ctx as unknown as Record<symbol, unknown>)[PLUGIN_REF]
+}
+
+async function initPerDriverCapture(
+  ctx: SessionLifecycleCtx,
+  driver: SeleniumDriverLike,
+  driverReadyTs: number
+): Promise<void> {
+  if (!ctx.sessionCapturer) {
+    return
+  }
+
+  const { sessionId, metadata } = await buildDriverMetadata({
+    driver,
+    driverReadyTs,
+    runner: ctx.runner,
+    rerunCommand: ctx.options.rerunCommand,
+    rerunTemplate: ctx.rerunTemplate,
+    launchCommand: ctx.launchCommand
+  })
+  ctx.sessionId = sessionId
+  if (metadata) {
+    ctx.sessionCapturer.sendUpstream('metadata', metadata)
+  }
+
+  // Parallel — serial attach misses frames on fast tests.
+  const screencastPromise = ctx.screencastOptions.enabled
+    ? (async () => {
+        try {
+          ctx.screencast = new ScreencastRecorder(ctx.screencastOptions)
+          await ctx.screencast.start(driver)
+        } catch (err) {
+          log.warn(`Screencast start failed: ${errorMessage(err)}`)
+        }
+      })()
+    : Promise.resolve()
+
+  const bidiPromise = (async () => {
+    try {
+      const sinks = buildBidiSinks(ctx.sessionCapturer!)
+      const ok = await attachBidiHandlers(driver, sinks)
+      if (ok) {
+        ctx.sessionCapturer!.bidiActive = true
+        log.info(
+          '✓ BiDi data flow active — script-injected console/network suppressed'
+        )
+      }
+    } catch (err) {
+      log.warn(`BiDi attach threw: ${errorMessage(err)}`)
+    }
+  })()
+
+  await Promise.all([screencastPromise, bidiPromise])
+}
+
+export async function onDriverEnd(ctx: SessionLifecycleCtx): Promise<void> {
+  if (ctx.screencast && ctx.sessionId) {
+    await finalizeScreencast({
+      recorder: ctx.screencast,
+      sessionId: ctx.sessionId,
+      filenamePrefix: 'selenium-video',
+      outputDir: resolveAdapterOutputDir({
+        testFilePath: ctx.testFilePath
+      }),
+      captureFormat: ctx.screencastOptions.captureFormat,
+      sendUpstream: (scope, data) =>
+        ctx.sessionCapturer?.sendUpstream(scope, data),
+      onLog: (level, message) => log[level](message)
+    })
+  }
+  ctx.driver = undefined
+  ctx.screencast = undefined
+  ctx.scriptInjected = false
+  ctx.sessionId = undefined
+  ctx.resetRetryTracker()
+}
+
+/** Final teardown. Idempotent. */
+export async function onSessionEnd(ctx: SessionLifecycleCtx): Promise<void> {
+  if (ctx.finalized) {
+    return
+  }
+  ctx.setFinalized(true)
+  const shutdownStart = Date.now()
+  try {
+    await onDriverEnd(ctx).catch(() => {})
+
+    // Don't call suiteManager.finalize() here — it sets `root.end`, which
+    // signals the dashboard's rerun tracker that the feature has finished
+    // and unblocks the new-run reset for the next scenario. onSessionEnd
+    // fires on each `driver.quit()` (per cucumber scenario), so finalizing
+    // the root here is premature. The true end-of-run finalize happens in
+    // finalizeTestRun (cucumber AfterAll). testReporter.updateSuites() is
+    // still useful to flush per-scenario state to the dashboard.
+    ctx.testManager?.finalizeSession()
+    ctx.testReporter?.updateSuites()
+
+    logSessionSummary(ctx)
+    ctx.sessionCapturer?.cleanup()
+
+    if (ctx.options.openUi && !ctx.isReuse) {
+      handleInteractivePath(ctx, shutdownStart)
+      return
+    }
+
+    // Non-interactive path (no dashboard or rerun child). Don't close the
+    // WS yet: this `onSessionEnd` is reached via the patched `driver.quit()`
+    // (cucumber's per-scenario `After` hook), but the runner's
+    // `onScenarioEnd` hook fires AFTER `After`. Closing the WS here would
+    // drop the final state update. Defer the close to `beforeExit`/`exit`,
+    // by which time every post-quit runner hook has flushed.
+    log.info(`🛑 Session ended (${Date.now() - shutdownStart}ms)`)
+  } catch (err) {
+    log.warn(`Cleanup error: ${errorMessage(err)}`)
+  }
+}
+
+function logSessionSummary(ctx: SessionLifecycleCtx): void {
+  const cmdCount = ctx.sessionCapturer?.commandsLog.length ?? 0
+  const consoleCount = ctx.sessionCapturer?.consoleLogs.length ?? 0
+  const networkCount = ctx.sessionCapturer?.networkRequests.length ?? 0
+  log.info(
+    `📊 Session summary — ${cmdCount} command(s), ${networkCount} network request(s), ${consoleCount} console log(s)`
+  )
+}
+
+function handleInteractivePath(
+  ctx: SessionLifecycleCtx,
+  shutdownStart: number
+): void {
+  log.info(
+    `💡 Tests complete — DevTools UI: http://${ctx.options.hostname}:${ctx.options.port}`
+  )
+  log.info('🔵 Close the DevTools browser window (or press Ctrl+C) to finish')
+  ctx.keepAliveTimer = setInterval(() => {}, 60 * 60 * 1000)
+  ctx.sessionCapturer?.setClientDisconnectedHandler(() => {
+    log.info('Dashboard closed — shutting down')
+    ctx.clearKeepAlive()
+    void completeShutdown(ctx, shutdownStart)
+  })
+}
+
+/**
+ * Final cleanup once the user has closed the dashboard browser. Drives the
+ * remaining teardown explicitly and `exit(0)`s — the natural event-loop
+ * drain doesn't fire reliably because the detached backend's own close
+ * races with the worker WS close.
+ */
+export async function completeShutdown(
+  ctx: SessionLifecycleCtx,
+  shutdownStart: number
+): Promise<void> {
+  try {
+    await ctx.sessionCapturer?.closeWebSocket()
+  } catch {
+    /* best-effort */
+  }
+  log.info(`🛑 Shutdown complete (${Date.now() - shutdownStart}ms)`)
+  process.exit(0)
+}
diff --git a/packages/selenium-devtools/src/session.ts b/packages/selenium-devtools/src/session.ts
index 5c989169..2312770e 100644
--- a/packages/selenium-devtools/src/session.ts
+++ b/packages/selenium-devtools/src/session.ts
@@ -1,47 +1,23 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { createRequire } from 'node:module'
 import logger from '@wdio/logger'
-import { WebSocket } from 'ws'
 import {
-  CONSOLE_METHODS,
-  LOG_SOURCES,
-  NAVIGATION_COMMANDS,
-  SPINNER_RE
-} from './constants.js'
-import {
-  stripAnsiCodes,
-  detectLogLevel,
+  SessionCapturerBase,
   createConsoleLogEntry,
-  chromeLogLevelToLogLevel
-} from './helpers/utils.js'
+  errorMessage,
+  loadInjectableScript,
+  mapChromeBrowserLogs,
+  pollUntilReady,
+  serializeError,
+  type LogSource
+} from '@wdio/devtools-core'
+import { WS_SCOPE } from '@wdio/devtools-shared'
+import { NAVIGATION_COMMANDS } from './constants.js'
 import { getDriverOriginals } from './driverPatcher.js'
-import type {
-  CommandLog,
-  ConsoleLog,
-  LogLevel,
-  SeleniumDriverLike
-} from './types.js'
+import type { CommandLog, LogLevel, SeleniumDriverLike } from './types.js'
 
-const require = createRequire(import.meta.url)
 const log = logger('@wdio/selenium-devtools:SessionCapturer')
 
-export class SessionCapturer {
-  #ws: WebSocket | undefined
-  #originalConsoleMethods: Record<
-    (typeof CONSOLE_METHODS)[number],
-    typeof console.log
-  >
-  #originalProcessMethods: {
-    stdoutWrite: typeof process.stdout.write
-    stderrWrite: typeof process.stderr.write
-  }
-  #isCapturingConsole = false
-  #isCapturingStream = false
-  #hasConnected = false
+export class SessionCapturer extends SessionCapturerBase {
   #driver: SeleniumDriverLike | undefined
-  #commandCounter = 0
-  #sentCommandIds = new Set<number>()
 
   // True once BiDi inspectors are attached — script-trace path skips streams.
   bidiActive = false
@@ -49,313 +25,103 @@ export class SessionCapturer {
   #clientConnectedWaiters: Array<() => void> = []
   #onClientDisconnected?: () => void
 
-  commandsLog: CommandLog[] = []
-  sources = new Map<string, string>()
-  consoleLogs: ConsoleLog[] = []
-  mutations: any[] = []
-  traceLogs: string[] = []
-  networkRequests: any[] = []
-  metadata?: any
-
   constructor(
     devtoolsOptions: { hostname?: string; port?: number } = {},
     driver?: SeleniumDriverLike
   ) {
-    const { port, hostname } = devtoolsOptions
+    super(devtoolsOptions)
     this.#driver = driver
-    if (hostname && port) {
-      this.#ws = new WebSocket(`ws://${hostname}:${port}/worker`)
-
-      this.#ws.on('open', () => {
-        this.#hasConnected = true
-        log.info('✓ Worker WebSocket connected to backend')
-      })
 
-      this.#ws.on('message', (raw: Buffer | string) => {
-        try {
-          const parsed = JSON.parse(raw.toString())
-          if (parsed?.scope === 'clientConnected') {
-            this.#clientConnected = true
-            const waiters = this.#clientConnectedWaiters
-            this.#clientConnectedWaiters = []
-            for (const w of waiters) {
-              try {
-                w()
-              } catch {
-                /* ignore */
-              }
-            }
-          } else if (parsed?.scope === 'clientDisconnected') {
-            this.#onClientDisconnected?.()
-          }
-        } catch {
-          // ignore non-JSON messages
-        }
-      })
-
-      this.#ws.on('error', (err: unknown) =>
-        log.error(
-          `Couldn't connect to devtools backend: ${(err as Error).message}`
-        )
-      )
-
-      this.#ws.on('close', () => {
-        log.info('Worker WebSocket disconnected')
-      })
-    }
-
-    this.#originalConsoleMethods = {
-      log: console.log,
-      info: console.info,
-      warn: console.warn,
-      error: console.error
-    }
-    this.#originalProcessMethods = {
-      stdoutWrite: process.stdout.write.bind(process.stdout),
-      stderrWrite: process.stderr.write.bind(process.stderr)
-    }
-
-    this.#patchConsole()
-    this.#interceptProcessStreams()
-  }
-
-  setDriver(driver: SeleniumDriverLike) {
-    this.#driver = driver
-  }
-
-  awaitClientConnected(): Promise<void> {
-    if (this.#clientConnected) {
-      return Promise.resolve()
-    }
-    return new Promise<void>((resolve) => {
-      this.#clientConnectedWaiters.push(resolve)
-    })
-  }
-
-  setClientDisconnectedHandler(fn: () => void) {
-    this.#onClientDisconnected = fn
-  }
-
-  // ---- console & terminal capture ------------------------------------------
-
-  #patchConsole() {
-    // Non-standard consoles (Jest CustomConsole, Vitest) reroute writes past
-    // our text filter and create a feedback loop — rely on stream interception.
+    // Skip console patching when running under Jest's CustomConsole / Vitest —
+    // those reroute writes through their own console, which causes our patched
+    // `console.*` to feed back through stream interception and loop. Stream
+    // interception alone is sufficient in that case.
     const protoName = Object.getPrototypeOf(console)?.constructor?.name
-    if (protoName && protoName !== 'Console') {
+    if (!protoName || protoName === 'Console') {
+      this.patchConsole()
+    } else {
       log.info(
         `Detected non-standard console (${protoName}) — skipping console patching, using stdout interception only`
       )
-      return
     }
-    CONSOLE_METHODS.forEach((method) => {
-      const originalMethod = this.#originalConsoleMethods[method]
-      console[method] = (...consoleArgs: any[]) => {
-        this.#isCapturingConsole = true
-        const result = originalMethod.apply(console, consoleArgs)
-        this.#isCapturingConsole = false
+    this.patchStreams()
+  }
 
-        const rawText = consoleArgs
-          .map((a) =>
-            typeof a === 'object' && a !== null ? JSON.stringify(a) : String(a)
-          )
-          .join(' ')
-        const cleanText = stripAnsiCodes(rawText).trim()
-        if (!cleanText) {
-          return result
-        }
-        if (this.#isInternalStreamLine(cleanText)) {
-          return result
-        }
+  protected override onWsOpen(): void {
+    log.info('✓ Worker WebSocket connected to backend')
+  }
 
-        const logEntry = createConsoleLogEntry(
-          method as LogLevel,
-          [cleanText],
-          LOG_SOURCES.TEST
-        )
-        this.consoleLogs.push(logEntry)
-        this.sendUpstream('consoleLogs', [logEntry])
-        return result
-      }
-    })
+  protected override onWsError(err: unknown): void {
+    log.error(`Couldn't connect to devtools backend: ${errorMessage(err)}`)
   }
 
-  // Drop lines that would feed back into sendUpstream and loop: pino JSON,
-  // [SESSION] markers, backend logs, Jest console.info framing.
-  #isInternalStreamLine(line: string): boolean {
-    const t = line.trim()
-    if (t.startsWith('{"') || t.startsWith('[SESSION]')) {
-      return true
-    }
-    if (t.includes('@wdio/devtools-backend')) {
-      return true
-    }
-    if (/^console\.(log|info|warn|error|debug|trace)$/.test(t)) {
-      return true
-    }
-    if (/^at\s.+:\d+:\d+\)?$/.test(t)) {
-      return true
-    }
-    return false
+  protected override onWsClose(): void {
+    log.info('Worker WebSocket disconnected')
   }
 
-  #interceptProcessStreams() {
-    const captureTerminalOutput = (outputData: string | Uint8Array) => {
-      if (this.#isCapturingStream) {
-        return
-      }
-      const outputText =
-        typeof outputData === 'string' ? outputData : outputData.toString()
-      if (!outputText?.trim()) {
-        return
-      }
-      this.#isCapturingStream = true
-      try {
-        const linesToCapture: string[] = []
-        for (const rawLine of outputText.split('\n')) {
-          const segments = rawLine.split('\r').filter((s) => s.trim())
-          const lastSegment = segments[segments.length - 1] ?? rawLine
-          const clean = stripAnsiCodes(lastSegment).trim()
-          if (
-            !clean ||
-            this.#isInternalStreamLine(clean) ||
-            SPINNER_RE.test(clean)
-          ) {
-            continue
-          }
-          linesToCapture.push(clean)
-        }
-        for (const clean of linesToCapture) {
-          const entry = createConsoleLogEntry(
-            detectLogLevel(clean),
-            [clean],
-            LOG_SOURCES.TERMINAL
-          )
-          this.consoleLogs.push(entry)
-          this.sendUpstream('consoleLogs', [entry])
+  protected override onWsMessage(msg: unknown): void {
+    const parsed = msg as { scope?: string } | null | undefined
+    if (parsed?.scope === WS_SCOPE.clientConnected) {
+      this.#clientConnected = true
+      const waiters = this.#clientConnectedWaiters
+      this.#clientConnectedWaiters = []
+      for (const w of waiters) {
+        try {
+          w()
+        } catch {
+          /* ignore */
         }
-      } finally {
-        this.#isCapturingStream = false
       }
+    } else if (parsed?.scope === WS_SCOPE.clientDisconnected) {
+      this.#onClientDisconnected?.()
     }
-
-    const interceptStreamWrite = (
-      stream: NodeJS.WriteStream,
-      original: (...args: any[]) => boolean
-    ) => {
-      const capturer = this
-      stream.write = function (chunk: any, ...rest: any[]): boolean {
-        const writeResult = original.call(stream, chunk, ...rest)
-        if (chunk && !capturer.#isCapturingConsole) {
-          captureTerminalOutput(chunk)
-        }
-        return writeResult
-      } as any
-    }
-
-    interceptStreamWrite(
-      process.stdout,
-      this.#originalProcessMethods.stdoutWrite
-    )
-    interceptStreamWrite(
-      process.stderr,
-      this.#originalProcessMethods.stderrWrite
-    )
-  }
-
-  #restoreConsole() {
-    CONSOLE_METHODS.forEach((method) => {
-      console[method] = this.#originalConsoleMethods[method]
-    })
   }
 
-  #restoreProcessStreams() {
-    process.stdout.write = this.#originalProcessMethods.stdoutWrite as any
-    process.stderr.write = this.#originalProcessMethods.stderrWrite as any
+  /**
+   * Push every captured line into the local `consoleLogs` array so it ends up
+   * in any future trace export, in addition to the live WS broadcast.
+   */
+  protected override onLine(
+    type: LogLevel,
+    args: string[],
+    source: LogSource
+  ): void {
+    const entry = createConsoleLogEntry(type, args, source)
+    this.consoleLogs.push(entry)
+    this.sendUpstream('consoleLogs', [entry])
   }
 
-  cleanup() {
-    this.#restoreConsole()
-    this.#restoreProcessStreams()
-  }
-
-  // ---- WebSocket plumbing --------------------------------------------------
-
-  get isReportingUpstream() {
-    return Boolean(this.#ws) && this.#ws?.readyState === WebSocket.OPEN
-  }
-
-  isConnected(): boolean {
-    return this.#ws?.readyState === WebSocket.OPEN
-  }
-
-  async waitForConnection(timeoutMs = 5000): Promise<boolean> {
-    if (!this.#ws) {
-      return false
-    }
-    if (this.#ws.readyState === WebSocket.OPEN) {
-      return true
-    }
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        log.warn(`WebSocket connection timeout after ${timeoutMs}ms`)
-        resolve(false)
-      }, timeoutMs)
-      this.#ws!.once('open', () => {
-        clearTimeout(timeout)
-        resolve(true)
-      })
-      this.#ws!.once('error', () => {
-        clearTimeout(timeout)
-        resolve(false)
-      })
-    })
+  setDriver(driver: SeleniumDriverLike) {
+    this.#driver = driver
   }
 
-  async closeWebSocket(): Promise<void> {
-    if (!this.#ws || this.#ws.readyState === WebSocket.CLOSED) {
-      return
+  awaitClientConnected(): Promise<void> {
+    if (this.#clientConnected) {
+      return Promise.resolve()
     }
     return new Promise<void>((resolve) => {
-      const timeout = setTimeout(resolve, 2000)
-      this.#ws!.once('close', () => {
-        clearTimeout(timeout)
-        resolve()
-      })
-      this.#ws!.close()
+      this.#clientConnectedWaiters.push(resolve)
     })
   }
 
-  sendUpstream(event: string, data: any) {
-    // Silent drops — logging here would loop back through stream interception.
-    if (!this.#ws || this.#ws.readyState !== WebSocket.OPEN) {
-      return
-    }
-    try {
-      this.#ws.send(JSON.stringify({ scope: event, data }))
-    } catch {
-      /* teardown */
-    }
+  setClientDisconnectedHandler(fn: () => void) {
+    this.#onClientDisconnected = fn
   }
 
-  // ---- command capture -----------------------------------------------------
+  // ---- WebSocket plumbing --------------------------------------------------
 
-  #serializeError(error: Error | undefined) {
-    return error
-      ? { name: error.name, message: error.message, stack: error.stack }
-      : undefined
-  }
+  // ---- command capture -----------------------------------------------------
 
   async captureCommand(
     command: string,
-    args: any[],
-    result: any,
+    args: unknown[],
+    result: unknown,
     error: Error | undefined,
     testUid?: string,
     callSource?: string,
     timestamp?: number
   ): Promise<CommandLog & { _id?: number }> {
-    const commandId = this.#commandCounter++
+    const commandId = this.commandCounter++
     // `id` is the stable lookup key — chained calls share a ms timestamp,
     // so timestamp-based matching rewrites the wrong entry on async updates.
     const entry: CommandLog & { _id?: number } = {
@@ -364,7 +130,7 @@ export class SessionCapturer {
       command,
       args,
       result,
-      error: this.#serializeError(error),
+      error: serializeError(error),
       timestamp: timestamp || Date.now(),
       callSource,
       testUid
@@ -373,53 +139,35 @@ export class SessionCapturer {
     return entry
   }
 
-  sendCommand(command: CommandLog & { _id?: number }) {
-    if (command._id !== undefined && !this.#sentCommandIds.has(command._id)) {
-      this.#sentCommandIds.add(command._id)
-      const toSend = { ...command }
-      delete toSend._id
-      this.sendUpstream('commands', [toSend])
-    }
-  }
-
-  sendReplaceCommand(
-    oldTimestamp: number,
-    command: CommandLog & { _id?: number }
-  ) {
-    const toSend = { ...command }
-    delete toSend._id
-    this.sendUpstream('replaceCommand', { oldTimestamp, command: toSend })
-  }
-
   /** Update an existing entry in place (matched by `_id`) for retry coalesce. */
   replaceCommand(
     oldId: number,
     command: string,
-    args: any[],
-    result: any,
+    args: unknown[],
+    result: unknown,
     error: Error | undefined,
     testUid?: string,
     callSource?: string,
     timestamp?: number
   ): { entry: CommandLog & { _id?: number }; oldTimestamp: number } {
     const idx = this.commandsLog.findIndex(
-      (c: any) => (c as CommandLog & { _id?: number })._id === oldId
+      (c) => (c as CommandLog & { _id?: number })._id === oldId
     )
     const oldTimestamp =
-      idx !== -1 ? ((this.commandsLog[idx] as any).timestamp ?? 0) : 0
+      idx !== -1 ? (this.commandsLog[idx]?.timestamp ?? 0) : 0
     if (idx === -1) {
-      const fresh = {
-        _id: this.#commandCounter++,
-        id: undefined as unknown as number,
+      const newId = this.commandCounter++
+      const fresh: CommandLog & { _id?: number; id?: number } = {
+        _id: newId,
+        id: newId,
         command,
         args,
         result,
-        error: this.#serializeError(error),
+        error: serializeError(error),
         timestamp: timestamp || Date.now(),
         callSource,
         testUid
-      } as CommandLog & { _id?: number }
-      ;(fresh as any).id = fresh._id
+      }
       this.commandsLog.push(fresh)
       return { entry: fresh, oldTimestamp: 0 }
     }
@@ -427,10 +175,10 @@ export class SessionCapturer {
       _id?: number
       id?: number
     }
-    previous.command = command as any
+    previous.command = command
     previous.args = args
     previous.result = result
-    previous.error = this.#serializeError(error) as any
+    previous.error = serializeError(error)
     previous.timestamp = timestamp || Date.now()
     previous.callSource = callSource
     previous.testUid = testUid
@@ -449,26 +197,15 @@ export class SessionCapturer {
       const data = await fn(driver)
       return data || null
     } catch (err) {
-      log.warn(`[screenshot] Failed: ${(err as Error).message}`)
+      log.warn(`[screenshot] Failed: ${errorMessage(err)}`)
       return null
     }
   }
 
   // ---- source files --------------------------------------------------------
 
-  async captureSource(filePath: string) {
-    if (this.sources.has(filePath)) {
-      return
-    }
-    try {
-      const source = await fs.readFile(filePath, 'utf-8')
-      this.sources.set(filePath, source.toString())
-      this.sendUpstream('sources', { [filePath]: source.toString() })
-    } catch (err) {
-      log.warn(
-        `Failed to read source file ${filePath}: ${(err as Error).message}`
-      )
-    }
+  protected override onSourceReadError(filePath: string, err: unknown): void {
+    log.warn(`Failed to read source file ${filePath}: ${errorMessage(err)}`)
   }
 
   // ---- browser-side trace (script injection) -------------------------------
@@ -480,34 +217,27 @@ export class SessionCapturer {
       return
     }
     try {
-      const scriptPath = require.resolve('@wdio/devtools-script')
-      const scriptDir = path.dirname(scriptPath)
-      const preloadScriptPath = path.join(scriptDir, 'script.js')
-      let scriptContent = await fs.readFile(preloadScriptPath, 'utf-8')
-      // Wrap top-level await so it can run inside a <script> body.
-      scriptContent = `(async function() { ${scriptContent} })()`
-
+      const scriptContent = await loadInjectableScript()
       await exec(
         driver,
         "var s=document.createElement('script');s.textContent=arguments[0];document.head.appendChild(s);return true;",
         scriptContent
       )
-
-      for (let i = 0; i < 5; i++) {
-        await new Promise((r) => setTimeout(r, 200))
-        const ready = await exec(
+      const ready = await pollUntilReady(async () => {
+        const r = await exec(
           driver,
           'return typeof window.wdioTraceCollector !== "undefined";'
         )
-        if (ready === true) {
-          log.info('✓ Script injected and collector ready')
-          return
-        }
+        return r === true
+      })
+      if (ready) {
+        log.info('✓ Script injected and collector ready')
+      } else {
+        log.warn('Script injection may have failed — collector not found')
       }
-      log.warn('Script injection may have failed — collector not found')
     } catch (err) {
       // Driver torn down between navigation and deferred trace work.
-      const msg = (err as Error).message ?? ''
+      const msg = errorMessage(err)
       if (
         msg.includes('ECONNREFUSED') ||
         msg.includes('no such session') ||
@@ -540,43 +270,12 @@ export class SessionCapturer {
       if (!traceData) {
         return
       }
-      const { mutations, traceLogs, consoleLogs, networkRequests, metadata } =
-        traceData
-
-      if (metadata) {
-        this.metadata = { ...this.metadata, ...metadata }
-        this.sendUpstream('metadata', this.metadata)
-      }
-      if (
-        !this.bidiActive &&
-        Array.isArray(consoleLogs) &&
-        consoleLogs.length > 0
-      ) {
-        const tagged = consoleLogs.map((e: any) => ({
-          ...e,
-          source: LOG_SOURCES.BROWSER
-        }))
-        this.consoleLogs.push(...tagged)
-        this.sendUpstream('consoleLogs', tagged)
-      }
-      if (
-        !this.bidiActive &&
-        Array.isArray(networkRequests) &&
-        networkRequests.length > 0
-      ) {
-        this.networkRequests.push(...networkRequests)
-        this.sendUpstream('networkRequests', networkRequests)
-      }
-      if (Array.isArray(mutations) && mutations.length > 0) {
-        this.mutations.push(...mutations)
-        this.sendUpstream('mutations', mutations)
-      }
-      if (Array.isArray(traceLogs) && traceLogs.length > 0) {
-        this.traceLogs.push(...traceLogs)
-        this.sendUpstream('logs', traceLogs)
-      }
+      this.processTracePayload(traceData as Record<string, unknown>, {
+        skipConsoleLogs: this.bidiActive,
+        skipNetworkRequests: this.bidiActive
+      })
     } catch (err) {
-      const msg = (err as Error).message ?? ''
+      const msg = errorMessage(err)
       if (
         msg.includes('ECONNREFUSED') ||
         msg.includes('no such session') ||
@@ -598,18 +297,23 @@ export class SessionCapturer {
       return
     }
     try {
-      const entries = await manage(driver).logs().get('browser')
+      // selenium-webdriver's Options.logs() chain is untyped at our boundary;
+      // narrow the result locally rather than typing the whole chain.
+      type RawBrowserLog = {
+        level: unknown
+        message: string
+        timestamp: number
+      }
+      const logs = (
+        manage(driver) as {
+          logs: () => { get: (t: string) => Promise<RawBrowserLog[]> }
+        }
+      ).logs()
+      const entries = await logs.get('browser')
       if (!Array.isArray(entries) || entries.length === 0) {
         return
       }
-      const tagged: ConsoleLog[] = entries.map(
-        (entry: { level: any; message: string; timestamp: number }) => ({
-          timestamp: entry.timestamp,
-          type: chromeLogLevelToLogLevel(entry.level),
-          args: [entry.message],
-          source: LOG_SOURCES.BROWSER
-        })
-      )
+      const tagged = mapChromeBrowserLogs(entries)
       this.consoleLogs.push(...tagged)
       this.sendUpstream('consoleLogs', tagged)
     } catch {
diff --git a/packages/selenium-devtools/src/test-management.ts b/packages/selenium-devtools/src/test-management.ts
new file mode 100644
index 00000000..842c0654
--- /dev/null
+++ b/packages/selenium-devtools/src/test-management.ts
@@ -0,0 +1,247 @@
+/**
+ * Test management for the Selenium plugin — startTest/endTest,
+ * startScenario/endScenario, lazy root-suite + test-manager creation, and the
+ * pending-action buffer that holds calls made before the driver is built.
+ *
+ * Extracted from `index.ts` to keep that file under the file-size cap. The
+ * plugin passes itself as a `TestManagementCtx` — a narrow interface
+ * exposing only the fields and methods these helpers need.
+ */
+
+import logger from '@wdio/logger'
+import { TestManager } from './helpers/testManager.js'
+import { getCallSourceFromStack } from './helpers/utils.js'
+import { DEFAULTS } from './constants.js'
+import type { SessionCapturer } from './session.js'
+import type { TestReporter } from './reporter.js'
+import type { SuiteManager } from './helpers/suiteManager.js'
+import type { TestStats } from './types.js'
+import type { RetryTracker } from '@wdio/devtools-core'
+
+const log = logger('@wdio/selenium-devtools:test-management')
+
+export type PendingTestAction =
+  | {
+      kind: 'start'
+      name: string
+      meta: { file?: string; callSource?: string }
+      suiteName?: string
+      suiteCallSource?: string
+    }
+  | { kind: 'end'; state: TestStats['state'] }
+
+export interface PendingScenario {
+  name: string
+  file?: string
+  callSource?: string
+  featureName?: string
+  featureCallSource?: string
+}
+
+export interface TestManagementCtx {
+  readonly retryTracker: RetryTracker
+  readonly testReporter: TestReporter | undefined
+  readonly sessionCapturer: SessionCapturer | undefined
+  suiteManager: SuiteManager | undefined
+  testManager: TestManager | undefined
+  testFilePath: string | undefined
+  pendingTestActions: PendingTestAction[]
+  pendingScenario: PendingScenario | null
+}
+
+export interface StartTestMeta {
+  file?: string
+  callSource?: string
+  suiteName?: string
+  suiteCallSource?: string
+}
+
+export interface StartScenarioMeta {
+  file?: string
+  callSource?: string
+  featureName?: string
+  featureCallSource?: string
+}
+
+export function startTest(
+  ctx: TestManagementCtx,
+  name: string,
+  meta: StartTestMeta = {}
+): void {
+  if (!ctx.testFilePath && meta.file) {
+    ctx.testFilePath = meta.file
+  }
+  const stackInfo = getCallSourceFromStack()
+  const file = meta.file || stackInfo.filePath
+  const callSource = meta.callSource || stackInfo.callSource
+  const resolvedMeta: { file?: string; callSource?: string } = {}
+  if (file) {
+    resolvedMeta.file = file
+  }
+  if (callSource && callSource !== 'unknown:0') {
+    resolvedMeta.callSource = callSource
+  }
+  if (!ctx.suiteManager || !ctx.testReporter) {
+    ctx.pendingTestActions.push({
+      kind: 'start',
+      name,
+      meta: resolvedMeta,
+      suiteName: meta.suiteName,
+      suiteCallSource: meta.suiteCallSource
+    })
+    return
+  }
+
+  ensureSuiteAndTestManager(
+    ctx,
+    meta.suiteName ?? DEFAULTS.SESSION_TITLE,
+    meta.suiteCallSource
+  )
+  if (meta.suiteName || meta.suiteCallSource) {
+    ctx.suiteManager.setRootSuiteTitle(
+      meta.suiteName ?? '',
+      meta.suiteCallSource
+    )
+  }
+  ctx.testManager!.startMarkedTest(name, resolvedMeta)
+  ctx.retryTracker.reset()
+  if (file) {
+    ctx.sessionCapturer?.captureSource(file).catch(() => {})
+  }
+}
+
+export function endTest(
+  ctx: TestManagementCtx,
+  state: TestStats['state'] = 'passed'
+): void {
+  if (!ctx.testManager) {
+    ctx.pendingTestActions.push({ kind: 'end', state })
+    return
+  }
+  ctx.testManager.endCurrent(state)
+}
+
+/** Cucumber scenario boundary — opens a sub-suite under the feature root. */
+export function startScenario(
+  ctx: TestManagementCtx,
+  name: string,
+  meta: StartScenarioMeta = {}
+): void {
+  if (!ctx.suiteManager || !ctx.testReporter) {
+    ctx.pendingScenario = { name, ...meta }
+    return
+  }
+  ensureSuiteAndTestManager(
+    ctx,
+    meta.featureName ?? DEFAULTS.SESSION_TITLE,
+    meta.featureCallSource
+  )
+  if (meta.featureName || meta.featureCallSource) {
+    ctx.suiteManager.setRootSuiteTitle(
+      meta.featureName ?? '',
+      meta.featureCallSource
+    )
+  }
+  // Stamp the .feature path as `featureFile` on the root and the scenario
+  // sub-suite. The root suite's `file` stays at process.cwd() (changing it
+  // mid-run would shift the stable UID and orphan accumulated state on the
+  // dashboard). The dashboard's rerun payload forwards `featureFile` to the
+  // backend, which strips `--name` and uses it as a positional arg for
+  // feature-level reruns.
+  const root = ctx.suiteManager.getRootSuite()
+  if (root && meta.file && root.featureFile !== meta.file) {
+    root.featureFile = meta.file
+    ctx.testReporter.updateSuites()
+  }
+  const file = meta.file ?? root?.file ?? process.cwd()
+  ctx.suiteManager.startScenarioSuite(name, file, meta.callSource, meta.file)
+  ctx.retryTracker.reset()
+  if (meta.file) {
+    ctx.sessionCapturer?.captureSource(meta.file).catch(() => {})
+  }
+}
+
+export function endScenario(
+  ctx: TestManagementCtx,
+  state: TestStats['state'] = 'passed'
+): void {
+  if (!ctx.suiteManager) {
+    return
+  }
+  ctx.testManager?.endCurrent(state)
+  ctx.suiteManager.endScenarioSuite(state)
+  ctx.retryTracker.reset()
+}
+
+/** Lazy-create rootSuite + testManager so they take the real describe title. */
+export function ensureSuiteAndTestManager(
+  ctx: TestManagementCtx,
+  title: string,
+  callSource?: string
+): void {
+  if (!ctx.suiteManager || !ctx.testReporter) {
+    return
+  }
+  let rootSuite = ctx.suiteManager.getRootSuite()
+  const created = !rootSuite
+  if (!rootSuite) {
+    const effectiveTitle = ctx.pendingScenario?.featureName ?? title
+    rootSuite = ctx.suiteManager.getOrCreateRootSuite(
+      process.cwd(),
+      effectiveTitle
+    )
+    const cs = ctx.pendingScenario?.featureCallSource ?? callSource
+    if (cs) {
+      rootSuite.callSource = cs
+    }
+  }
+  if (!ctx.testManager) {
+    ctx.testManager = new TestManager(
+      rootSuite,
+      ctx.testReporter,
+      ctx.suiteManager
+    )
+  }
+  if (created && ctx.pendingScenario) {
+    const p = ctx.pendingScenario
+    ctx.pendingScenario = null
+    const file = p.file ?? rootSuite.file
+    ctx.suiteManager.startScenarioSuite(p.name, file, p.callSource)
+    if (p.file) {
+      ctx.sessionCapturer?.captureSource(p.file).catch(() => {})
+    }
+  }
+}
+
+/** Apply any startTest/endTest calls buffered before testManager existed. */
+export function flushPendingTestActions(ctx: TestManagementCtx): void {
+  if (ctx.pendingTestActions.length === 0) {
+    return
+  }
+  for (const action of ctx.pendingTestActions) {
+    if (action.kind === 'start') {
+      ensureSuiteAndTestManager(
+        ctx,
+        action.suiteName ?? DEFAULTS.SESSION_TITLE,
+        action.suiteCallSource
+      )
+      if (!ctx.testManager) {
+        continue
+      }
+      if (action.suiteName || action.suiteCallSource) {
+        ctx.suiteManager?.setRootSuiteTitle(
+          action.suiteName ?? '',
+          action.suiteCallSource
+        )
+      }
+      ctx.testManager.startMarkedTest(action.name, action.meta)
+      if (action.meta.file) {
+        ctx.sessionCapturer?.captureSource(action.meta.file).catch(() => {})
+      }
+    } else {
+      ctx.testManager?.endCurrent(action.state)
+    }
+  }
+  ctx.pendingTestActions = []
+  void log
+}
diff --git a/packages/selenium-devtools/src/types.ts b/packages/selenium-devtools/src/types.ts
index cc55695b..d239a308 100644
--- a/packages/selenium-devtools/src/types.ts
+++ b/packages/selenium-devtools/src/types.ts
@@ -1,3 +1,19 @@
+// Selenium-specific types live here. Cross-package types come from @wdio/devtools-shared.
+
+export {
+  TraceType,
+  type CommandLog,
+  type ConsoleLog,
+  type DocumentInfo,
+  type LogLevel,
+  type Metadata,
+  type NetworkRequest,
+  type PerformanceData,
+  type SuiteStats,
+  type TestStats,
+  type TestStatus
+} from '@wdio/devtools-shared'
+
 export interface DevToolsOptions {
   port?: number
   hostname?: string
@@ -17,150 +33,10 @@ export interface DevToolsOptions {
   headless?: boolean
 }
 
-export interface ScreencastFrame {
-  /** Base64-encoded image data — JPEG/PNG. */
-  data: string
-  /** Unix timestamp in milliseconds. */
-  timestamp: number
-}
-
-export interface ScreencastOptions {
-  /** Enable screencast recording for this session (default: false). */
-  enabled?: boolean
-  /** Image format for individual frames (default: 'jpeg'). Chromium-only. */
-  captureFormat?: 'jpeg' | 'png'
-  /** JPEG quality 0–100 (default: 70). Chromium-only. */
-  quality?: number
-  /** Max frame width in px Chrome sends over CDP (default: 1280). Chromium-only. */
-  maxWidth?: number
-  /** Max frame height in px Chrome sends over CDP (default: 720). Chromium-only. */
-  maxHeight?: number
-  /**
-   * Polling interval for non-Chromium fallback (default: 200 ms).
-   * Used when CDP isn't available — calls driver.takeScreenshot() at this rate.
-   */
-  pollIntervalMs?: number
-}
-
-export interface CommandLog {
-  command: string
-  args: any[]
-  result?: any
-  error?: { name: string; message: string; stack?: string }
-  timestamp: number
-  callSource?: string
-  screenshot?: string
-  testUid?: string
-  performance?: PerformanceData
-  cookies?: string
-  documentInfo?: DocumentInfo
-  // Stable id used for replaceCommand reconciliation (timestamps collide on
-  // chained calls within the same millisecond).
-  id?: number
-}
-
-export interface PerformanceData {
-  navigation?: {
-    url: string
-    timing: {
-      loadTime?: number
-      domReady?: number
-      responseTime?: number
-      dnsLookup?: number
-      tcpConnection?: number
-      serverResponse?: number
-    }
-  }
-  resources?: Array<{
-    url: string
-    duration: number
-    size: number
-    type: string
-    startTime: number
-    responseEnd: number
-  }>
-}
-
-export interface DocumentInfo {
-  url: string
-  title: string
-  headers: { userAgent: string; language: string; platform: string }
-  documentInfo: { readyState: string; referrer: string; characterSet: string }
-}
-
-export type LogLevel = 'trace' | 'debug' | 'log' | 'info' | 'warn' | 'error'
-
-export interface ConsoleLog {
-  timestamp: number
-  type: LogLevel
-  args: any[]
-  source: string
-}
-
-export interface TestStats {
-  uid: string
-  cid: string
-  title: string
-  fullTitle: string
-  parent: string
-  state: 'passed' | 'failed' | 'skipped' | 'pending' | 'running'
-  start: Date
-  end: Date | null
-  type: 'test'
-  file: string
-  retries: number
-  _duration: number
-  error?: { name: string; message: string; stack?: string }
-  hooks?: any[]
-  callSource?: string
-}
-
-export interface SuiteStats {
-  uid: string
-  cid: string
-  title: string
-  fullTitle: string
-  type: 'suite'
-  file: string
-  start: Date
-  state?: 'pending' | 'running' | 'passed' | 'failed' | 'skipped'
-  end?: Date | null
-  tests: (string | TestStats)[]
-  suites: SuiteStats[]
-  hooks: any[]
-  _duration: number
-  parent?: string
-  callSource?: string
-}
-
-export enum TraceType {
-  Testrunner = 'testrunner'
-}
-
-export interface Metadata {
-  type: TraceType
-  url?: string
-  options?: any
-  capabilities?: any
-  viewport?: any
-}
-
-export interface NetworkRequest {
-  id: string
-  url: string
-  method: string
-  status?: number
-  statusText?: string
-  timestamp: number
-  startTime: number
-  endTime?: number
-  time?: number
-  type: string
-  requestHeaders?: Record<string, string>
-  responseHeaders?: Record<string, string>
-  size?: number
-  error?: string
-}
+// ScreencastFrame, ScreencastOptions hoisted to @wdio/devtools-shared; re-exported
+// here for backwards compatibility with existing selenium-internal imports.
+import type { ScreencastOptions } from '@wdio/devtools-shared'
+export type { ScreencastFrame, ScreencastOptions } from '@wdio/devtools-shared'
 
 /**
  * Minimal shape of a selenium-webdriver `WebDriver` instance that the plugin
@@ -169,26 +45,31 @@ export interface NetworkRequest {
  * minor versions and we only touch a small surface.
  */
 export interface SeleniumDriverLike {
-  executeScript: (script: string | Function, ...args: any[]) => Promise<any>
+  executeScript: (
+    script: string | Function,
+    ...args: unknown[]
+  ) => Promise<unknown>
   takeScreenshot?: () => Promise<string>
   getSession?: () => Promise<{ getId: () => string }>
-  getCapabilities?: () => Promise<any>
-  manage?: () => any
+  getCapabilities?: () => Promise<unknown>
+  manage?: () => unknown
   quit?: () => Promise<void>
   close?: () => Promise<void>
-  [key: string]: any
+  /** Selenium 4 helper used by the screencast recorder. */
+  createCDPConnection?: (target: string) => Promise<unknown>
+  [key: string]: unknown
 }
 
 // ─── driverPatcher ──────────────────────────────────────────────────────────
 
 export interface CapturedCommand {
   command: string
-  args: any[]
+  args: unknown[]
   // Sanitized result safe to JSON.stringify over the wire.
-  result: any
+  result: unknown
   // Raw selenium result kept by reference for in-process enrichment — must
   // NOT be sent upstream (contains non-serialisable WebElement state).
-  rawResult?: any
+  rawResult?: unknown
   error: Error | undefined
   callSource: string | undefined
   timestamp: number
@@ -196,7 +77,7 @@ export interface CapturedCommand {
 }
 
 export interface DriverPatcherHooks {
-  onBeforeBuild?: (builder: any) => void
+  onBeforeBuild?: (builder: unknown) => void
   onDriverCreated: (driver: SeleniumDriverLike) => void | Promise<void>
   onCommand: (cmd: CapturedCommand) => void
   // Awaited before delegating to the original `driver.quit()` so async
@@ -215,19 +96,21 @@ export interface DriverOriginals {
   executeScript?: (
     driver: SeleniumDriverLike,
     script: string,
-    ...args: any[]
-  ) => Promise<any>
-  manage?: (driver: SeleniumDriverLike) => any
+    ...args: unknown[]
+  ) => Promise<unknown>
+  manage?: (driver: SeleniumDriverLike) => unknown
 }
 
 // Unwrapped WebElement methods for internal enrichment paths.
 export interface ElementOriginals {
-  getText?: (element: any) => Promise<string>
-  getTagName?: (element: any) => Promise<string>
+  getText?: (element: unknown) => Promise<string>
+  getTagName?: (element: unknown) => Promise<string>
 }
 
 // ─── bidi ───────────────────────────────────────────────────────────────────
 
+import type { ConsoleLog, NetworkRequest } from '@wdio/devtools-shared'
+
 export interface BidiHandlerSinks {
   pushConsoleLog: (entry: ConsoleLog) => void
   pushNetworkRequest: (entry: NetworkRequest) => void
diff --git a/packages/selenium-devtools/tests/driverPatcher.test.ts b/packages/selenium-devtools/tests/driverPatcher.test.ts
new file mode 100644
index 00000000..3ad7b38a
--- /dev/null
+++ b/packages/selenium-devtools/tests/driverPatcher.test.ts
@@ -0,0 +1,124 @@
+import { describe, it, expect } from 'vitest'
+import {
+  isWebElementLike,
+  safeSerialize,
+  webElementSummary,
+  getDriverOriginals,
+  getElementOriginals
+} from '../src/driverPatcher.js'
+
+describe('isWebElementLike', () => {
+  it('detects an object with getId + click as a WebElement', () => {
+    const el = { getId: () => 'a', click: () => {} }
+    expect(isWebElementLike(el)).toBe(true)
+  })
+
+  it('rejects plain objects without click/getId', () => {
+    expect(isWebElementLike({ foo: 'bar' })).toBe(false)
+    expect(isWebElementLike({ getId: () => 'a' })).toBe(false)
+    expect(isWebElementLike({ click: () => {} })).toBe(false)
+  })
+
+  it('rejects primitives and null/undefined', () => {
+    // The function uses && chaining so it returns the raw falsy value for
+    // null/undefined inputs — assert falsy rather than strict false.
+    expect(isWebElementLike(null)).toBeFalsy()
+    expect(isWebElementLike(undefined)).toBeFalsy()
+    expect(isWebElementLike(42)).toBeFalsy()
+    expect(isWebElementLike('not-an-element')).toBeFalsy()
+    expect(isWebElementLike(true)).toBeFalsy()
+  })
+})
+
+describe('webElementSummary', () => {
+  it('uses the resolved id_ value when present', () => {
+    expect(webElementSummary({ id_: { _value: 'elem-1' } })).toBe(
+      '<WebElement id=elem-1>'
+    )
+    expect(webElementSummary({ id_: { value: 'elem-2' } })).toBe(
+      '<WebElement id=elem-2>'
+    )
+  })
+
+  it('falls back to a bare summary when id is not resolved', () => {
+    expect(webElementSummary({})).toBe('<WebElement>')
+    expect(webElementSummary({ id_: undefined })).toBe('<WebElement>')
+    expect(webElementSummary(null)).toBe('<WebElement>')
+  })
+})
+
+describe('safeSerialize', () => {
+  it('passes primitives through unchanged', () => {
+    expect(safeSerialize(42)).toBe(42)
+    expect(safeSerialize('hi')).toBe('hi')
+    expect(safeSerialize(true)).toBe(true)
+  })
+
+  it('preserves null and undefined', () => {
+    expect(safeSerialize(null)).toBe(null)
+    expect(safeSerialize(undefined)).toBe(undefined)
+  })
+
+  it('summarizes functions as [Function]', () => {
+    expect(safeSerialize(() => 1)).toBe('[Function]')
+    expect(safeSerialize(function named() {})).toBe('[Function]')
+  })
+
+  it('summarizes single WebElement-like values', () => {
+    const el = { getId: () => 'a', click: () => {}, id_: { _value: 'x' } }
+    expect(safeSerialize(el)).toBe('<WebElement id=x>')
+  })
+
+  it('summarizes a homogeneous WebElement[] as <WebElement[]> (count: N)', () => {
+    const el = { getId: () => 'a', click: () => {} }
+    expect(safeSerialize([el, el, el])).toBe('<WebElement[]> (count: 3)')
+  })
+
+  it('formats a Selenium "By" locator as "By.<using>(<value>)"', () => {
+    expect(safeSerialize({ using: 'css selector', value: '.btn' })).toBe(
+      'By.css selector(".btn")'
+    )
+    expect(safeSerialize({ using: 'id', value: 'main' })).toBe('By.id("main")')
+  })
+
+  it('recursively serializes plain arrays', () => {
+    expect(safeSerialize([1, 'a', null, undefined])).toEqual([
+      1,
+      'a',
+      null,
+      undefined
+    ])
+  })
+
+  it('mixed array with one non-element falls back to per-item serialize', () => {
+    const el = { getId: () => 'a', click: () => {} }
+    expect(safeSerialize([el, 'plain'])).toEqual(['<WebElement>', 'plain'])
+  })
+
+  it('JSON-roundtrips plain objects', () => {
+    expect(safeSerialize({ a: 1, b: 'two', c: [true] })).toEqual({
+      a: 1,
+      b: 'two',
+      c: [true]
+    })
+  })
+
+  it('falls back to String() for objects that cannot serialize (cyclic)', () => {
+    const cyclic: any = { name: 'me' }
+    cyclic.self = cyclic
+    const out = safeSerialize(cyclic)
+    expect(typeof out).toBe('string')
+    expect(out).toContain('[object')
+  })
+})
+
+describe('getDriverOriginals / getElementOriginals', () => {
+  it('return objects (the in-memory pristine-prototype stash)', () => {
+    const d = getDriverOriginals()
+    const e = getElementOriginals()
+    expect(typeof d).toBe('object')
+    expect(typeof e).toBe('object')
+    expect(d).not.toBeNull()
+    expect(e).not.toBeNull()
+  })
+})
diff --git a/packages/selenium-devtools/tests/index.test.ts b/packages/selenium-devtools/tests/index.test.ts
index da255cff..93bcc6f2 100644
--- a/packages/selenium-devtools/tests/index.test.ts
+++ b/packages/selenium-devtools/tests/index.test.ts
@@ -291,7 +291,7 @@ describe('SessionCapturer', () => {
       'log'
     ])
     expect(captured.every((e) => e.source === LOG_SOURCES.TEST)).toBe(true)
-    expect(captured[4].args[0]).toBe('payload {"id":1,"nested":{"x":2}}')
+    expect(captured[4].args).toEqual(['payload', '{"id":1,"nested":{"x":2}}'])
 
     capturer.cleanup()
     expect(console.log).toBe(originalLog)
diff --git a/packages/selenium-devtools/tests/session.test.ts b/packages/selenium-devtools/tests/session.test.ts
new file mode 100644
index 00000000..a780adf4
--- /dev/null
+++ b/packages/selenium-devtools/tests/session.test.ts
@@ -0,0 +1,303 @@
+import { afterEach, describe, it, expect, vi, beforeEach } from 'vitest'
+import { loadInjectableScript } from '@wdio/devtools-core'
+import { SessionCapturer } from '../src/session.js'
+import { getDriverOriginals } from '../src/driverPatcher.js'
+
+// `@wdio/devtools-script` is a workspace sibling that may not be built
+// yet in a CI test job that runs before the script-package build step.
+// injectScript() calls loadInjectableScript() (resolve + readFile), so
+// the probe attempts the same operation — checking only resolution
+// against the TEST file's node_modules tree historically drifted from
+// what the runtime actually does inside @wdio/devtools-core.
+const scriptPackageAvailable = await loadInjectableScript()
+  .then(() => true)
+  .catch(() => false)
+
+function makeCapturer(driver?: unknown): SessionCapturer {
+  return new SessionCapturer({}, driver as never)
+}
+
+describe('selenium SessionCapturer.captureCommand', () => {
+  it('pushes a CommandLog with _id and id set to the same counter value', async () => {
+    const cap = makeCapturer()
+    const entry = await cap.captureCommand(
+      'click',
+      ['#btn'],
+      { ok: true },
+      undefined
+    )
+    expect(entry._id).toBeDefined()
+    expect((entry as { id?: number }).id).toBe(entry._id)
+    expect(cap.commandsLog).toHaveLength(1)
+  })
+
+  it('serializes Error into a plain object', async () => {
+    const cap = makeCapturer()
+    const err = new Error('boom')
+    const entry = await cap.captureCommand('x', [], undefined, err)
+    expect((entry.error as { name: string; message: string }).name).toBe(
+      'Error'
+    )
+  })
+
+  it('uses provided timestamp when given', async () => {
+    const cap = makeCapturer()
+    const entry = await cap.captureCommand(
+      'x',
+      [],
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      9999
+    )
+    expect(entry.timestamp).toBe(9999)
+  })
+})
+
+describe('selenium SessionCapturer.replaceCommand', () => {
+  it('mutates the existing entry in place and preserves _id/id', async () => {
+    const cap = makeCapturer()
+    const orig = await cap.captureCommand('click', ['#a'], undefined, undefined)
+    const origId = orig._id!
+    const origTs = orig.timestamp
+    const { entry, oldTimestamp } = cap.replaceCommand(
+      origId,
+      'click',
+      ['#a'],
+      { ok: true },
+      undefined
+    )
+    expect(oldTimestamp).toBe(origTs)
+    expect(cap.commandsLog).toHaveLength(1)
+    expect(entry._id).toBe(origId)
+    expect(entry.result).toEqual({ ok: true })
+  })
+
+  it('appends a fresh entry with new _id when oldId not found, oldTimestamp=0', async () => {
+    const cap = makeCapturer()
+    const { entry, oldTimestamp } = cap.replaceCommand(
+      999,
+      'x',
+      [],
+      'result',
+      undefined
+    )
+    expect(oldTimestamp).toBe(0)
+    expect(cap.commandsLog).toHaveLength(1)
+    expect(entry.result).toBe('result')
+  })
+})
+
+describe('selenium SessionCapturer.isNavigationCommand', () => {
+  it.each([
+    ['get', true],
+    ['navigate', true],
+    ['url', false],
+    ['click', false]
+  ])('isNavigationCommand(%s) → %s', (command, expected) => {
+    const cap = makeCapturer()
+    expect(cap.isNavigationCommand(command)).toBe(expected)
+  })
+})
+
+describe('selenium SessionCapturer.takeScreenshot', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('returns null when no driver is set', async () => {
+    const cap = makeCapturer()
+    expect(await cap.takeScreenshot()).toBeNull()
+  })
+
+  it('returns null when takeScreenshot original is not stashed', async () => {
+    // Driver present but no original stashed → null
+    const cap = makeCapturer({ id: 'driver' })
+    expect(await cap.takeScreenshot()).toBeNull()
+  })
+})
+
+describe('selenium SessionCapturer.captureBrowserLogs', () => {
+  it('no-ops when no driver set', async () => {
+    const cap = makeCapturer()
+    await expect(cap.captureBrowserLogs()).resolves.toBeUndefined()
+    expect(cap.consoleLogs).toHaveLength(0)
+  })
+
+  it('no-ops when driver set but no manage() stashed', async () => {
+    const cap = makeCapturer({ id: 'd' })
+    await expect(cap.captureBrowserLogs()).resolves.toBeUndefined()
+    expect(cap.consoleLogs).toHaveLength(0)
+  })
+})
+
+describe('selenium SessionCapturer.injectScript', () => {
+  it('no-ops when no driver set', async () => {
+    const cap = makeCapturer()
+    await expect(cap.injectScript()).resolves.toBeUndefined()
+  })
+
+  it('no-ops when driver set but no executeScript stashed', async () => {
+    const cap = makeCapturer({ id: 'd' })
+    await expect(cap.injectScript()).resolves.toBeUndefined()
+  })
+})
+
+describe('selenium SessionCapturer.captureTrace', () => {
+  it('no-ops when no driver set', async () => {
+    const cap = makeCapturer()
+    await expect(cap.captureTrace()).resolves.toBeUndefined()
+  })
+
+  it('no-ops when driver set but no executeScript stashed', async () => {
+    const cap = makeCapturer({ id: 'd' })
+    await expect(cap.captureTrace()).resolves.toBeUndefined()
+  })
+})
+
+// Direct mutation of the singleton driverOriginals bag is the
+// least-painful way to exercise the executeScript-dependent paths
+// without standing up a real selenium-webdriver. Always restore in
+// afterEach so we don't leak state between tests.
+describe('selenium SessionCapturer (with stashed executeScript)', () => {
+  let restoreExec: (() => void) | undefined
+
+  afterEach(() => {
+    restoreExec?.()
+    restoreExec = undefined
+  })
+
+  function stubExec(impl: (...args: unknown[]) => unknown) {
+    const originals = getDriverOriginals()
+    const prev = originals.executeScript
+    originals.executeScript = impl as (typeof originals)['executeScript']
+    restoreExec = () => {
+      if (prev) {
+        originals.executeScript = prev
+      } else {
+        delete originals.executeScript
+      }
+    }
+  }
+
+  it.skipIf(!scriptPackageAvailable)(
+    'injectScript runs to completion when collector becomes ready',
+    async () => {
+      let scriptInjected = false
+      let collectorReadyCalls = 0
+      stubExec(async (_driver, script) => {
+        const s = String(script)
+        if (s.includes('createElement')) {
+          scriptInjected = true
+          return true
+        }
+        if (s.includes('wdioTraceCollector')) {
+          collectorReadyCalls++
+          return collectorReadyCalls >= 1
+        }
+        return undefined
+      })
+      const cap = makeCapturer({ id: 'd' })
+      await cap.injectScript()
+      expect(scriptInjected).toBe(true)
+      expect(collectorReadyCalls).toBeGreaterThanOrEqual(1)
+    }
+  )
+
+  it('injectScript swallows ECONNREFUSED / no-such-session errors silently', async () => {
+    stubExec(async () => {
+      throw new Error('ECONNREFUSED')
+    })
+    const cap = makeCapturer({ id: 'd' })
+    await expect(cap.injectScript()).resolves.toBeUndefined()
+  })
+
+  it('captureTrace early-returns when collector is not present', async () => {
+    stubExec(async () => false)
+    const cap = makeCapturer({ id: 'd' })
+    await expect(cap.captureTrace()).resolves.toBeUndefined()
+  })
+
+  it('captureTrace early-returns when getTraceData returns falsy', async () => {
+    let call = 0
+    stubExec(async () => {
+      call++
+      return call === 1 ? true : null
+    })
+    const cap = makeCapturer({ id: 'd' })
+    await expect(cap.captureTrace()).resolves.toBeUndefined()
+    expect(call).toBe(2)
+  })
+
+  it('captureTrace processes payload when collector returns data', async () => {
+    let call = 0
+    stubExec(async () => {
+      call++
+      if (call === 1) {
+        return true
+      }
+      return {
+        mutations: [],
+        networkRequests: [],
+        consoleLogs: []
+      }
+    })
+    const cap = makeCapturer({ id: 'd' })
+    await cap.captureTrace()
+    expect(call).toBe(2)
+  })
+
+  it('captureTrace swallows ECONNREFUSED / no-such-session errors silently', async () => {
+    stubExec(async () => {
+      throw new Error('invalid session id')
+    })
+    const cap = makeCapturer({ id: 'd' })
+    await expect(cap.captureTrace()).resolves.toBeUndefined()
+  })
+})
+
+describe('selenium SessionCapturer.awaitClientConnected', () => {
+  it('resolves immediately if client already connected', async () => {
+    const cap = makeCapturer()
+    // simulate connect via onWsMessage
+    ;(cap as unknown as { onWsMessage: (m: unknown) => void }).onWsMessage({
+      scope: 'clientConnected'
+    })
+    await expect(cap.awaitClientConnected()).resolves.toBeUndefined()
+  })
+
+  it('blocks until a clientConnected message arrives', async () => {
+    const cap = makeCapturer()
+    let resolved = false
+    const p = cap.awaitClientConnected().then(() => {
+      resolved = true
+    })
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resolved).toBe(false)
+    ;(cap as unknown as { onWsMessage: (m: unknown) => void }).onWsMessage({
+      scope: 'clientConnected'
+    })
+    await p
+    expect(resolved).toBe(true)
+  })
+
+  it('invokes setClientDisconnectedHandler on clientDisconnected scope', () => {
+    const cap = makeCapturer()
+    const fn = vi.fn()
+    cap.setClientDisconnectedHandler(fn)
+    ;(cap as unknown as { onWsMessage: (m: unknown) => void }).onWsMessage({
+      scope: 'clientDisconnected'
+    })
+    expect(fn).toHaveBeenCalled()
+  })
+})
+
+describe('selenium SessionCapturer.setDriver', () => {
+  it('updates the driver reference', () => {
+    const cap = makeCapturer()
+    const driver = { id: 'd1' }
+    cap.setDriver(driver as never)
+    // No direct getter exposed; verify via takeScreenshot path falling through
+    // (driver-yes, original-no → null without throw)
+    return cap.takeScreenshot().then((s) => expect(s).toBeNull())
+  })
+})
diff --git a/packages/selenium-devtools/tsconfig.json b/packages/selenium-devtools/tsconfig.json
index c07e1902..a4b89587 100644
--- a/packages/selenium-devtools/tsconfig.json
+++ b/packages/selenium-devtools/tsconfig.json
@@ -11,7 +11,8 @@
     "strict": true,
     "resolveJsonModule": true,
     "skipLibCheck": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "ignoreDeprecations": "6.0"
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "example"]
diff --git a/packages/service/README.md b/packages/service/README.md
index 0d88f3fc..887f885d 100644
--- a/packages/service/README.md
+++ b/packages/service/README.md
@@ -52,7 +52,7 @@ services: [['devtools', options]]
 
 Records browser sessions as `.webm` videos. Videos are displayed in the DevTools UI alongside the snapshot and DOM mutation views.
 
-> **Note:** Screencast recording is currently supported for **WebdriverIO only**. Nightwatch.js support is planned for a future release.
+Available across all three adapters — WebdriverIO uses CDP push for Chrome (and polling fallback otherwise); see the [Nightwatch](../nightwatch-devtools/README.md#screencast) and [Selenium](../selenium-devtools/README.md) READMEs for their adapter-specific modes.
 
 ### Setup
 
@@ -122,3 +122,11 @@ No configuration change is needed to switch modes — the service detects browse
 |---|---|
 | `wdio-trace-{sessionId}.json` | Full trace: DOM mutations, commands, screenshots, console logs, network requests |
 | `wdio-video-{sessionId}.webm` | Screencast video (only produced when `screencast.enabled: true`) |
+
+## Performance API capture
+
+After every navigation command (`url`, `navigateTo`, etc.), the service runs the shared `CAPTURE_PERFORMANCE_SCRIPT` from `@wdio/devtools-core` to read `window.performance.getEntriesByType('navigation' | 'resource')`, cookies, and document info. The result is attached to the command entry in the Actions tab so you see `loadTime` / `domReady` / `responseTime` / resource counts per navigation. Same script and `applyPerformanceData` post-processing used by selenium-devtools and nightwatch-devtools — uniform dashboard fields across all three adapters.
+
+## Shared library notes
+
+Most of this service's capture + reporting logic now lives in `@wdio/devtools-core` and is consumed by all three adapters: `SessionCapturerBase`, `ScreencastRecorderBase`, `TestReporterBase`, `loadInjectableScript`/`pollUntilReady`, `processTracePayload`, `captureSource`, `sendCommand`/`sendReplaceCommand`, `errorMessage`/`toError`/`serializeError`, `RetryTracker`, `mapChromeBrowserLogs`, `attachBidiHandlers`, `finalizeScreencast`, `encodeToVideo`, `suite-helpers`, `test-discovery`. This service contains only WDIO-specific glue (BiDi event listeners via WDIO's native `browser.on`, the WDIO reporter integration, `beforeCommand`/`afterCommand` hook wiring, Cucumber UID branching).
diff --git a/packages/service/package.json b/packages/service/package.json
index f62b2287..66461d70 100644
--- a/packages/service/package.json
+++ b/packages/service/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@wdio/devtools-service",
-  "version": "10.4.2",
+  "version": "10.5.0",
   "description": "Hook up WebdriverIO with DevTools",
   "author": "Christian Bromann <mail@bromann.dev>",
   "repository": {
@@ -35,35 +35,37 @@
     "prepublishOnly": "pnpm build"
   },
   "dependencies": {
-    "@babel/parser": "^7.28.4",
-    "@babel/traverse": "^7.28.4",
-    "@babel/types": "^7.28.4",
+    "@babel/parser": "^7.29.7",
+    "@babel/traverse": "^7.29.7",
+    "@babel/types": "^7.29.7",
     "@wdio/devtools-backend": "workspace:^",
     "@wdio/devtools-script": "workspace:^",
     "@wdio/logger": "9.18.0",
-    "@wdio/reporter": "9.27.0",
-    "@wdio/types": "9.27.0",
+    "@wdio/reporter": "9.27.2",
+    "@wdio/types": "9.27.2",
     "fluent-ffmpeg": "^2.1.3",
-    "import-meta-resolve": "^4.1.0",
-    "stack-trace": "1.0.0-pre2",
-    "ws": "^8.18.3"
+    "import-meta-resolve": "^4.2.0",
+    "stack-trace": "^1.0.0",
+    "stacktrace-parser": "^0.1.11",
+    "ws": "^8.21.0"
   },
   "license": "MIT",
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
     "@types/babel__traverse": "^7.28.0",
-    "@types/fluent-ffmpeg": "^2.1.27",
+    "@types/fluent-ffmpeg": "^2.1.28",
     "@types/stack-trace": "^0.0.33",
     "@types/ws": "^8.18.1",
-    "@wdio/globals": "9.27.0",
-    "@wdio/protocols": "9.27.0",
-    "typescript": "6.0.2",
-    "vite": "8.0.7",
-    "vite-plugin-dts": "^4.5.4"
-
+    "@wdio/devtools-core": "workspace:^",
+    "@wdio/devtools-shared": "workspace:^",
+    "@wdio/globals": "9.27.2",
+    "@wdio/protocols": "9.27.2",
+    "typescript": "6.0.3",
+    "vite": "^8.0.16",
+    "vite-plugin-dts": "^5.0.2"
   },
   "peerDependencies": {
-    "@wdio/protocols": "9.27.0",
+    "@wdio/protocols": "9.27.2",
     "devtools": "^8.42.0",
     "webdriverio": "^9.19.1"
   }
diff --git a/packages/service/src/bidi-listeners.ts b/packages/service/src/bidi-listeners.ts
new file mode 100644
index 00000000..fce6ad5a
--- /dev/null
+++ b/packages/service/src/bidi-listeners.ts
@@ -0,0 +1,63 @@
+import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
+import type { SessionCapturer } from './session.js'
+
+const log = logger('@wdio/devtools-service:bidi-listeners')
+
+/**
+ * Subscribe a SessionCapturer to the BiDi event stream coming off a
+ * WebdriverIO browser — network request lifecycle (3 events) + browser
+ * console (`log.entryAdded`). Idempotent only in the sense that the caller
+ * should gate it (e.g. with a one-shot flag); this function will register a
+ * fresh listener on each call.
+ *
+ * Returns nothing. Errors during the optional `sessionSubscribe(log)` call
+ * are logged but non-fatal — WDIO auto-subscribes to network events; only
+ * log events need the explicit subscribe.
+ */
+export function attachBidiListeners(
+  browser: WebdriverIO.Browser,
+  capturer: SessionCapturer
+): void {
+  log.info('Setting up BiDi network event listeners...')
+
+  // WDIO's BiDi event types are a broader union than our handlers'
+  // narrower expected shape. The handlers do their own runtime narrowing;
+  // the cast at this seam is intentional and isolated.
+  type BidiRequestSent = Parameters<
+    typeof capturer.handleNetworkRequestStarted
+  >[0]
+  type BidiResponseCompleted = Parameters<
+    typeof capturer.handleNetworkResponseCompleted
+  >[0]
+  type BidiFetchError = Parameters<typeof capturer.handleNetworkFetchError>[0]
+  type BidiLogEntry = Parameters<typeof capturer.handleLogEntryAdded>[0]
+
+  browser.on('network.beforeRequestSent', (event) => {
+    capturer.handleNetworkRequestStarted(event as unknown as BidiRequestSent)
+  })
+  browser.on('network.responseCompleted', (event) => {
+    capturer.handleNetworkResponseCompleted(
+      event as unknown as BidiResponseCompleted
+    )
+  })
+  browser.on('network.fetchError', (event) => {
+    log.info(
+      `>>> BiDi fetchError - keys: ${Object.keys(event as object).join(', ')}`
+    )
+    capturer.handleNetworkFetchError(event as unknown as BidiFetchError)
+  })
+  browser.on('log.entryAdded', (event) => {
+    capturer.handleLogEntryAdded(event as unknown as BidiLogEntry)
+  })
+
+  // WDIO auto-subscribes to network events but not log events.
+  try {
+    // sessionSubscribe is augmented onto WebdriverIO.Browser in types.ts.
+    browser.sessionSubscribe?.({ events: ['log.entryAdded'] })
+  } catch (err) {
+    log.warn(`Could not subscribe to log.entryAdded: ${errorMessage(err)}`)
+  }
+
+  log.info('✓ BiDi network + log event listeners registered')
+}
diff --git a/packages/service/src/constants.ts b/packages/service/src/constants.ts
index fd27b2ed..eec10f5c 100644
--- a/packages/service/src/constants.ts
+++ b/packages/service/src/constants.ts
@@ -1,13 +1,8 @@
-import type { ScreencastOptions } from './types.js'
+import type { ParserPlugin } from '@babel/parser'
 
-export const SCREENCAST_DEFAULTS: Required<ScreencastOptions> = {
-  enabled: false,
-  captureFormat: 'jpeg',
-  quality: 70,
-  maxWidth: 1280,
-  maxHeight: 720,
-  pollIntervalMs: 200
-}
+// SCREENCAST_DEFAULTS hoisted to @wdio/devtools-shared; re-exported for
+// backwards compatibility with existing service-internal imports.
+export { SCREENCAST_DEFAULTS } from '@wdio/devtools-shared'
 
 export const PAGE_TRANSITION_COMMANDS: string[] = [
   'url',
@@ -16,43 +11,15 @@ export const PAGE_TRANSITION_COMMANDS: string[] = [
   'click'
 ]
 
-/**
- * Regular expression to strip ANSI escape codes from terminal output
- */
-export const ANSI_REGEX = /\x1b\[[0-9;]*m/g
-
-/**
- * Console method types for log capturing
- */
-export const CONSOLE_METHODS = ['log', 'info', 'warn', 'error'] as const
-
-/**
- * Log level detection patterns with priority order (highest to lowest)
- */
-export const LOG_LEVEL_PATTERNS: ReadonlyArray<{
-  level: 'trace' | 'debug' | 'info' | 'warn' | 'error'
-  pattern: RegExp
-}> = [
-  { level: 'trace', pattern: /\btrace\b/i },
-  { level: 'debug', pattern: /\bdebug\b/i },
-  { level: 'info', pattern: /\binfo\b/i },
-  { level: 'warn', pattern: /\bwarn(ing)?\b/i },
-  { level: 'error', pattern: /\berror\b/i }
-] as const
-
-/**
- * Visual indicators that suggest error-level logs
- */
-export const ERROR_INDICATORS = ['✗', 'failed', 'failure'] as const
-
-/**
- * Console log source types
- */
-export const LOG_SOURCES = {
-  BROWSER: 'browser',
-  TEST: 'test',
-  TERMINAL: 'terminal'
-} as const
+// Console capture constants are defined in @wdio/devtools-core; re-exported
+// here so existing imports from ./constants.js continue to work.
+export {
+  ANSI_REGEX,
+  CONSOLE_METHODS,
+  LOG_LEVEL_PATTERNS,
+  ERROR_INDICATORS,
+  LOG_SOURCES
+} from '@wdio/devtools-core'
 
 export const DEFAULT_LAUNCH_CAPS: WebdriverIO.Capabilities = {
   browserName: 'chrome',
@@ -110,7 +77,7 @@ export const PARSE_PLUGINS = [
   'decorators-legacy',
   'classProperties',
   'dynamicImport'
-] as const
+] as const satisfies readonly ParserPlugin[]
 
 /**
  * Test framework identifiers
@@ -132,8 +99,9 @@ export const STEP_FN_NAMES = [
 export const STEP_FILE_RE = /\.(?:steps?)\.[cm]?[jt]sx?$/i
 export const STEP_DIR_RE =
   /(?:^|\/)(?:step[-_]?definitions|steps)\/.+\.[cm]?[jt]sx?$/i
-export const SPEC_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i
-export const FEATURE_FILE_RE = /\.feature$/i
+// SPEC_FILE_RE / FEATURE_FILE_RE come from shared — re-exported here so
+// existing import sites in service keep resolving.
+export { SPEC_FILE_RE, FEATURE_FILE_RE } from '@wdio/devtools-shared'
 export const SOURCE_FILE_EXT_RE = /\.(?:[cm]?js|[cm]?ts)x?$/
 
 /**
diff --git a/packages/service/src/index.ts b/packages/service/src/index.ts
index 3dffebef..1f54eba1 100644
--- a/packages/service/src/index.ts
+++ b/packages/service/src/index.ts
@@ -3,6 +3,7 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import logger from '@wdio/logger'
+import { errorMessage } from '@wdio/devtools-core'
 import { SevereServiceError } from 'webdriverio'
 import type { Services, Reporters, Capabilities, Options } from '@wdio/types'
 import type { WebDriverCommands } from '@wdio/protocols'
@@ -12,14 +13,17 @@ import { TestReporter } from './reporter.js'
 import { DevToolsAppLauncher } from './launcher.js'
 import { getBrowserObject, isUserSpecFile } from './utils.js'
 import { ScreencastRecorder } from './screencast.js'
-import { encodeToVideo } from './video-encoder.js'
+import { attachBidiListeners } from './bidi-listeners.js'
+import {
+  finalizeScreencast,
+  resolveAdapterOutputDir
+} from '@wdio/devtools-core'
 import { parse } from 'stack-trace'
 import {
   type TraceLog,
   TraceType,
   type ServiceOptions,
-  type ScreencastOptions,
-  type ScreencastInfo
+  type ScreencastOptions
 } from './types.js'
 import { INTERNAL_COMMANDS, CONTEXT_CHANGE_COMMANDS } from './constants.js'
 
@@ -33,85 +37,8 @@ type CommandFrame = {
   callSource?: string
 }
 
-/**
- * Setup WebdriverIO Devtools hook for standalone instances
- */
-export function setupForDevtools(opts: Options.WebdriverIO) {
-  let browserCaptured = false
-  const service = new DevToolsHookService()
-  service.captureType = TraceType.Standalone
-
-  // In v9, the `opts` object itself contains the capabilities.
-  // The `beforeSession` hook expects the config and the capabilities.
-  service.beforeSession(opts, opts as Capabilities.W3CCapabilities)
-
-  opts.beforeCommand = Array.isArray(opts.beforeCommand)
-    ? opts.beforeCommand
-    : opts.beforeCommand
-      ? [opts.beforeCommand]
-      : []
-  opts.beforeCommand.push(async function captureBrowserInstance(
-    this: WebdriverIO.Browser,
-    command: keyof WebDriverCommands
-  ) {
-    if (!browserCaptured) {
-      browserCaptured = true
-      service.before(
-        this.capabilities as Capabilities.W3CCapabilities,
-        [],
-        this
-      )
-    }
-
-    /**
-     * capture trace on `deleteSession` since we can't do it in `afterCommand` as the session
-     * would be terminated by then
-     */
-    if (command === 'deleteSession') {
-      await service.after()
-    }
-  }, service.beforeCommand.bind(service))
-
-  /**
-   * register after command hook
-   */
-  opts.afterCommand = Array.isArray(opts.afterCommand)
-    ? opts.afterCommand
-    : opts.afterCommand
-      ? [opts.afterCommand]
-      : []
-  opts.afterCommand.push(service.afterCommand.bind(service))
-
-  /**
-   * return modified session configuration
-   */
-  return opts
-}
-
-function detectInvocationConfigPath(): string | undefined {
-  const envPath = process.env.DEVTOOLS_WDIO_CONFIG
-  if (envPath) {
-    return path.isAbsolute(envPath)
-      ? envPath
-      : path.resolve(process.cwd(), envPath)
-  }
-  const argv = process.argv
-  for (let i = 0; i < argv.length - 1; i++) {
-    if (argv[i] === '--config' || argv[i] === '-c') {
-      const next = argv[i + 1]
-      if (next && /\.(conf|config)\.(ts|js|cjs|mjs)$/i.test(next)) {
-        return path.isAbsolute(next) ? next : path.resolve(process.cwd(), next)
-      }
-    }
-  }
-  const positional = argv.find((a) => /\.conf\.(ts|js|cjs|mjs)$/i.test(a))
-  if (!positional) {
-    return undefined
-  }
-  return path.isAbsolute(positional)
-    ? positional
-    : path.resolve(process.cwd(), positional)
-}
+export { setupForDevtools } from './standalone.js'
+import { detectInvocationConfigPath } from './standalone.js'
 
 export default class DevToolsHookService implements Services.ServiceInstance {
   #testReporters: TestReporter[] = []
@@ -167,7 +94,7 @@ export default class DevToolsHookService implements Services.ServiceInstance {
       await this.#injectScriptSync(browser)
     } catch (err) {
       log.error(
-        `Failed to inject script at session start: ${(err as Error).message}`
+        `Failed to inject script at session start: ${errorMessage(err)}`
       )
     }
 
@@ -227,7 +154,7 @@ export default class DevToolsHookService implements Services.ServiceInstance {
           constructor(options: Reporters.Options) {
             super(
               options,
-              (upstreamData: any) =>
+              (upstreamData) =>
                 self.#sessionCapturer.sendUpstream('suites', upstreamData),
               (location: string) => {
                 self.#sessionCapturer.ensureSourceLoaded(location)
@@ -262,116 +189,78 @@ export default class DevToolsHookService implements Services.ServiceInstance {
     this.#commandStack = []
   }
 
+  #resolveCallSourceFromFrame(
+    frame: ReturnType<typeof parse>[number]
+  ): string | undefined {
+    const rawFile = frame.getFileName() ?? undefined
+    let absPath = rawFile
+    if (rawFile?.startsWith('file://')) {
+      try {
+        const url = new URL(rawFile)
+        absPath = decodeURIComponent(url.pathname)
+      } catch {
+        absPath = rawFile
+      }
+    }
+    if (absPath?.includes('?')) {
+      absPath = absPath.split('?')[0]
+    }
+    if (absPath === undefined) {
+      return undefined
+    }
+    const line = frame.getLineNumber() ?? undefined
+    const column = frame.getColumnNumber() ?? undefined
+    return `${absPath}:${line ?? 0}:${column ?? 0}`
+  }
+
+  #pushTopLevelCommandFrame(
+    command: string,
+    args: string[],
+    callSource: string | undefined
+  ): void {
+    if (INTERNAL_COMMANDS.includes(command)) {
+      return
+    }
+    const cmdSig = JSON.stringify({ command, args, src: callSource })
+    if (this.#lastCommandSig !== cmdSig) {
+      this.#commandStack.push({ command, callSource })
+      this.#lastCommandSig = cmdSig
+    }
+  }
+
   async beforeCommand(command: string, args: string[]) {
     if (!this.#browser) {
       return
     }
-
-    // Set up BiDi listeners on first command (before any actual commands are executed)
+    // BiDi listeners attach on the first command (before any execute).
     if (!this.#bidiListenersSetup && this.#browser.isBidi) {
       this.#bidiListenersSetup = true
-      log.info('Setting up BiDi network event listeners...')
-
-      // Listen for network events
-      this.#browser.on('network.beforeRequestSent', (event: any) => {
-        this.#sessionCapturer.handleNetworkRequestStarted(event)
-      })
-
-      this.#browser.on('network.responseCompleted', (event: any) => {
-        this.#sessionCapturer.handleNetworkResponseCompleted(event)
-      })
-
-      this.#browser.on('network.fetchError', (event: any) => {
-        log.info(`>>> BiDi fetchError - keys: ${Object.keys(event).join(', ')}`)
-        this.#sessionCapturer.handleNetworkFetchError(event)
-      })
-
-      this.#browser.on('log.entryAdded', (event: any) => {
-        this.#sessionCapturer.handleLogEntryAdded(event)
-      })
-
-      // WDIO auto-subscribes to network events but not log events.
-      try {
-        ;(this.#browser as any).sessionSubscribe?.({
-          events: ['log.entryAdded']
-        })
-      } catch (err) {
-        log.warn(
-          `Could not subscribe to log.entryAdded: ${(err as Error).message}`
-        )
-      }
-
-      log.info('✓ BiDi network + log event listeners registered')
+      attachBidiListeners(this.#browser, this.#sessionCapturer)
     }
-
-    /**
-     * On the first URL navigation, mark this moment as the start of meaningful
-     * recording so leading blank/black frames (browser not yet loaded, pre-test
-     * pauses, etc.) are trimmed from the encoded video.
-     * This fires via beforeCommand regardless of test runner (Mocha, Jasmine,
-     * Cucumber, or standalone), making it universally applicable.
-     */
+    // On first URL navigation, mark the start of meaningful recording so
+    // leading blank frames (pre-test pauses, etc.) are trimmed from the video.
+    // Fires regardless of runner (Mocha, Jasmine, Cucumber, standalone).
     if (command === 'url') {
       this.#screencastRecorder?.setStartMarker()
       this.#sessionCapturer.sendUpstream('metadata', { url: args[0] })
     }
-
-    /**
-     * Smart stack filtering to detect top-level user commands
-     */
+    // Smart stack filtering to detect top-level user commands.
     Error.stackTraceLimit = 20
     const stack = parse(new Error('')).reverse()
-    const source = stack.find((frame) => {
-      const file = frame.getFileName()
-      // Only consider command frames from user spec/test files
-      return isUserSpecFile(file)
-    })
-
-    if (
-      source &&
-      this.#commandStack.length === 0 &&
-      !INTERNAL_COMMANDS.includes(command)
-    ) {
-      const rawFile = source.getFileName() ?? undefined
-      let absPath = rawFile
-
-      if (rawFile?.startsWith('file://')) {
-        try {
-          const url = new URL(rawFile)
-          absPath = decodeURIComponent(url.pathname)
-        } catch {
-          absPath = rawFile
-        }
-      }
-
-      if (absPath?.includes('?')) {
-        absPath = absPath.split('?')[0]
-      }
-
-      const line = source.getLineNumber() ?? undefined
-      const column = source.getColumnNumber() ?? undefined
-      const callSource =
-        absPath !== undefined
-          ? `${absPath}:${line ?? 0}:${column ?? 0}`
-          : undefined
-
-      const cmdSig = JSON.stringify({
+    const source = stack.find((frame) => isUserSpecFile(frame.getFileName()))
+    if (source && this.#commandStack.length === 0) {
+      this.#pushTopLevelCommandFrame(
         command,
         args,
-        src: callSource
-      })
-
-      if (this.#lastCommandSig !== cmdSig) {
-        this.#commandStack.push({ command, callSource })
-        this.#lastCommandSig = cmdSig
-      }
+        this.#resolveCallSourceFromFrame(source)
+      )
     }
   }
 
   afterCommand(
     command: keyof WebDriverCommands,
-    args: any[],
-    result: any,
+    args: unknown[],
+    result: unknown,
     error?: Error
   ) {
     // Skip bookkeeping for internal injection calls
@@ -423,8 +312,8 @@ export default class DevToolsHookService implements Services.ServiceInstance {
       consoleLogs: this.#sessionCapturer.consoleLogs,
       networkRequests: this.#sessionCapturer.networkRequests,
       metadata: {
-        type: this.captureType,
         ...this.#sessionCapturer.metadata!,
+        type: this.captureType,
         options,
         capabilities: this.#browser.capabilities as Capabilities.W3CCapabilities
       },
@@ -467,20 +356,25 @@ export default class DevToolsHookService implements Services.ServiceInstance {
 
   /**
    * Resolves the directory where devtools output files (trace JSON, video WebM)
-   * should be written, using the following priority:
-   *  1. `outputDir` if the user explicitly set it in wdio.conf — respected as-is.
-   *  2. `rootDir`   — WDIO automatically sets this to the directory containing
-   *                   wdio.conf.ts, so files always land next to the config file
-   *                   regardless of where the `wdio` command is invoked from.
-   *  3. `process.cwd()` — last-resort fallback.
+   * should be written.
+   *
+   * WDIO-specific quirk: `wdio.conf.ts`'s `outputDir` (or the auto-set
+   * `rootDir`) is the authoritative location — both are honored as-is via
+   * `userConfiguredDir`, bypassing the test-file fallback. This preserves
+   * the long-standing WDIO behavior of writing files next to the config.
+   * Falls back to `process.cwd()`.
    *
-   * NOTE: Avoid setting `outputDir` in wdio.conf just to fix the output path —
-   * doing so redirects WDIO worker logs to files and silences the terminal.
+   * NOTE: Avoid setting `outputDir` in wdio.conf just to fix the output path
+   * — doing so redirects WDIO worker logs to files and silences the terminal.
    * Rely on `rootDir` instead (it is set automatically by WDIO).
    */
   get #outputDir(): string {
-    const opts = this.#browser?.options as any
-    return opts?.outputDir || opts?.rootDir || process.cwd()
+    const opts = this.#browser?.options as
+      | { outputDir?: string; rootDir?: string }
+      | undefined
+    return resolveAdapterOutputDir({
+      userConfiguredDir: opts?.outputDir || opts?.rootDir
+    })
   }
 
   /**
@@ -492,38 +386,21 @@ export default class DevToolsHookService implements Services.ServiceInstance {
     if (!this.#screencastRecorder) {
       return
     }
-
-    await this.#screencastRecorder.stop()
-
-    // Skip ghost sessions: browser.reloadSession() creates a new session at the
-    // end of a test run that has no steps — it captures at most a handful of
-    // frames before teardown. Require at least 5 frames so we don't produce
+    // Skip ghost sessions: browser.reloadSession() creates a new session at
+    // the end of a test run that has no steps — it captures at most a handful
+    // of frames before teardown. Require at least 5 frames so we don't produce
     // empty videos for these ephemeral sessions.
-    if (this.#screencastRecorder.frames.length < 5) {
-      return
-    }
-
-    const outputDir = this.#outputDir
-    const videoFile = `wdio-video-${sessionId}.webm`
-    const videoPath = path.join(outputDir, videoFile)
-    try {
-      await encodeToVideo(this.#screencastRecorder.frames, videoPath, {
-        captureFormat: this.#screencastOptions?.captureFormat
-      })
-      const screencastInfo: ScreencastInfo = {
-        sessionId,
-        videoPath,
-        videoFile,
-        frameCount: this.#screencastRecorder.frames.length,
-        duration: this.#screencastRecorder.duration
-      }
-      // Notify the backend (and then the UI) that a video is ready.
-      // The backend stores the absolute videoPath and exposes it via
-      // GET /api/video/:sessionId, forwarding only { sessionId } to the UI.
-      this.#sessionCapturer.sendUpstream('screencast', screencastInfo)
-    } catch (encodeErr) {
-      log.warn(`Screencast encode failed: ${(encodeErr as Error).message}`)
-    }
+    await finalizeScreencast({
+      recorder: this.#screencastRecorder,
+      sessionId,
+      filenamePrefix: 'wdio-video',
+      outputDir: this.#outputDir,
+      minFrames: 5,
+      captureFormat: this.#screencastOptions?.captureFormat,
+      sendUpstream: (scope, data) =>
+        this.#sessionCapturer.sendUpstream(scope, data),
+      onLog: (level, message) => log[level](message)
+    })
   }
 
   /**
@@ -548,14 +425,17 @@ export default class DevToolsHookService implements Services.ServiceInstance {
     try {
       this.#injecting = true
       const markerPresent = await this.#browser.execute(() => {
-        return Boolean((window as any).__WDIO_DEVTOOLS_MARK)
+        return Boolean(
+          (window as unknown as { __WDIO_DEVTOOLS_MARK?: unknown })
+            .__WDIO_DEVTOOLS_MARK
+        )
       })
       if (markerPresent) {
         return
       }
       await this.#sessionCapturer.injectScript(getBrowserObject(this.#browser))
     } catch (err) {
-      log.warn(`[inject] failed (reason=${reason}): ${(err as Error).message}`)
+      log.warn(`[inject] failed (reason=${reason}): ${errorMessage(err)}`)
     } finally {
       this.#injecting = false
     }
diff --git a/packages/service/src/launcher.ts b/packages/service/src/launcher.ts
index 8a121737..b8fd252d 100644
--- a/packages/service/src/launcher.ts
+++ b/packages/service/src/launcher.ts
@@ -3,6 +3,7 @@ import http from 'node:http'
 import { remote } from 'webdriverio'
 import { start } from '@wdio/devtools-backend'
 import logger from '@wdio/logger'
+import { REUSE_ENV, RUNNER_ENV } from '@wdio/devtools-shared'
 import { DEFAULT_LAUNCH_CAPS } from './constants.js'
 import type { ServiceOptions, ExtendedCapabilities } from './types.js'
 
@@ -10,7 +11,7 @@ const log = logger('@wdio/devtools-service:Launcher')
 
 // On rerun the original CLI process still owns its port-binding services;
 // swallow EADDRINUSE so other services' onPrepare don't fail loudly.
-if (process.env.DEVTOOLS_APP_REUSE === '1') {
+if (process.env[REUSE_ENV.REUSE] === '1') {
   const originalListen = http.Server.prototype.listen
   http.Server.prototype.listen = function patchedListen(
     this: http.Server,
@@ -36,7 +37,8 @@ if (process.env.DEVTOOLS_APP_REUSE === '1') {
 }
 
 // Lives in the launcher: forked workers have their own argv without the config arg.
-function detectInvocationConfigPath(): string | undefined {
+// Exported for unit tests; not part of the package's public API surface.
+export function detectInvocationConfigPath(): string | undefined {
   const argv = process.argv
   for (let i = 0; i < argv.length - 1; i++) {
     if (argv[i] === '--config' || argv[i] === '-c') {
@@ -55,7 +57,7 @@ function detectInvocationConfigPath(): string | undefined {
     : path.resolve(process.cwd(), positional)
 }
 
-function detectInvocationSpecs(): string[] {
+export function detectInvocationSpecs(): string[] {
   const argv = process.argv
   const out: string[] = []
   for (let i = 0; i < argv.length - 1; i++) {
@@ -88,30 +90,32 @@ export class DevToolsAppLauncher {
     this.#options = options
   }
 
-  async onPrepare(_: never, caps: ExtendedCapabilities[]) {
-    try {
-      const detectedConfig = detectInvocationConfigPath()
-      if (detectedConfig && !process.env.DEVTOOLS_WDIO_CONFIG) {
-        process.env.DEVTOOLS_WDIO_CONFIG = detectedConfig
-        log.info(`Detected config for reruns: ${detectedConfig}`)
-      }
-
-      if (!process.env.DEVTOOLS_WDIO_INITIAL_SPECS) {
-        const detectedSpecs = detectInvocationSpecs()
-        if (detectedSpecs.length) {
-          process.env.DEVTOOLS_WDIO_INITIAL_SPECS = detectedSpecs.join(
-            path.delimiter
-          )
-          log.info(
-            `Detected initial specs for Run All: ${detectedSpecs.join(', ')}`
-          )
-        }
+  #captureRerunEnv(): void {
+    const detectedConfig = detectInvocationConfigPath()
+    if (detectedConfig && !process.env[RUNNER_ENV.WDIO_CONFIG]) {
+      process.env[RUNNER_ENV.WDIO_CONFIG] = detectedConfig
+      log.info(`Detected config for reruns: ${detectedConfig}`)
+    }
+    if (!process.env[RUNNER_ENV.WDIO_INITIAL_SPECS]) {
+      const detectedSpecs = detectInvocationSpecs()
+      if (detectedSpecs.length) {
+        process.env[RUNNER_ENV.WDIO_INITIAL_SPECS] = detectedSpecs.join(
+          path.delimiter
+        )
+        log.info(
+          `Detected initial specs for Run All: ${detectedSpecs.join(', ')}`
+        )
       }
+    }
+  }
 
-      const reusePort = process.env.DEVTOOLS_APP_PORT
+  async onPrepare(_: never, caps: ExtendedCapabilities[]) {
+    try {
+      this.#captureRerunEnv()
+      const reusePort = process.env[REUSE_ENV.PORT]
       const reuseHost =
-        process.env.DEVTOOLS_APP_HOST || this.#options.hostname || 'localhost'
-      if (process.env.DEVTOOLS_APP_REUSE === '1' && reusePort) {
+        process.env[REUSE_ENV.HOST] || this.#options.hostname || 'localhost'
+      if (process.env[REUSE_ENV.REUSE] === '1' && reusePort) {
         log.info(
           `Reusing existing DevTools app at http://${reuseHost}:${reusePort}`
         )
@@ -125,11 +129,9 @@ export class DevToolsAppLauncher {
         port: this.#options.port,
         hostname: this.#options.hostname
       })
-
       if (!port) {
         return console.log(`Failed to start server on port ${port}`)
       }
-
       this.#updateCapabilities(caps, {
         port,
         hostname: this.#options.hostname || 'localhost'
@@ -162,8 +164,11 @@ export class DevToolsAppLauncher {
       }
       try {
         await this.#browser.deleteSession()
-      } catch (err: any) {
-        log.warn('Session already closed or could not be deleted:', err.message)
+      } catch (err) {
+        log.warn(
+          'Session already closed or could not be deleted:',
+          (err as Error).message
+        )
       }
     }
   }
diff --git a/packages/service/src/reporter.ts b/packages/service/src/reporter.ts
index dcf380b6..ad792131 100644
--- a/packages/service/src/reporter.ts
+++ b/packages/service/src/reporter.ts
@@ -2,6 +2,12 @@ import WebdriverIOReporter, {
   type SuiteStats,
   type TestStats
 } from '@wdio/reporter'
+import type { Reporters } from '@wdio/types'
+import {
+  deterministicUid,
+  generateStableUid as generateStableUidByFileName,
+  resetSignatureCounters
+} from '@wdio/devtools-core'
 import {
   mapTestToSource,
   setCurrentSpecFile,
@@ -9,85 +15,112 @@ import {
 } from './utils.js'
 import { readFileSync, existsSync } from 'node:fs'
 
-// Track test/suite occurrences within current run to handle duplicate signatures
-const signatureCounters = new Map<string, number>()
+// True when the stats object is a Cucumber scenario. The `type` field on
+// @wdio/reporter's SuiteStats/TestStats is a literal union ('suite' | 'test'),
+// but WDIO's Cucumber adapter ALSO emits `type: 'scenario'`. Module
+// augmentation can't widen the literal, so we widen at the read site here.
+function isScenario(item: SuiteStats | TestStats): boolean {
+  return (item as { type?: string }).type === 'scenario'
+}
 
-// Generate stable UID based on test/suite metadata
+// Generate stable UID for a WDIO suite/test stats object. Handles WDIO's
+// Cucumber-specific shapes (scenarios with featureFile/featureLine, or with
+// numeric uid + example-row fallback), then delegates the Mocha/Jasmine path
+// to core's generateStableUid.
 function generateStableUid(item: SuiteStats | TestStats): string {
-  const rawItem = item as any
-
   // For Cucumber scenarios, prefer the feature file URI:line as the stable
   // discriminator. The Cucumber pickle carries the actual line of the example
   // row, which is stable across reruns regardless of how many examples run.
-  // The previous fallback used WDIO's index-based uid (`example-${rawItem.uid}`),
+  // The previous fallback used WDIO's index-based uid (`example-${item.uid}`),
   // but that uid is reassigned when running a subset of examples — e.g. running
   // only example 2 alone makes it example index 0, colliding with example 1's
   // stable UID from a full run and causing duplicate rows in the dashboard.
   if (
-    rawItem.type === 'scenario' &&
-    rawItem.featureFile &&
-    typeof rawItem.featureLine === 'number'
+    isScenario(item) &&
+    item.featureFile &&
+    typeof item.featureLine === 'number'
   ) {
-    const parts = [rawItem.featureFile, String(rawItem.featureLine), item.title]
-    const hash = parts
-      .join('::')
-      .split('')
-      .reduce((acc, char) => {
-        return ((acc << 5) - acc + char.charCodeAt(0)) | 0
-      }, 0)
-    return `stable-${Math.abs(hash).toString(36)}`
+    return deterministicUid(
+      item.featureFile,
+      String(item.featureLine),
+      item.title
+    )
   }
 
   // Fallback for Cucumber scenarios where the pickle URI:line wasn't captured.
-  if (rawItem.type === 'scenario' && /^\d+$/.test(rawItem.uid)) {
-    const parts = [
+  if (isScenario(item) && /^\d+$/.test(item.uid)) {
+    const file = 'file' in item ? (item.file ?? '') : ''
+    const parent = 'parent' in item ? (item.parent ?? '') : ''
+    return deterministicUid(
       item.title,
-      rawItem.file || '',
-      rawItem.parent || '',
-      rawItem.cid || '',
-      `example-${rawItem.uid}`
-    ]
-    const hash = parts
-      .join('::')
-      .split('')
-      .reduce((acc, char) => {
-        return ((acc << 5) - acc + char.charCodeAt(0)) | 0
-      }, 0)
-    return `stable-${Math.abs(hash).toString(36)}`
+      file,
+      parent,
+      item.cid || '',
+      `example-${item.uid}`
+    )
   }
 
   // For Mocha/Jasmine tests and suites, use only stable identifiers
   // that don't change between full and partial runs
   // DO NOT use cid or parent as they can vary based on run context
-  const parts = [rawItem.file || '', String(rawItem.fullTitle || item.title)]
-
-  const signature = parts.join('::')
-  const count = signatureCounters.get(signature) || 0
-  signatureCounters.set(signature, count + 1)
+  const file = 'file' in item ? (item.file ?? '') : ''
+  return generateStableUidByFileName(file, String(item.fullTitle || item.title))
+}
 
-  if (count > 0) {
-    parts.push(String(count))
+/**
+ * Parse a Cucumber feature file to extract line numbers for scenario outline examples
+ * Returns a map of example index -> line number
+ */
+function findScenarioLineIndex(lines: string[], scenarioTitle: string): number {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim()
+    if (
+      (line.startsWith('Scenario Outline:') || line.startsWith('Scenario:')) &&
+      line.includes(scenarioTitle)
+    ) {
+      return i
+    }
   }
+  return -1
+}
 
-  const hash = parts
-    .join('::')
-    .split('')
-    .reduce((acc, char) => {
-      return ((acc << 5) - acc + char.charCodeAt(0)) | 0
-    }, 0)
-
-  return `stable-${Math.abs(hash).toString(36)}`
+function findExamplesSectionStart(lines: string[], fromIndex: number): number {
+  for (let i = fromIndex; i < lines.length; i++) {
+    if (lines[i].trim().startsWith('Examples:')) {
+      return i
+    }
+  }
+  return -1
 }
 
-// Reset counters at the start of each test run
-function resetSignatureCounters() {
-  signatureCounters.clear()
+function collectExampleDataRowLines(
+  lines: string[],
+  examplesStartIndex: number
+): Map<number, number> {
+  const exampleLines = new Map<number, number>()
+  let exampleIndex = 0
+  let foundHeader = false
+  for (let i = examplesStartIndex + 1; i < lines.length; i++) {
+    const line = lines[i].trim()
+    if (
+      line.startsWith('Scenario') ||
+      line.startsWith('Feature:') ||
+      (!line && exampleIndex > 0)
+    ) {
+      break
+    }
+    if (line.startsWith('|')) {
+      if (!foundHeader) {
+        foundHeader = true
+      } else {
+        exampleLines.set(exampleIndex, i + 1)
+        exampleIndex++
+      }
+    }
+  }
+  return exampleLines
 }
 
-/**
- * Parse a Cucumber feature file to extract line numbers for scenario outline examples
- * Returns a map of example index -> line number
- */
 function parseFeatureFileForExampleLines(
   filePath: string,
   scenarioTitle: string
@@ -96,70 +129,19 @@ function parseFeatureFileForExampleLines(
     if (!existsSync(filePath)) {
       return null
     }
-
-    const content = readFileSync(filePath, 'utf-8')
-    const lines = content.split('\n')
-
-    // Find the scenario outline with matching title
-    let scenarioLineIndex = -1
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim()
-      if (
-        (line.startsWith('Scenario Outline:') ||
-          line.startsWith('Scenario:')) &&
-        line.includes(scenarioTitle)
-      ) {
-        scenarioLineIndex = i
-        break
-      }
-    }
-
+    const lines = readFileSync(filePath, 'utf-8').split('\n')
+    const scenarioLineIndex = findScenarioLineIndex(lines, scenarioTitle)
     if (scenarioLineIndex === -1) {
       return null
     }
-
-    // Find the Examples section
-    let examplesStartIndex = -1
-    for (let i = scenarioLineIndex; i < lines.length; i++) {
-      if (lines[i].trim().startsWith('Examples:')) {
-        examplesStartIndex = i
-        break
-      }
-    }
-
+    const examplesStartIndex = findExamplesSectionStart(
+      lines,
+      scenarioLineIndex
+    )
     if (examplesStartIndex === -1) {
       return null
     }
-
-    // Find the data rows (skip header row with |)
-    const exampleLines = new Map<number, number>()
-    let exampleIndex = 0
-    let foundHeader = false
-
-    for (let i = examplesStartIndex + 1; i < lines.length; i++) {
-      const line = lines[i].trim()
-
-      // Stop at next scenario or feature end
-      if (
-        line.startsWith('Scenario') ||
-        line.startsWith('Feature:') ||
-        (!line && exampleIndex > 0)
-      ) {
-        break
-      }
-
-      // Data rows start with |
-      if (line.startsWith('|')) {
-        if (!foundHeader) {
-          foundHeader = true // Skip header row
-        } else {
-          // Store line number (1-indexed)
-          exampleLines.set(exampleIndex, i + 1)
-          exampleIndex++
-        }
-      }
-    }
-
+    const exampleLines = collectExampleDataRowLines(lines, examplesStartIndex)
     return exampleLines.size > 0 ? exampleLines : null
   } catch (error) {
     console.error('[Reporter] Failed to parse feature file:', error)
@@ -168,14 +150,14 @@ function parseFeatureFileForExampleLines(
 }
 
 export class TestReporter extends WebdriverIOReporter {
-  #report: (data: any) => void
+  #report: (data: Record<string, SuiteStats>[]) => void
   #loadSource: (location: string) => void
   #currentSpecFile?: string
   #suitePath: string[] = []
 
   constructor(
-    options: any,
-    report: (data: any) => void,
+    options: Reporters.Options,
+    report: (data: Record<string, SuiteStats>[]) => void,
     loadSource: (location: string) => void = () => {}
   ) {
     super(options)
@@ -188,23 +170,24 @@ export class TestReporter extends WebdriverIOReporter {
   onSuiteStart(suiteStats: SuiteStats): void {
     super.onSuiteStart(suiteStats)
 
-    const rawSuite = suiteStats as any
-
     // For Cucumber scenarios: prefer the pickle's URI:line (stable across
     // single-example reruns). Fall back to index-based feature-file parsing
     // only if the pickle data isn't available.
-    if (rawSuite.type === 'scenario' && suiteStats.file?.endsWith('.feature')) {
+    if (isScenario(suiteStats) && suiteStats.file?.endsWith('.feature')) {
+      const cucumberArg = (suiteStats as { argument?: unknown }).argument as
+        | { uri?: string; line?: number }
+        | undefined
       const pickleUri =
-        rawSuite.argument?.uri ?? rawSuite.pickle?.uri ?? rawSuite.uri
+        cucumberArg?.uri ?? suiteStats.pickle?.uri ?? suiteStats.uri
       const pickleLine =
-        rawSuite.argument?.line ??
-        rawSuite.pickle?.location?.line ??
-        rawSuite.line
+        cucumberArg?.line ??
+        suiteStats.pickle?.location?.line ??
+        (typeof suiteStats.line === 'number' ? suiteStats.line : undefined)
       if (typeof pickleUri === 'string' && typeof pickleLine === 'number') {
-        rawSuite.featureFile = pickleUri
-        rawSuite.featureLine = pickleLine
+        suiteStats.featureFile = pickleUri
+        suiteStats.featureLine = pickleLine
       } else {
-        const exampleIndex = parseInt(rawSuite.uid, 10)
+        const exampleIndex = parseInt(suiteStats.uid, 10)
         if (!isNaN(exampleIndex)) {
           const exampleLines = parseFeatureFileForExampleLines(
             suiteStats.file,
@@ -212,16 +195,15 @@ export class TestReporter extends WebdriverIOReporter {
           )
           if (exampleLines?.has(exampleIndex)) {
             const lineNumber = exampleLines.get(exampleIndex)!
-            rawSuite.featureFile = suiteStats.file
-            rawSuite.featureLine = lineNumber
+            suiteStats.featureFile = suiteStats.file
+            suiteStats.featureLine = lineNumber
           }
         }
       }
     }
 
     // Generate stable UID for consistent identification across reruns
-    const stableUid = generateStableUid(suiteStats)
-    ;(suiteStats as any).uid = stableUid
+    suiteStats.uid = generateStableUid(suiteStats)
 
     this.#currentSpecFile = suiteStats.file
     setCurrentSpecFile(suiteStats.file)
@@ -232,11 +214,16 @@ export class TestReporter extends WebdriverIOReporter {
     }
 
     // Enrich and set callSource for suites
-    mapSuiteToSource(suiteStats as any, this.#currentSpecFile, this.#suitePath)
-    if ((suiteStats as any).file && (suiteStats as any).line !== null) {
-      ;(suiteStats as any).callSource =
-        `${(suiteStats as any).file}:${(suiteStats as any).line}`
-      this.#loadSource((suiteStats as any).file)
+    mapSuiteToSource(suiteStats, this.#currentSpecFile, this.#suitePath)
+    if (suiteStats.file) {
+      // loadSource only needs the file path — line is irrelevant for fetching
+      // the source. Fire whenever there's a file mapping, even if line is unset
+      // (e.g. cucumber feature suites where the line comes from pickle data
+      // populated later).
+      this.#loadSource(suiteStats.file)
+      if (suiteStats.line !== null && suiteStats.line !== undefined) {
+        suiteStats.callSource = `${suiteStats.file}:${suiteStats.line}`
+      }
     }
 
     this.#sendUpstream()
@@ -246,24 +233,27 @@ export class TestReporter extends WebdriverIOReporter {
     super.onTestStart(testStats)
 
     // For Cucumber: capture feature file URI and line from pickle
-    const rawTest = testStats as any
-    if (rawTest.argument?.uri && typeof rawTest.argument?.line === 'number') {
-      // Store feature file location for Cucumber scenarios
-      rawTest.featureFile = rawTest.argument.uri
-      rawTest.featureLine = rawTest.argument.line
+    const cucumberArg = (testStats as { argument?: unknown }).argument as
+      | { uri?: string; line?: number }
+      | undefined
+    if (cucumberArg?.uri && typeof cucumberArg.line === 'number') {
+      testStats.featureFile = cucumberArg.uri
+      testStats.featureLine = cucumberArg.line
     }
 
     // Enrich testStats with callSource info FIRST
     mapTestToSource(testStats, this.#currentSpecFile)
-    if ((testStats as any).file && (testStats as any).line !== null) {
-      ;(testStats as any).callSource =
-        `${(testStats as any).file}:${(testStats as any).line}`
-      this.#loadSource((testStats as any).file)
+    if (
+      testStats.file &&
+      testStats.line !== null &&
+      testStats.line !== undefined
+    ) {
+      testStats.callSource = `${testStats.file}:${testStats.line}`
+      this.#loadSource(testStats.file)
     }
 
     // Generate stable UID after enriching metadata for consistent test identification
-    const stableUid = generateStableUid(testStats)
-    ;(testStats as any).uid = stableUid
+    testStats.uid = generateStableUid(testStats)
 
     this.#sendUpstream()
   }
@@ -277,9 +267,15 @@ export class TestReporter extends WebdriverIOReporter {
     // `matcherResult`) — Jest/expect-webdriverio may attach these as either
     // enumerable or non-enumerable depending on version, so we access them
     // by name rather than relying on spread.
-    const rawErr = (testStats as any).error
+    const rawErr = testStats.error as
+      | (Error & {
+          expected?: unknown
+          actual?: unknown
+          matcherResult?: unknown
+        })
+      | undefined
     if (rawErr) {
-      ;(testStats as any).error = {
+      testStats.error = {
         ...rawErr,
         message: rawErr.message,
         name: rawErr.name,
@@ -287,7 +283,7 @@ export class TestReporter extends WebdriverIOReporter {
         expected: rawErr.expected,
         actual: rawErr.actual,
         matcherResult: rawErr.matcherResult
-      }
+      } as Error
     }
     this.#sendUpstream()
   }
@@ -319,8 +315,7 @@ export class TestReporter extends WebdriverIOReporter {
     // Use the suite's current UID (which we've set to stable) as the key
     for (const suite of Object.values(this.suites)) {
       if (suite) {
-        const actualUid = (suite as any).uid
-        payload.push({ [actualUid]: suite })
+        payload.push({ [suite.uid]: suite })
       }
     }
 
diff --git a/packages/service/src/screencast.ts b/packages/service/src/screencast.ts
index a034e7a2..528a37b6 100644
--- a/packages/service/src/screencast.ts
+++ b/packages/service/src/screencast.ts
@@ -1,159 +1,97 @@
 import logger from '@wdio/logger'
-
-import { SCREENCAST_DEFAULTS } from './constants.js'
-import type { ScreencastFrame, ScreencastOptions } from './types.js'
+import { ScreencastRecorderBase, errorMessage } from '@wdio/devtools-core'
 
 const log = logger('@wdio/devtools-service:ScreencastRecorder')
 
-/**
- * Manages session screencast recording with automatic browser detection.
- *
- * Recording strategy (chosen automatically at start time):
- *   1. CDP push mode  — Chrome/Chromium only. Chrome pushes frames over the
- *      DevTools Protocol; each frame is ack'd immediately. Efficient with no
- *      impact on test command timing.
- *   2. BiDi polling   — all other browsers (Firefox, Safari, Edge Legacy, …).
- *      Falls back to calling browser.takeScreenshot() at a fixed interval.
- *      Works wherever WebDriver screenshots are supported; adds a small
- *      round-trip overhead proportional to pollIntervalMs.
- *
- * Usage:
- *   const recorder = new ScreencastRecorder(options)
- *   await recorder.start(browser)   // in before() hook
- *   // ... test runs ...
- *   await recorder.stop()           // in after() hook
- *   const frames = recorder.frames  // feed to encodeToVideo()
- */
-export class ScreencastRecorder {
-  #frames: ScreencastFrame[] = []
-  /** Puppeteer CDPSession — set only in CDP mode. */
-  #cdpSession: any = undefined
-  /** setInterval handle — set only in polling mode. */
-  #pollTimer: ReturnType<typeof setInterval> | undefined = undefined
-  #isRecording = false
-  #options: Required<ScreencastOptions>
-  /**
-   * Index into #frames where meaningful recording begins.
-   * Frames before this index (blank browser before first navigation) are
-   * excluded from encoding. Set once via setStartMarker().
-   */
-  #startIndex = 0
-  #startMarkerSet = false
-
-  constructor(options: ScreencastOptions = {}) {
-    this.#options = { ...SCREENCAST_DEFAULTS, ...options }
-  }
-
-  // ─── public API ───────────────────────────────────────────────────────────
+interface CdpSessionLike {
+  send(method: string, params?: Record<string, unknown>): Promise<unknown>
+  on(event: string, handler: (event: unknown) => void | Promise<void>): void
+}
 
-  /**
-   * Start recording. Tries CDP (Chrome) first; falls back to BiDi polling
-   * for all other browsers. Safe to call even if the browser does not support
-   * screenshots — the failure is logged and recording is simply skipped.
-   */
-  async start(browser: WebdriverIO.Browser): Promise<void> {
-    const cdpStarted = await this.#startCdp(browser)
-    if (!cdpStarted) {
-      await this.#startPolling(browser)
-    }
-  }
+interface PuppeteerPageLike {
+  createCDPSession(): Promise<CdpSessionLike>
+}
 
-  /**
-   * Stop recording and release resources.
-   * Safe to call even if start() was never called or failed.
-   */
-  async stop(): Promise<void> {
-    if (!this.#isRecording) {
-      return
-    }
+interface PuppeteerLike {
+  pages(): Promise<PuppeteerPageLike[]>
+}
 
-    if (this.#cdpSession) {
-      await this.#stopCdp()
-    } else if (this.#pollTimer !== undefined) {
-      this.#stopPolling()
-    }
+/**
+ * WDIO-specific screencast recorder. Inherits the frame buffer, polling
+ * fallback, and public API from {@link ScreencastRecorderBase}; overrides the
+ * CDP hooks to use WDIO's Puppeteer escape hatch (`browser.getPuppeteer()`).
+ */
+export class ScreencastRecorder extends ScreencastRecorderBase<WebdriverIO.Browser> {
+  #cdpSession: CdpSessionLike | undefined = undefined
 
-    this.#isRecording = false
+  protected override onPollingStarted(intervalMs: number): void {
+    log.info(
+      `✓ Screencast recording started (polling mode, ${intervalMs} ms interval)`
+    )
   }
 
-  /**
-   * Mark the current frame position as the start of meaningful recording.
-   * Frames captured before this call (blank browser, pre-navigation pauses)
-   * are excluded from the encoded video.
-   * Safe to call multiple times — only the first call takes effect.
-   */
-  setStartMarker() {
-    if (!this.#startMarkerSet) {
-      this.#startMarkerSet = true
-      this.#startIndex = this.#frames.length
-    }
+  protected override onPollingStopped(frameCount: number): void {
+    log.info(`✓ Screencast stopped — ${frameCount} frame(s) collected`)
   }
 
-  /** Frames to encode — everything from the first meaningful action onwards. */
-  get frames(): ScreencastFrame[] {
-    return this.#frames.slice(this.#startIndex)
+  protected override onUnavailable(err: unknown): void {
+    log.warn(
+      `Screencast unavailable (${errorMessage(err)}). Recording skipped.`
+    )
   }
 
-  /**
-   * Duration in milliseconds between first and last captured frame.
-   * Returns 0 if fewer than 2 frames were collected.
-   */
-  get duration(): number {
-    const f = this.frames
-    if (f.length < 2) {
-      return 0
+  protected override async takeScreenshot(): Promise<string | null> {
+    if (!this.driver) {
+      return null
     }
-    return f[f.length - 1].timestamp - f[0].timestamp
+    return this.driver.takeScreenshot()
   }
 
-  get isRecording(): boolean {
-    return this.#isRecording
-  }
-
-  // ─── CDP mode (Chrome/Chromium) ───────────────────────────────────────────
-
-  /**
-   * Attempt to start recording via the Chrome DevTools Protocol.
-   * Returns true on success, false if CDP is unavailable (non-Chrome browser
-   * or remote grid without debug-port access).
-   */
-  async #startCdp(browser: WebdriverIO.Browser): Promise<boolean> {
+  protected override async tryStartCdp(): Promise<boolean> {
+    if (!this.driver) {
+      return false
+    }
     try {
-      const puppeteer = await (browser as any).getPuppeteer()
+      // getPuppeteer is augmented onto WebdriverIO.Browser in types.ts; the
+      // returned Puppeteer object isn't typed by WDIO, so narrow it locally.
+      const raw = await this.driver.getPuppeteer?.()
+      if (!raw) {
+        return false
+      }
+      const puppeteer = raw as PuppeteerLike
       const pages = await puppeteer.pages()
       if (!pages.length) {
         return false
       }
 
       const page = pages[0]
-      this.#cdpSession = await page.createCDPSession()
-
-      await this.#cdpSession.send('Page.startScreencast', {
-        format: this.#options.captureFormat,
-        quality: this.#options.quality,
-        maxWidth: this.#options.maxWidth,
-        maxHeight: this.#options.maxHeight
+      const session = await page.createCDPSession()
+      this.#cdpSession = session
+
+      await session.send('Page.startScreencast', {
+        format: this.options.captureFormat,
+        quality: this.options.quality,
+        maxWidth: this.options.maxWidth,
+        maxHeight: this.options.maxHeight
       })
 
-      this.#cdpSession.on('Page.screencastFrame', async (event: any) => {
-        // CDP timestamp is seconds (float); convert to ms.
-        this.#frames.push({
-          data: event.data,
-          timestamp: Math.round(event.metadata.timestamp * 1000)
-        })
+      session.on('Page.screencastFrame', async (rawEvent) => {
+        const event = rawEvent as {
+          data: string
+          metadata: { timestamp: number }
+          sessionId?: number
+        }
+        this.pushCdpFrame(event.data, event.metadata.timestamp)
         // Chrome stops sending frames if acks are not sent promptly.
         try {
-          await this.#cdpSession.send('Page.screencastFrameAck', {
+          await session.send('Page.screencastFrameAck', {
             sessionId: event.sessionId
           })
         } catch (ackErr) {
-          log.warn(
-            `Screencast: failed to ack frame — ${(ackErr as Error).message}`
-          )
+          log.warn(`Screencast: failed to ack frame — ${errorMessage(ackErr)}`)
         }
       })
 
-      this.#isRecording = true
       log.info('✓ Screencast recording started (CDP mode)')
       return true
     } catch {
@@ -162,16 +100,19 @@ export class ScreencastRecorder {
     }
   }
 
-  async #stopCdp(): Promise<void> {
+  protected override async tryStopCdp(): Promise<void> {
+    const session = this.#cdpSession
+    if (!session) {
+      return
+    }
     try {
-      await this.#cdpSession.send('Page.stopScreencast')
+      await session.send('Page.stopScreencast')
       log.info(
-        `✓ Screencast stopped — ${this.#frames.length} frame(s) collected`
+        `✓ Screencast stopped — ${this.buffer.length} frame(s) collected`
       )
     } catch (err) {
-      const msg = (err as Error).message ?? ''
+      const msg = errorMessage(err)
       if (msg.includes('Session closed') || msg.includes('Target closed')) {
-        // Browser shut down before after() completed — frames already buffered.
         log.debug(
           'Screencast: CDP session already closed (expected during teardown)'
         )
@@ -182,51 +123,4 @@ export class ScreencastRecorder {
       this.#cdpSession = undefined
     }
   }
-
-  // ─── Polling mode (all other browsers) ───────────────────────────────────
-
-  /**
-   * Attempt to start recording via periodic browser.takeScreenshot() calls.
-   * Works for any browser that supports WebDriver screenshots (Firefox,
-   * Safari, etc.). Adds a small round-trip overhead per interval tick.
-   */
-  async #startPolling(browser: WebdriverIO.Browser): Promise<void> {
-    try {
-      // Capture one frame immediately to verify screenshots work before
-      // committing to the polling loop.
-      const firstShot = await browser.takeScreenshot()
-      this.#frames.push({ data: firstShot, timestamp: Date.now() })
-
-      const intervalMs = this.#options.pollIntervalMs
-      this.#pollTimer = setInterval(async () => {
-        try {
-          const data = await browser.takeScreenshot()
-          this.#frames.push({ data, timestamp: Date.now() })
-        } catch {
-          // Session ended mid-interval — stop polling gracefully.
-          this.#stopPolling()
-        }
-      }, intervalMs)
-
-      this.#isRecording = true
-      log.info(
-        `✓ Screencast recording started (polling mode, ${intervalMs} ms interval)`
-      )
-    } catch (err) {
-      log.warn(
-        `Screencast unavailable (${(err as Error).message}). ` +
-          'Recording will be skipped.'
-      )
-    }
-  }
-
-  #stopPolling(): void {
-    if (this.#pollTimer !== undefined) {
-      clearInterval(this.#pollTimer)
-      this.#pollTimer = undefined
-      log.info(
-        `✓ Screencast stopped — ${this.#frames.length} frame(s) collected`
-      )
-    }
-  }
 }
diff --git a/packages/service/src/session.ts b/packages/service/src/session.ts
index a538b795..fcd6b508 100644
--- a/packages/service/src/session.ts
+++ b/packages/service/src/session.ts
@@ -2,67 +2,29 @@ import fs from 'node:fs/promises'
 import url from 'node:url'
 
 import logger from '@wdio/logger'
-import { WebSocket } from 'ws'
 import { parse } from 'stack-trace'
 import { resolve } from 'import-meta-resolve'
 import { SevereServiceError } from 'webdriverio'
 import type { WebDriverCommands } from '@wdio/protocols'
 
+import { PAGE_TRANSITION_COMMANDS } from './constants.js'
 import {
-  PAGE_TRANSITION_COMMANDS,
-  ANSI_REGEX,
-  CONSOLE_METHODS,
-  LOG_LEVEL_PATTERNS,
-  ERROR_INDICATORS,
-  LOG_SOURCES
-} from './constants.js'
-import { type CommandLog, type TraceLog, type LogLevel } from './types.js'
+  CAPTURE_PERFORMANCE_SCRIPT,
+  LOG_SOURCES,
+  SessionCapturerBase,
+  applyPerformanceData,
+  createConsoleLogEntry,
+  errorMessage,
+  getRequestType,
+  type CapturedPerformancePayload,
+  type LogSource
+} from '@wdio/devtools-core'
+import type { CommandLog, LogLevel } from './types.js'
 
 const log = logger('@wdio/devtools-service:SessionCapturer')
 
-const stripAnsi = (text: string) => text.replace(ANSI_REGEX, '')
-
-const detectLogLevel = (text: string): LogLevel => {
-  const t = stripAnsi(text).toLowerCase()
-  for (const { level, pattern } of LOG_LEVEL_PATTERNS) {
-    if (pattern.test(t)) {
-      return level
-    }
-  }
-  if (ERROR_INDICATORS.some((i) => t.includes(i.toLowerCase()))) {
-    return 'error'
-  }
-  return 'log'
-}
-
-const toConsoleEntry = (
-  type: LogLevel,
-  args: any[],
-  source: (typeof LOG_SOURCES)[keyof typeof LOG_SOURCES]
-): ConsoleLogs => ({ timestamp: Date.now(), type, args, source })
-
-export class SessionCapturer {
-  #ws: WebSocket | undefined
+export class SessionCapturer extends SessionCapturerBase {
   #isScriptInjected = false
-  #originalConsoleMethods: Record<
-    (typeof CONSOLE_METHODS)[number],
-    typeof console.log
-  > = {
-    log: console.log,
-    info: console.info,
-    warn: console.warn,
-    error: console.error
-  }
-  #originalStdoutWrite = process.stdout.write.bind(process.stdout)
-  #originalStderrWrite = process.stderr.write.bind(process.stderr)
-  /** True while we are inside the patched console call — prevents double-capture via stream. */
-  #insideConsole = false
-  commandsLog: CommandLog[] = []
-  sources = new Map<string, string>()
-  mutations: TraceMutation[] = []
-  traceLogs: string[] = []
-  consoleLogs: ConsoleLogs[] = []
-  networkRequests: NetworkRequest[] = []
   #pendingNetworkRequests = new Map<
     string,
     {
@@ -73,121 +35,29 @@ export class SessionCapturer {
       requestHeaders?: Record<string, string>
     }
   >()
-  metadata?: {
-    url: string
-    viewport: {
-      width: number
-      height: number
-      offsetLeft: number
-      offsetTop: number
-      scale: number
-    }
-  }
 
   constructor(devtoolsOptions: { hostname?: string; port?: number } = {}) {
-    const { port, hostname } = devtoolsOptions
-    if (hostname && port) {
-      this.#ws = new WebSocket(`ws://${hostname}:${port}/worker`)
-      this.#ws.on('error', (err: unknown) =>
-        log.error(
-          `Couldn't connect to devtools backend: ${(err as Error).message}`
-        )
-      )
-    }
-
-    this.#patchConsole()
-    this.#patchStreams()
+    super(devtoolsOptions)
+    this.patchConsole()
+    this.patchStreams()
   }
 
-  /**
-   * Patch Node.js console methods so every console.log/info/warn/error call in
-   * the test runner process (test files, page-object helpers, etc.) is forwarded
-   * to the UI Console tab with source='test'.
-   */
-  #patchConsole() {
-    CONSOLE_METHODS.forEach((method) => {
-      const original = this.#originalConsoleMethods[method]
-      console[method] = (...args: any[]) => {
-        const serialized = args.map((a) =>
-          typeof a === 'object' && a !== null
-            ? (() => {
-                try {
-                  return JSON.stringify(a)
-                } catch {
-                  return String(a)
-                }
-              })()
-            : String(a)
-        )
-        const entry = toConsoleEntry(method, serialized, LOG_SOURCES.TEST)
-        this.consoleLogs.push(entry)
-        this.sendUpstream('consoleLogs', [entry])
-
-        this.#insideConsole = true
-        const result = original.apply(console, args)
-        this.#insideConsole = false
-        return result
-      }
-    })
+  protected override onWsError(err: unknown): void {
+    log.error(`Couldn't connect to devtools backend: ${errorMessage(err)}`)
   }
 
   /**
-   * Patch process.stdout / process.stderr so all terminal output (WDIO
-   * framework logs, reporter output, etc.) is also forwarded to the UI
-   * Console tab with source='terminal'.  The original write is always
-   * called first so actual terminal output is never suppressed.
+   * Push every captured line into the local `consoleLogs` array so it ends up
+   * in the final trace payload, in addition to the live WS broadcast.
    */
-  #patchStreams() {
-    const forward = (raw: string | Uint8Array) => {
-      const text = typeof raw === 'string' ? raw : raw.toString()
-      if (!text.trim()) {
-        return
-      }
-      text
-        .split('\n')
-        .filter((l) => l.trim())
-        .forEach((line) => {
-          const entry = toConsoleEntry(
-            detectLogLevel(line),
-            [stripAnsi(line)],
-            LOG_SOURCES.TERMINAL
-          )
-          this.consoleLogs.push(entry)
-          this.sendUpstream('consoleLogs', [entry])
-        })
-    }
-
-    const wrap = (
-      stream: NodeJS.WriteStream,
-      original: (...a: any[]) => boolean
-    ) => {
-      stream.write = ((chunk: any, ...rest: any[]): boolean => {
-        const result = original.call(stream, chunk, ...rest)
-        if (chunk && !this.#insideConsole) {
-          forward(chunk)
-        }
-        return result
-      }) as any
-    }
-
-    wrap(process.stdout, this.#originalStdoutWrite)
-    wrap(process.stderr, this.#originalStderrWrite)
-  }
-
-  /**
-   * Restore all patched methods. Must be called in after() so subsequent
-   * test runs (or the WDIO reporter teardown) see the real stdout/stderr.
-   */
-  cleanup() {
-    CONSOLE_METHODS.forEach((method) => {
-      console[method] = this.#originalConsoleMethods[method]
-    })
-    process.stdout.write = this.#originalStdoutWrite as any
-    process.stderr.write = this.#originalStderrWrite as any
-  }
-
-  get isReportingUpstream() {
-    return Boolean(this.#ws) && this.#ws?.readyState === WebSocket.OPEN
+  protected override onLine(
+    type: LogLevel,
+    args: string[],
+    source: LogSource
+  ): void {
+    const entry = createConsoleLogEntry(type, args, source)
+    this.consoleLogs.push(entry as ConsoleLogs)
+    this.sendUpstream('consoleLogs', [entry])
   }
 
   // Cucumber step files never appear on the WebDriver call stack;
@@ -200,26 +70,16 @@ export class SessionCapturer {
       ? url.fileURLToPath(location)
       : location
     const sourceFilePath = absolutePath.split(':')[0]
-    if (!sourceFilePath || this.sources.has(sourceFilePath)) {
+    if (!sourceFilePath) {
       return
     }
-    try {
-      const sourceCode = (await fs.readFile(sourceFilePath, 'utf-8')).toString()
-      this.sources.set(sourceFilePath, sourceCode)
-      this.sendUpstream('sources', { [sourceFilePath]: sourceCode })
-    } catch {
-      // file unreadable / missing — nothing to surface
-    }
+    await this.captureSource(sourceFilePath)
   }
 
-  async afterCommand(
-    browser: WebdriverIO.Browser,
-    command: keyof WebDriverCommands,
-    args: any[],
-    result: any,
-    error: Error | undefined,
-    callSource?: string
-  ) {
+  #resolveUserStackFrame(): {
+    sourceFileLocation: string
+    absolutePath: string
+  } {
     const sourceFileLocation =
       parse(new Error(''))
         .filter((frame) => Boolean(frame.getFileName()))
@@ -241,19 +101,21 @@ export class SessionCapturer {
     const absolutePath = sourceFileLocation.startsWith('file://')
       ? url.fileURLToPath(sourceFileLocation)
       : sourceFileLocation
+    return { sourceFileLocation, absolutePath }
+  }
+
+  async afterCommand(
+    browser: WebdriverIO.Browser,
+    command: keyof WebDriverCommands,
+    args: unknown[],
+    result: unknown,
+    error: Error | undefined,
+    callSource?: string
+  ) {
+    const { sourceFileLocation, absolutePath } = this.#resolveUserStackFrame()
     const sourceFilePath = absolutePath.split(':')[0]
-    const doesFileExist = await fs.access(sourceFilePath).then(
-      () => true,
-      () => false
-    )
-    if (
-      sourceFileLocation &&
-      !this.sources.has(sourceFileLocation) &&
-      doesFileExist
-    ) {
-      const sourceCode = await fs.readFile(sourceFilePath, 'utf-8')
-      this.sources.set(sourceFilePath, sourceCode.toString())
-      this.sendUpstream('sources', { [sourceFilePath]: sourceCode.toString() })
+    if (sourceFileLocation && sourceFilePath) {
+      await this.captureSource(sourceFilePath)
     }
     const commandLogEntry: CommandLog = {
       command,
@@ -272,15 +134,48 @@ export class SessionCapturer {
     }
     this.commandsLog.push(commandLogEntry)
     this.sendUpstream('commands', [commandLogEntry])
-
-    /**
-     * capture trace and write to file on commands that could trigger a page transition
-     */
+    // Capture trace + perf on commands that could trigger a page transition.
     if (PAGE_TRANSITION_COMMANDS.includes(command)) {
+      await this.#capturePerformance(browser, commandLogEntry, args)
       await this.#captureTrace(browser)
     }
   }
 
+  /**
+   * Run the shared Performance API capture script and attach the result to
+   * the given CommandLog entry. Same `CAPTURE_PERFORMANCE_SCRIPT` +
+   * `applyPerformanceData` selenium and nightwatch use, so the dashboard
+   * shows consistent navigation/resources/cookies across all three adapters.
+   */
+  async #capturePerformance(
+    browser: WebdriverIO.Browser,
+    entry: CommandLog,
+    args: unknown[]
+  ): Promise<void> {
+    try {
+      // Brief settle so navigation entries are populated before we read them.
+      await new Promise((resolve) => setTimeout(resolve, 500))
+      const payload = (await browser.execute(CAPTURE_PERFORMANCE_SCRIPT)) as
+        | CapturedPerformancePayload
+        | undefined
+      if (applyPerformanceData(entry, payload, args[0] as string | undefined)) {
+        this.sendUpstream('commands', [entry])
+      }
+    } catch (err) {
+      const msg = errorMessage(err)
+      // Session torn down between the navigation command and the deferred
+      // perf-script execution — expected during teardown of the last test.
+      if (
+        msg.includes('ECONNREFUSED') ||
+        msg.includes('no such session') ||
+        msg.includes('invalid session id')
+      ) {
+        return
+      }
+      log.warn(`Performance capture failed: ${msg}`)
+    }
+  }
+
   async injectScript(browser: WebdriverIO.Browser) {
     if (this.#isScriptInjected) {
       log.info('Script already injected, skipping')
@@ -323,46 +218,30 @@ export class SessionCapturer {
         return
       }
 
-      const { mutations, traceLogs, consoleLogs, networkRequests, metadata } =
-        await browser.execute(() => window.wdioTraceCollector.getTraceData())
-      this.metadata = metadata
-
-      if (Array.isArray(mutations)) {
-        this.mutations.push(...(mutations as TraceMutation[]))
-        this.sendUpstream('mutations', mutations)
-      }
-      if (Array.isArray(traceLogs)) {
-        this.traceLogs.push(...traceLogs)
-        this.sendUpstream('logs', traceLogs)
-      }
-      if (Array.isArray(consoleLogs)) {
-        const browserLogs = consoleLogs as ConsoleLogs[]
-        browserLogs.forEach((log) => (log.source = LOG_SOURCES.BROWSER))
-        this.consoleLogs.push(...browserLogs)
-        this.sendUpstream('consoleLogs', browserLogs)
-      }
-      if (Array.isArray(networkRequests)) {
-        const requests = networkRequests as NetworkRequest[]
-        this.networkRequests.push(...requests)
-        this.sendUpstream('networkRequests', requests)
-      }
-
-      this.sendUpstream('metadata', metadata)
-      log.info(`✓ Sent metadata upstream, WS state: ${this.#ws?.readyState}`)
+      const payload = await browser.execute(() =>
+        window.wdioTraceCollector.getTraceData()
+      )
+      this.processTracePayload(payload as Record<string, unknown>)
     } catch (err) {
-      log.error(`Failed to capture trace: ${(err as Error).message}`)
+      log.error(`Failed to capture trace: ${errorMessage(err)}`)
     }
   }
 
   // Protocol-level capture survives pages that rewrite their own console.
-  handleLogEntryAdded(event: {
-    type?: 'console' | 'javascript'
-    level?: 'debug' | 'info' | 'warn' | 'error'
-    text?: string
-    method?: string
-    timestamp?: number
-    args?: Array<{ type?: string; value?: unknown }>
-  }) {
+  #stringifyBidiLogArg(
+    a: { type?: string; value?: unknown } | undefined
+  ): string {
+    if (a && 'value' in a && a.value !== undefined) {
+      try {
+        return typeof a.value === 'string' ? a.value : JSON.stringify(a.value)
+      } catch {
+        return String(a.value)
+      }
+    }
+    return `[${a?.type ?? 'unknown'}]`
+  }
+
+  #mapBidiLogType(method?: string, level?: string): ConsoleLogs['type'] {
     const methodToType: Record<string, ConsoleLogs['type']> = {
       log: 'log',
       info: 'info',
@@ -377,28 +256,23 @@ export class SessionCapturer {
       error: 'error',
       debug: 'log'
     }
-    const type: ConsoleLogs['type'] =
-      methodToType[event.method ?? ''] ??
-      levelToType[event.level ?? ''] ??
-      'log'
+    return methodToType[method ?? ''] ?? levelToType[level ?? ''] ?? 'log'
+  }
 
+  handleLogEntryAdded(event: {
+    type?: 'console' | 'javascript'
+    level?: 'debug' | 'info' | 'warn' | 'error'
+    text?: string
+    method?: string
+    timestamp?: number
+    args?: Array<{ type?: string; value?: unknown }>
+  }) {
+    const type = this.#mapBidiLogType(event.method, event.level)
     const args: string[] = Array.isArray(event.args)
-      ? event.args.map((a) => {
-          if (a && 'value' in a && a.value !== undefined) {
-            try {
-              return typeof a.value === 'string'
-                ? a.value
-                : JSON.stringify(a.value)
-            } catch {
-              return String(a.value)
-            }
-          }
-          return `[${a?.type ?? 'unknown'}]`
-        })
+      ? event.args.map((a) => this.#stringifyBidiLogArg(a))
       : event.text
         ? [event.text]
         : []
-
     const entry: ConsoleLogs = {
       timestamp:
         typeof event.timestamp === 'number' ? event.timestamp : Date.now(),
@@ -458,6 +332,33 @@ export class SessionCapturer {
     }
   }
 
+  #flattenBidiHeaders(
+    headers:
+      | {
+          name: string
+          value: { type?: string; value?: string } | string
+        }[]
+      | undefined
+  ): Record<string, string> {
+    const out: Record<string, string> = {}
+    if (!headers) {
+      return out
+    }
+    for (const h of headers) {
+      const name = typeof h.name === 'string' ? h.name.toLowerCase() : ''
+      const value =
+        typeof h.value === 'string'
+          ? h.value
+          : typeof h.value === 'object' && h.value?.value
+            ? h.value.value
+            : ''
+      if (name) {
+        out[name] = value
+      }
+    }
+    return out
+  }
+
   handleNetworkResponseCompleted(event: {
     request: { request: string }
     response: {
@@ -478,35 +379,12 @@ export class SessionCapturer {
       if (!pending) {
         return
       }
-
       this.#pendingNetworkRequests.delete(requestId)
-
-      const responseHeaders: Record<string, string> = {}
-      if (response.headers) {
-        response.headers.forEach(
-          (h: {
-            name: string
-            value: { type?: string; value?: string } | string
-          }) => {
-            const name = typeof h.name === 'string' ? h.name.toLowerCase() : ''
-            const value =
-              typeof h.value === 'string'
-                ? h.value
-                : typeof h.value === 'object' && h.value?.value
-                  ? h.value.value
-                  : ''
-            if (name) {
-              responseHeaders[name] = value
-            }
-          }
-        )
-      }
-
+      const responseHeaders = this.#flattenBidiHeaders(response.headers)
       const contentType = responseHeaders['content-type']?.trim()
       if (!contentType || contentType === '-') {
         return
       }
-
       const endTime = performance.now()
       const networkRequest: NetworkRequest = {
         id: `${timestamp}-${requestId}`,
@@ -514,7 +392,7 @@ export class SessionCapturer {
         method: pending.method,
         status: response.status,
         statusText: response.statusText,
-        type: this.#getRequestType(pending.url, contentType),
+        type: getRequestType(pending.url, contentType),
         timestamp: pending.timestamp,
         startTime: pending.startTime,
         endTime,
@@ -523,7 +401,6 @@ export class SessionCapturer {
         responseHeaders,
         size: response.bytesReceived
       }
-
       this.networkRequests.push(networkRequest)
       this.sendUpstream('networkRequests', [networkRequest])
     } catch (err) {
@@ -535,56 +412,4 @@ export class SessionCapturer {
     const requestId = event.request.request
     this.#pendingNetworkRequests.delete(requestId)
   }
-
-  #getRequestType(url: string, contentType?: string): string {
-    const urlLower = url.toLowerCase()
-    const ct = contentType?.toLowerCase() || ''
-
-    if (ct.includes('text/html')) {
-      return 'document'
-    }
-    if (ct.includes('text/css')) {
-      return 'stylesheet'
-    }
-    if (ct.includes('javascript') || ct.includes('ecmascript')) {
-      return 'script'
-    }
-    if (ct.includes('image/')) {
-      return 'image'
-    }
-    if (ct.includes('font/') || ct.includes('woff')) {
-      return 'font'
-    }
-    if (ct.includes('application/json')) {
-      return 'fetch'
-    }
-
-    if (urlLower.endsWith('.html') || urlLower.endsWith('.htm')) {
-      return 'document'
-    }
-    if (urlLower.endsWith('.css')) {
-      return 'stylesheet'
-    }
-    if (urlLower.endsWith('.js') || urlLower.endsWith('.mjs')) {
-      return 'script'
-    }
-    if (urlLower.match(/\.(png|jpg|jpeg|gif|svg|webp|ico)$/)) {
-      return 'image'
-    }
-    if (urlLower.match(/\.(woff|woff2|ttf|eot|otf)$/)) {
-      return 'font'
-    }
-
-    return 'xhr'
-  }
-
-  sendUpstream<Scope extends keyof TraceLog>(
-    scope: Scope,
-    data: Partial<TraceLog[Scope]>
-  ) {
-    if (!this.#ws || this.#ws.readyState !== WebSocket.OPEN) {
-      return
-    }
-    this.#ws.send(JSON.stringify({ scope, data }))
-  }
 }
diff --git a/packages/service/src/standalone.ts b/packages/service/src/standalone.ts
new file mode 100644
index 00000000..4e4dd9e8
--- /dev/null
+++ b/packages/service/src/standalone.ts
@@ -0,0 +1,87 @@
+import path from 'node:path'
+import type { Capabilities, Options } from '@wdio/types'
+import type { WebDriverCommands } from '@wdio/protocols'
+import { RUNNER_ENV } from '@wdio/devtools-shared'
+import DevToolsHookService from './index.js'
+import { TraceType } from './types.js'
+
+/**
+ * Resolve the WDIO config path from argv or `DEVTOOLS_WDIO_CONFIG`. The
+ * service uses this to send a `config` upstream message so the dashboard's
+ * rerun button knows which config to relaunch with.
+ */
+export function detectInvocationConfigPath(): string | undefined {
+  const envPath = process.env[RUNNER_ENV.WDIO_CONFIG]
+  if (envPath) {
+    return path.isAbsolute(envPath)
+      ? envPath
+      : path.resolve(process.cwd(), envPath)
+  }
+  const argv = process.argv
+  for (let i = 0; i < argv.length - 1; i++) {
+    if (argv[i] === '--config' || argv[i] === '-c') {
+      const next = argv[i + 1]
+      if (next && /\.(conf|config)\.(ts|js|cjs|mjs)$/i.test(next)) {
+        return path.isAbsolute(next) ? next : path.resolve(process.cwd(), next)
+      }
+    }
+  }
+  const positional = argv.find((a) => /\.conf\.(ts|js|cjs|mjs)$/i.test(a))
+  if (!positional) {
+    return undefined
+  }
+  return path.isAbsolute(positional)
+    ? positional
+    : path.resolve(process.cwd(), positional)
+}
+
+/**
+ * Setup WebdriverIO Devtools hook for standalone instances — wires the
+ * service into `opts.beforeCommand`/`afterCommand` callbacks so a non-WDIO-
+ * runner consumer (e.g. a Node script using `remote()` directly) still gets
+ * command capture and screencast recording.
+ */
+export function setupForDevtools(
+  opts: Options.WebdriverIO
+): Options.WebdriverIO {
+  let browserCaptured = false
+  const service = new DevToolsHookService()
+  service.captureType = TraceType.Standalone
+
+  // In v9, the `opts` object itself contains the capabilities.
+  service.beforeSession(opts, opts as Capabilities.W3CCapabilities)
+
+  opts.beforeCommand = Array.isArray(opts.beforeCommand)
+    ? opts.beforeCommand
+    : opts.beforeCommand
+      ? [opts.beforeCommand]
+      : []
+  opts.beforeCommand.push(async function captureBrowserInstance(
+    this: WebdriverIO.Browser,
+    command: keyof WebDriverCommands
+  ) {
+    if (!browserCaptured) {
+      browserCaptured = true
+      service.before(
+        this.capabilities as Capabilities.W3CCapabilities,
+        [],
+        this
+      )
+    }
+
+    // Capture trace on `deleteSession` — afterCommand fires after the
+    // session is gone, so do it here before the WS to the browser closes.
+    if (command === 'deleteSession') {
+      await service.after()
+    }
+  }, service.beforeCommand.bind(service))
+
+  opts.afterCommand = Array.isArray(opts.afterCommand)
+    ? opts.afterCommand
+    : opts.afterCommand
+      ? [opts.afterCommand]
+      : []
+  opts.afterCommand.push(service.afterCommand.bind(service))
+
+  return opts
+}
diff --git a/packages/service/src/types.ts b/packages/service/src/types.ts
index b1e5a4d9..a4dce985 100644
--- a/packages/service/src/types.ts
+++ b/packages/service/src/types.ts
@@ -1,118 +1,35 @@
-import type { WebDriverCommands } from '@wdio/protocols'
-import type { Capabilities, Options } from '@wdio/types'
-import type { SuiteStats } from '@wdio/reporter'
-
-export interface CommandLog {
-  command: keyof WebDriverCommands
-  args: any[]
-  result: any
-  error?: Error
-  timestamp: number
-  callSource: string
-  screenshot?: string
-  testUid?: string
-  id?: number
-}
-
-export interface ScreencastFrame {
-  /** Base64-encoded image data — JPEG/PNG from CDP push mode or PNG from browser.takeScreenshot() in polling mode */
-  data: string
-  /** Unix timestamp in milliseconds */
-  timestamp: number
-}
-
-export interface ScreencastOptions {
-  /** Enable screencast recording for this session (default: false) */
-  enabled?: boolean
-  /**
-   * Image format for individual frames (default: 'jpeg').
-   * - Chrome/Chromium (CDP mode): controls the format Chrome sends over CDP.
-   * - Other browsers (polling mode): screenshots are always PNG; this option
-   *   is ignored.
-   * Does NOT affect the output video container, which is always WebM.
-   */
-  captureFormat?: 'jpeg' | 'png'
-  /**
-   * JPEG quality 0–100 (default: 70).
-   * Only applies in Chrome/Chromium CDP mode with captureFormat 'jpeg'.
-   */
-  quality?: number
-  /**
-   * Max frame width in pixels Chrome sends over CDP (default: 1280).
-   * Only applies in Chrome/Chromium CDP mode.
-   */
-  maxWidth?: number
-  /**
-   * Max frame height in pixels Chrome sends over CDP (default: 720).
-   * Only applies in Chrome/Chromium CDP mode.
-   */
-  maxHeight?: number
-  /**
-   * Screenshot polling interval in milliseconds for non-Chrome browsers
-   * (default: 200 ms ≈ 5 fps).
-   * Polling calls browser.takeScreenshot() at this interval. A lower value
-   * gives smoother video but adds more WebDriver round-trips during the test.
-   */
-  pollIntervalMs?: number
-}
-
-export interface ScreencastInfo {
-  sessionId?: string
-  /** Absolute path to the encoded video file on disk */
-  videoPath?: string
-  /** Filename only, e.g. wdio-video-{sessionId}.webm */
-  videoFile?: string
-  frameCount?: number
-  /** Duration in milliseconds between first and last frame */
-  duration?: number
-}
-
-export enum TraceType {
-  Standalone = 'standalone',
-  Testrunner = 'testrunner'
-}
-
-export interface Viewport {
-  width: number
-  height: number
-  offsetLeft: number
-  offsetTop: number
-  scale: number
-}
-
-export interface Metadata {
-  type: TraceType
-  url: string
-  options: Omit<Options.WebdriverIO, 'capabilities'>
-  capabilities: Capabilities.W3CCapabilities
-  viewport: Viewport
-  /** Nightwatch / extended fields */
-  sessionId?: string
-  testEnv?: string
-  host?: string
-  modulePath?: string
-  desiredCapabilities?: Record<string, unknown>
-}
-
-export interface TraceLog {
-  mutations: TraceMutation[]
-  logs: string[]
-  consoleLogs: ConsoleLogs[]
-  networkRequests: NetworkRequest[]
-  metadata: Metadata
-  commands: CommandLog[]
-  sources: Record<string, string>
-  suites?: Record<string, SuiteStats>[]
-  screencast?: ScreencastInfo
-  config?: { configFile?: string }
-}
+// WDIO-specific types live here. Cross-package types come from @wdio/devtools-shared.
+//
+// Re-exports below maintain backwards compatibility for external consumers of
+// @wdio/devtools-service/types. New code should import directly from
+// @wdio/devtools-shared.
+
+export {
+  TraceType,
+  type CommandLog,
+  type ConsoleLog,
+  type DocumentInfo,
+  type LogLevel,
+  type Metadata,
+  type NetworkRequest,
+  type PerformanceData,
+  type PreservedAttempt,
+  type PreservedStep,
+  type ScreencastInfo,
+  type TestStatus,
+  type TraceLog,
+  type Viewport
+} from '@wdio/devtools-shared'
+
+// ScreencastFrame, ScreencastOptions hoisted to @wdio/devtools-shared; re-exported
+// here for backwards compatibility with existing service-internal imports.
+import type { ScreencastOptions } from '@wdio/devtools-shared'
+export type { ScreencastFrame, ScreencastOptions } from '@wdio/devtools-shared'
 
 export interface ExtendedCapabilities extends WebdriverIO.Capabilities {
   'wdio:devtoolsOptions'?: ServiceOptions
 }
 
-export type LogLevel = 'trace' | 'debug' | 'log' | 'info' | 'warn' | 'error'
-
 export interface ServiceOptions {
   /**
    * port to launch the application on (default: random)
@@ -146,6 +63,14 @@ export interface ServiceOptions {
 declare namespace WebdriverIO {
   interface ServiceOption extends ServiceOptions {}
   interface Capabilities {}
+  interface Browser {
+    // CDP escape hatch present at runtime in Chrome/Chromium sessions but
+    // omitted from WDIO's public Browser type. Returns Puppeteer's top-level
+    // browser object — see screencast.ts for the local shape we use.
+    getPuppeteer?: () => Promise<unknown>
+    // BiDi-specific WDIO method, present at runtime when BiDi is active.
+    sessionSubscribe?: (opts: { events: string[] }) => Promise<unknown>
+  }
 }
 
 declare module '@wdio/reporter' {
@@ -156,6 +81,12 @@ declare module '@wdio/reporter' {
     callSource?: string
     featureFile?: string
     featureLine?: number
+    // Cucumber pickle augmentations (the WDIO Cucumber adapter attaches these
+    // on scenarios; @wdio/reporter's base types don't include them). `argument`
+    // already exists in the base with a different shape, so reads of its
+    // Cucumber-specific fields stay locally cast in reporter.ts.
+    pickle?: { uri?: string; location?: { line?: number } }
+    uri?: string
   }
 
   interface SuiteStats {
@@ -163,69 +94,26 @@ declare module '@wdio/reporter' {
     callSource?: string
     featureFile?: string
     featureLine?: number
+    pickle?: { uri?: string; location?: { line?: number } }
+    uri?: string
   }
 }
 
+/** Minimal contract `findStepDefinitionLocation` uses when matching against
+ *  a Cucumber-expression step. The real instance comes from the optional
+ *  `@cucumber/cucumber-expressions` peer — its types are loose across
+ *  versions, so we pin only what's invoked. */
+export interface CucumberExpressionLike {
+  match(text: string): unknown
+}
+
 export type StepDef = {
   kind: 'regex' | 'string' | 'expression'
   keyword?: string
   text?: string
   regex?: RegExp
-  expr?: any
+  expr?: CucumberExpressionLike
   file: string
   line: number
   column: number
 }
-
-export interface PreservedStep {
-  uid: string
-  title?: string
-  fullTitle?: string
-  start?: number
-  end?: number
-  state?: 'passed' | 'failed' | 'skipped' | 'pending' | 'running'
-  error?: {
-    message?: string
-    name?: string
-    stack?: string
-    /** expect-webdriverio surfaces these directly on the error. */
-    expected?: unknown
-    actual?: unknown
-    /** expect-webdriverio also bundles them under matcherResult. */
-    matcherResult?: {
-      expected?: unknown
-      actual?: unknown
-      message?: string
-    }
-  }
-}
-
-export interface PreservedAttempt {
-  testUid: string
-  scope: 'test' | 'suite'
-  capturedAt: number
-  window: { start: number; end: number }
-  test: {
-    title?: string
-    fullTitle?: string
-    file?: string
-    callSource?: string
-    start?: number
-    end?: number
-    duration?: number
-    state?: 'passed' | 'failed' | 'skipped' | 'pending' | 'running'
-    error?: { message: string; name?: string; stack?: string }
-  }
-  /**
-   * Descendant step (TestStats) snapshots — populated when scope === 'suite'.
-   * Each entry has its own time window so commands can be attributed to the
-   * step that owned them at runtime. The Compare tab uses this to mark
-   * commands that ran inside a failed step (the assertion site).
-   */
-  steps?: PreservedStep[]
-  commands: CommandLog[]
-  consoleLogs: ConsoleLogs[]
-  networkRequests: NetworkRequest[]
-  mutations: TraceMutation[]
-  sources: Record<string, string>
-}
diff --git a/packages/service/src/utils.ts b/packages/service/src/utils.ts
index 19ab0d42..dc58e737 100644
--- a/packages/service/src/utils.ts
+++ b/packages/service/src/utils.ts
@@ -1,62 +1,18 @@
-import fs from 'fs'
-import path from 'node:path'
-import { createRequire } from 'node:module'
-import { parse } from '@babel/parser'
-import type {
-  Node as BabelNode,
-  NodePath,
-  TraverseOptions
-} from '@babel/traverse'
-import type { CallExpression } from '@babel/types'
-import { parse as parseStackTrace } from 'stack-trace'
-
-import {
-  PARSE_PLUGINS,
-  TEST_FN_NAMES,
-  SUITE_FN_NAMES,
-  STEP_FN_NAMES,
-  STEP_FILE_RE,
-  STEP_DIR_RE,
-  SPEC_FILE_RE,
-  FEATURE_FILE_RE,
-  FEATURE_OR_SCENARIO_LINE_RE,
-  STEP_DEF_REGEX_LITERAL_RE,
-  STEP_DEF_STRING_RE,
-  SOURCE_FILE_EXT_RE,
-  STEPS_DIR_CANDIDATES,
-  STEPS_DIR_ASCENT_MAX,
-  STEPS_GLOBAL_SEARCH_MAX_DEPTH
-} from './constants.js'
-import type { StepDef } from './types.js'
-
-const require = createRequire(import.meta.url)
-// @babel/traverse ships as CommonJS; load the callable via require to avoid ESM interop issues
-const traverse = (
-  require('@babel/traverse') as {
-    default: (parent: BabelNode, opts?: TraverseOptions) => void
-  }
-).default
-const _astCache = new Map<string, any[]>()
-
-let CE: { CucumberExpression: any; ParameterTypeRegistry: any } | undefined
-try {
-  const ce = require('@cucumber/cucumber-expressions')
-  CE = {
-    CucumberExpression: ce.CucumberExpression,
-    ParameterTypeRegistry: ce.ParameterTypeRegistry
-  }
-} catch {
-  /* optional */
-}
-
-/**
- * Track current spec file (set by reporter)
- */
-let CURRENT_SPEC_FILE: string | undefined
-export function setCurrentSpecFile(file?: string) {
-  CURRENT_SPEC_FILE = file
-}
-
+// Re-exports + small helpers used across the service. The heavy lifting
+// (AST parsing, source mapping, cucumber step-def lookup) lives in
+// utils/source-mapping.ts and utils/step-defs.ts.
+
+export {
+  setCurrentSpecFile,
+  findTestLocations,
+  getCurrentTestLocation,
+  mapTestToSource,
+  mapSuiteToSource
+} from './utils/source-mapping.js'
+export { findStepDefinitionLocation } from './utils/step-defs.js'
+
+/** A spec file owned by the user — excludes node-builtins and node_modules,
+ *  but keeps WDIO's expect helpers (callers may want to step into those). */
 export function isUserSpecFile(file?: string | null): boolean {
   if (!file) {
     return false
@@ -71,9 +27,7 @@ export function isUserSpecFile(file?: string | null): boolean {
   return !normalized.includes('/node_modules/')
 }
 
-/**
- * Get the top-level browser object from an element/browser
- */
+/** Walk up an element chain to its root browser. */
 export function getBrowserObject(
   elem: WebdriverIO.Element | WebdriverIO.Browser
 ): WebdriverIO.Browser {
@@ -82,668 +36,3 @@ export function getBrowserObject(
     ? getBrowserObject(elemObject.parent)
     : (elem as WebdriverIO.Browser)
 }
-
-/**
- * Get root callee name (handles Identifier and MemberExpression like it.only)
- */
-function rootCalleeName(callee: any): string | undefined {
-  if (!callee) {
-    return
-  }
-  if (callee.type === 'Identifier') {
-    return callee.name
-  }
-  if (callee.type === 'MemberExpression') {
-    const obj: any = callee.object
-    return obj && obj.type === 'Identifier' ? obj.name : undefined
-  }
-  return
-}
-
-/**
- * Parse a JS/TS test/spec file to collect suite/test calls (Mocha/Jasmine) with full title path
- */
-export function findTestLocations(filePath: string) {
-  if (!fs.existsSync(filePath)) {
-    return []
-  }
-
-  const src = fs.readFileSync(filePath, 'utf-8')
-  const ast = parse(src, {
-    sourceType: 'module',
-    plugins: PARSE_PLUGINS as any,
-    errorRecovery: true,
-    allowReturnOutsideFunction: true
-  })
-
-  type Loc = {
-    type: 'test' | 'suite'
-    name: string
-    titlePath: string[]
-    line?: number
-    column?: number
-  }
-
-  const out: Loc[] = []
-  const suiteStack: string[] = []
-
-  const isSuite = (n?: string) =>
-    (!!n && (SUITE_FN_NAMES as readonly string[]).includes(n)) ||
-    n === 'Feature'
-  const isTest = (n?: string) =>
-    !!n && (TEST_FN_NAMES as readonly string[]).includes(n)
-
-  const staticTitle = (node: any): string | undefined => {
-    if (!node) {
-      return
-    }
-    if (node.type === 'StringLiteral') {
-      return node.value
-    }
-    if (node.type === 'TemplateLiteral' && node.expressions.length === 0) {
-      return node.quasis.map((q: any) => q.value.cooked).join('')
-    }
-    return
-  }
-
-  traverse(ast, {
-    enter(p) {
-      if (!p.isCallExpression()) {
-        return
-      }
-      const callee: any = p.node.callee
-      const root = rootCalleeName(callee)
-      if (!root) {
-        return
-      }
-
-      if (isSuite(root)) {
-        const ttl = staticTitle(p.node.arguments?.[0] as any)
-        if (ttl) {
-          out.push({
-            type: 'suite',
-            name: ttl,
-            titlePath: [...suiteStack, ttl],
-            line: p.node.loc?.start.line,
-            column: p.node.loc?.start.column
-          })
-          suiteStack.push(ttl)
-        }
-      } else if (isTest(root)) {
-        const ttl = staticTitle(p.node.arguments?.[0] as any)
-        if (ttl) {
-          out.push({
-            type: 'test',
-            name: ttl,
-            titlePath: [...suiteStack, ttl],
-            line: p.node.loc?.start.line,
-            column: p.node.loc?.start.column
-          })
-        }
-      }
-    },
-    exit(p) {
-      if (!p.isCallExpression()) {
-        return
-      }
-      const callee: any = p.node.callee
-      const root = rootCalleeName(callee)
-      if (!root || !isSuite(root)) {
-        return
-      }
-      const ttl = ((): string | undefined => {
-        const a0: any = p.node.arguments?.[0]
-        if (a0?.type === 'StringLiteral') {
-          return a0.value
-        }
-        if (a0?.type === 'TemplateLiteral' && a0.expressions.length === 0) {
-          return a0.quasis.map((q: any) => q.value.cooked).join('')
-        }
-        return
-      })()
-      if (ttl && suiteStack[suiteStack.length - 1] === ttl) {
-        suiteStack.pop()
-      }
-    }
-  })
-
-  return out
-}
-
-/**
- * Capture stack trace and try to find a user frame.
- * Prefer step-definition files, then spec/tests, then feature files.
- */
-export function getCurrentTestLocation() {
-  const frames = parseStackTrace(new Error())
-
-  const pick = (predicate: (f: any) => boolean) => {
-    const f = frames.find((fr) => {
-      const fn = fr.getFileName()
-      return !!fn && !fn.includes('node_modules') && predicate(fr)
-    })
-    return f
-      ? {
-          file: f.getFileName() as string,
-          line: f.getLineNumber() as number,
-          column: f.getColumnNumber() as number
-        }
-      : null
-  }
-
-  const step = pick((fr) => {
-    const fn = fr.getFileName() as string
-    return STEP_FILE_RE.test(fn) || STEP_DIR_RE.test(fn)
-  })
-  if (step) {
-    return step
-  }
-
-  const spec = pick((fr) => SPEC_FILE_RE.test(fr.getFileName() as string))
-  if (spec) {
-    return spec
-  }
-
-  const feature = pick((fr) => FEATURE_FILE_RE.test(fr.getFileName() as string))
-  if (feature) {
-    return feature
-  }
-
-  return null
-}
-
-/**
- * Step-definition discovery and matching (Cucumber)
- */
-
-// Look for step-definitions directory by ascending from a base directory
-function _findStepsDir(startDir: string): string | undefined {
-  let dir = startDir
-  for (let i = 0; i < STEPS_DIR_ASCENT_MAX; i++) {
-    for (const c of STEPS_DIR_CANDIDATES) {
-      const p = path.join(dir, c)
-      if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
-        return p
-      }
-    }
-    const up = path.dirname(dir)
-    if (up === dir) {
-      break
-    }
-    dir = up
-  }
-  return undefined
-}
-
-// Global fallback (find a features/*/(step-definitions|steps) directory under cwd)
-let _globalStepsDir: string | undefined
-function _findStepsDirGlobal(): string | undefined {
-  if (_globalStepsDir && fs.existsSync(_globalStepsDir)) {
-    return _globalStepsDir
-  }
-
-  const root = process.cwd()
-  const queue: { dir: string; depth: number }[] = [{ dir: root, depth: 0 }]
-  const maxDepth = STEPS_GLOBAL_SEARCH_MAX_DEPTH
-  while (queue.length) {
-    const { dir, depth } = queue.shift()!
-    if (depth > maxDepth) {
-      continue
-    }
-
-    // Look for a features folder here
-    const featuresDir = path.join(dir, 'features')
-    if (fs.existsSync(featuresDir) && fs.statSync(featuresDir).isDirectory()) {
-      for (const c of STEPS_DIR_CANDIDATES) {
-        const p = path.join(featuresDir, c)
-        if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
-          _globalStepsDir = p
-          return p
-        }
-      }
-    }
-
-    // BFS into subdirs
-    for (const entry of fs.readdirSync(dir)) {
-      if (entry.startsWith('.')) {
-        continue
-      }
-      const full = path.join(dir, entry)
-      let st: fs.Stats
-      try {
-        st = fs.statSync(full)
-      } catch {
-        continue
-      }
-      if (st.isDirectory() && !full.includes('node_modules')) {
-        queue.push({ dir: full, depth: depth + 1 })
-      }
-    }
-  }
-  return undefined
-}
-
-// Recursively list all source files in a directory
-function _listFiles(dir: string): string[] {
-  const out: string[] = []
-  for (const entry of fs.readdirSync(dir)) {
-    const full = path.join(dir, entry)
-    const st = fs.statSync(full)
-    if (st.isDirectory()) {
-      out.push(..._listFiles(full))
-    } else if (SOURCE_FILE_EXT_RE.test(entry)) {
-      out.push(full)
-    }
-  }
-  return out
-}
-
-// Text fallback: scan a file for step definitions on a single line
-function _collectStepDefsFromText(file: string): StepDef[] {
-  const out: StepDef[] = []
-  const src = fs.readFileSync(file, 'utf-8')
-  const lines = src.split(/\r?\n/)
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    // Regex step: Given(/^...$/i, ...)
-    const mRe = line.match(STEP_DEF_REGEX_LITERAL_RE)
-    if (mRe) {
-      const lit = mRe[2] // like /pattern/flags
-      const lastSlash = lit.lastIndexOf('/')
-      const pattern = lit.slice(1, lastSlash)
-      const flags = lit.slice(lastSlash + 1)
-      try {
-        out.push({
-          kind: 'regex',
-          regex: new RegExp(pattern, flags),
-          file,
-          line: i + 1,
-          column: mRe.index ?? 0
-        })
-        continue
-      } catch {
-        // ignore malformed regex
-      }
-    }
-    // String step: Given('I do X', ...)
-    const mStr = line.match(STEP_DEF_STRING_RE)
-    if (mStr) {
-      const keyword = mStr[1]
-      const text = mStr[3]
-      out.push({
-        kind: 'string',
-        keyword,
-        text,
-        file,
-        line: i + 1,
-        column: mStr.index ?? 0
-      })
-    }
-  }
-  return out
-}
-
-const _stepsCache = new Map<string, StepDef[]>()
-function _collectStepDefs(stepsDir: string): StepDef[] {
-  const cached = _stepsCache.get(stepsDir)
-  if (cached) {
-    return cached
-  }
-
-  const files = _listFiles(stepsDir)
-  const defs: StepDef[] = []
-
-  for (const file of files) {
-    let pushed = 0
-    try {
-      const src = fs.readFileSync(file, 'utf-8')
-      const ast = parse(src, {
-        sourceType: 'module',
-        plugins: PARSE_PLUGINS as any,
-        errorRecovery: true
-      })
-
-      traverse(ast, {
-        CallExpression(p: NodePath<CallExpression>) {
-          const callee: any = p.node.callee
-          // Support Identifier (Given(...)) and MemberExpression (cucumber.Given(...))
-          let name: string | undefined
-          if (callee?.type === 'Identifier') {
-            name = callee.name
-          } else if (callee?.type === 'MemberExpression') {
-            const prop = (callee as any).property
-            if (prop?.type === 'Identifier') {
-              name = prop.name
-            }
-          }
-          if (!name || !(STEP_FN_NAMES as readonly string[]).includes(name)) {
-            return
-          }
-
-          const arg = p.node.arguments?.[0] as any
-          const loc = {
-            file,
-            line: p.node.loc?.start.line ?? 1,
-            column: p.node.loc?.start.column ?? 0
-          }
-
-          if (arg?.type === 'RegExpLiteral') {
-            defs.push({
-              kind: 'regex',
-              regex: new RegExp(arg.pattern, arg.flags ?? ''),
-              ...loc
-            })
-            pushed++
-          } else if (arg?.type === 'StringLiteral') {
-            // If Cucumber Expressions is available and pattern contains {...}, treat as expression
-            if (CE && arg.value.includes('{')) {
-              const expr = new CE!.CucumberExpression(
-                arg.value,
-                new CE!.ParameterTypeRegistry()
-              )
-              defs.push({ kind: 'expression', expr, ...loc })
-            } else {
-              defs.push({
-                kind: 'string',
-                keyword: name,
-                text: arg.value,
-                ...loc
-              })
-            }
-            pushed++
-          }
-        }
-      })
-    } catch {
-      // ignore AST parse errors; fallback below
-    }
-    // If AST found nothing, fallback to text scan for this file
-    if (pushed === 0) {
-      const fromText = _collectStepDefsFromText(file)
-      if (fromText.length) {
-        defs.push(...fromText)
-      }
-    }
-  }
-
-  _stepsCache.set(stepsDir, defs)
-  return defs
-}
-
-function findStepDefinitionLocation(stepTitle: string, hintPath?: string) {
-  const baseDir = hintPath
-    ? path.extname(hintPath)
-      ? path.dirname(hintPath)
-      : hintPath
-    : undefined
-
-  let stepsDir = baseDir ? _findStepsDir(baseDir) : undefined
-  if (!stepsDir) {
-    stepsDir = _findStepsDirGlobal()
-  }
-  if (!stepsDir) {
-    return
-  }
-
-  const defs = _collectStepDefs(stepsDir)
-
-  const title = String(stepTitle ?? '').trim()
-  const titleNoKw = title.replace(/^(Given|When|Then|And|But)\s+/i, '').trim()
-
-  // String match
-  const s = defs.find(
-    (d) =>
-      d.kind === 'string' &&
-      (titleNoKw.localeCompare(d.text!, 'en', { sensitivity: 'base' }) === 0 ||
-        title.localeCompare(`${d.keyword} ${d.text}`, 'en', {
-          sensitivity: 'base'
-        }) === 0)
-  )
-  if (s) {
-    return { file: s.file, line: s.line, column: s.column }
-  }
-
-  // Cucumber expression match
-  const e = defs.find(
-    (d) =>
-      d.kind === 'expression' &&
-      (() => {
-        try {
-          return !!d.expr!.match(titleNoKw) || !!d.expr!.match(title)
-        } catch {
-          return false
-        }
-      })()
-  )
-  if (e) {
-    return { file: e.file, line: e.line, column: e.column }
-  }
-
-  // Regex match
-  const r = defs.find(
-    (d) =>
-      d.kind === 'regex' && (d.regex!.test(titleNoKw) || d.regex!.test(title))
-  )
-  if (r) {
-    return { file: r.file, line: r.line, column: r.column }
-  }
-
-  return
-}
-
-/**
- * Helpers for Mocha/Jasmine mapping
- */
-function normalizeFullTitle(full?: string) {
-  return String(full || '')
-    .replace(/^\d+:\s*/, '') // drop worker prefix like "0: "
-    .replace(/\s+/g, ' ')
-    .trim()
-}
-
-function escapeRegExp(s: string) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-function offsetToLineCol(src: string, offset: number) {
-  let line = 1,
-    col = 1
-  for (let i = 0; i < offset && i < src.length; i++) {
-    if (src.charCodeAt(i) === 10) {
-      line++
-      col = 1
-    } else {
-      col++
-    }
-  }
-  return { line, column: col }
-}
-
-/**
- * Textual fallback: find the test by scanning for it/test/specify(...) with the exact title.
- * Works even if Babel AST couldn’t be built or callee is wrapped.
- */
-function findTestLocationByText(file: string, title: string) {
-  try {
-    const src = fs.readFileSync(file, 'utf-8')
-    const q = `(['"\`])${escapeRegExp(title)}\\1`
-    const call = String.raw`\b(?:${(TEST_FN_NAMES as readonly string[]).join('|')})\s*\(\s*${q}`
-    const re = new RegExp(call)
-    const m = re.exec(src)
-    if (m && typeof m.index === 'number') {
-      const { line, column } = offsetToLineCol(src, m.index)
-      return { file, line, column }
-    }
-  } catch {}
-  return undefined
-}
-
-// Find describe/context/suite("<title>", ...) by text as a fallback
-function findSuiteLocationByText(file: string, title: string) {
-  try {
-    const src = fs.readFileSync(file, 'utf-8')
-    const q = `(['"\`])${escapeRegExp(title)}\\1`
-    const call = String.raw`\b(?:${(SUITE_FN_NAMES as readonly string[]).join('|')})\s*\(\s*${q}`
-    const re = new RegExp(call)
-    const m = re.exec(src)
-    if (m && typeof m.index === 'number') {
-      const { line, column } = offsetToLineCol(src, m.index)
-      return { file, line, column }
-    }
-  } catch {}
-  return undefined
-}
-
-/**
- * Enrich stats:
- * - Cucumber: prefer step-definition file/line
- * - Mocha/Jasmine: AST with suite path; fallback to runtime stack
- */
-export function mapTestToSource(testStats: any, hintFile?: string) {
-  const title = String(testStats?.title ?? '').trim()
-  const fullTitle = normalizeFullTitle(testStats?.fullTitle)
-
-  // Hint for locating related files
-  const hint =
-    (Array.isArray((testStats as any).specs)
-      ? (testStats as any).specs[0]
-      : undefined) ||
-    (testStats as any).file ||
-    (testStats as any).specFile ||
-    hintFile ||
-    CURRENT_SPEC_FILE
-
-  // Cucumber-like step: resolve step-definition location
-  if (/^(Given|When|Then|And|But)\b/i.test(title)) {
-    const stepLoc = findStepDefinitionLocation(
-      title,
-      FEATURE_FILE_RE.test(String(hint)) ? hint : undefined
-    )
-    if (stepLoc) {
-      Object.assign(testStats, stepLoc)
-      return
-    }
-  }
-
-  // Mocha/Jasmine static mapping via AST
-  const file =
-    (testStats as any).file ||
-    (Array.isArray((testStats as any).specs)
-      ? (testStats as any).specs[0]
-      : undefined) ||
-    (testStats as any).specFile ||
-    hintFile ||
-    CURRENT_SPEC_FILE
-
-  if (file && !FEATURE_FILE_RE.test(file)) {
-    if (!_astCache.has(file)) {
-      try {
-        _astCache.set(file, findTestLocations(file))
-      } catch {
-        // ignore parse errors
-      }
-    }
-    const locs = _astCache.get(file) as any[] | undefined
-    if (locs?.length) {
-      const match =
-        locs.find(
-          (l) =>
-            l.type === 'test' &&
-            l.name === title &&
-            fullTitle.includes(l.titlePath.join(' '))
-        ) || locs.find((l) => l.type === 'test' && l.name === title)
-
-      if (match) {
-        Object.assign(testStats, {
-          file,
-          line: match.line,
-          column: match.column
-        })
-        return
-      }
-    }
-
-    // Fallback: plain text search for it/test/specify("<title>")
-    const textLoc = findTestLocationByText(file, title)
-    if (textLoc) {
-      Object.assign(testStats, textLoc)
-      return
-    }
-  }
-
-  // Runtime stack fallback
-  const runtimeLoc = getCurrentTestLocation()
-  if (runtimeLoc) {
-    Object.assign(testStats, runtimeLoc)
-  }
-}
-
-/**
- * Enrich a suite with file + line
- * - Mocha/Jasmine: map "describe/context" by title path using AST
- * - Cucumber: find Feature/Scenario line in .feature file
- */
-export function mapSuiteToSource(
-  suiteStats: any,
-  hintFile?: string,
-  suitePath: string[] = []
-) {
-  const title = String(suiteStats?.title ?? '').trim()
-  const file = (suiteStats as any).file || hintFile || CURRENT_SPEC_FILE
-  if (!title || !file) {
-    return
-  }
-
-  // Cucumber: feature/scenario line
-  if (FEATURE_FILE_RE.test(file)) {
-    try {
-      const src = fs.readFileSync(file, 'utf-8').split(/\r?\n/)
-      const norm = (s: string) => s.trim().replace(/\s+/g, ' ')
-      const want = norm(title)
-      for (let i = 0; i < src.length; i++) {
-        const m = src[i].match(FEATURE_OR_SCENARIO_LINE_RE)
-        if (m && norm(m[2]) === want) {
-          Object.assign(suiteStats, { file, line: i + 1, column: 1 })
-          return
-        }
-      }
-    } catch {}
-    return
-  }
-
-  // Mocha/Jasmine: AST first
-  try {
-    if (!_astCache.has(file)) {
-      _astCache.set(file, findTestLocations(file))
-    }
-    const locs = _astCache.get(file) as any[] | undefined
-    if (locs?.length) {
-      const match =
-        locs.find(
-          (l) =>
-            l.type === 'suite' &&
-            Array.isArray(l.titlePath) &&
-            l.titlePath.length === suitePath.length &&
-            l.titlePath.every((t: string, i: number) => t === suitePath[i])
-        ) ||
-        locs.find((l) => l.type === 'suite' && l.titlePath.at(-1) === title)
-
-      if (match?.line) {
-        Object.assign(suiteStats, {
-          file,
-          line: match.line,
-          column: match.column
-        })
-        return
-      }
-    }
-  } catch {
-    // ignore
-  }
-
-  // Fallback: text search
-  const textLoc = findSuiteLocationByText(file, title)
-  if (textLoc) {
-    Object.assign(suiteStats, textLoc)
-  }
-}
diff --git a/packages/service/src/utils/ast-locations.ts b/packages/service/src/utils/ast-locations.ts
new file mode 100644
index 00000000..4c539c14
--- /dev/null
+++ b/packages/service/src/utils/ast-locations.ts
@@ -0,0 +1,216 @@
+import fs from 'fs'
+import { createRequire } from 'node:module'
+import { parse } from '@babel/parser'
+import type {
+  Node as BabelNode,
+  NodePath,
+  TraverseOptions
+} from '@babel/traverse'
+import type { CallExpression } from '@babel/types'
+import { parse as parseStackTrace } from 'stack-trace'
+
+type CalleeNode =
+  | { type: 'Identifier'; name: string }
+  | { type: 'MemberExpression'; object: { type: string; name?: string } }
+  | { type: string }
+
+type TitleNode =
+  | { type: 'StringLiteral'; value: string }
+  | {
+      type: 'TemplateLiteral'
+      expressions: unknown[]
+      quasis: Array<{ value: { cooked?: string } }>
+    }
+  | { type: string }
+
+interface StackFrameLike {
+  getFileName(): string | null
+  getLineNumber(): number | null
+  getColumnNumber(): number | null
+}
+
+import {
+  PARSE_PLUGINS,
+  TEST_FN_NAMES,
+  SUITE_FN_NAMES,
+  STEP_FILE_RE,
+  STEP_DIR_RE,
+  SPEC_FILE_RE,
+  FEATURE_FILE_RE
+} from '../constants.js'
+
+const require = createRequire(import.meta.url)
+const traverse = (
+  require('@babel/traverse') as {
+    default: (parent: BabelNode, opts?: TraverseOptions) => void
+  }
+).default
+
+export interface Loc {
+  type: 'test' | 'suite'
+  name: string
+  titlePath: string[]
+  line?: number
+  column?: number
+}
+
+function rootCalleeName(callee: CalleeNode | undefined): string | undefined {
+  if (!callee) {
+    return
+  }
+  if (callee.type === 'Identifier') {
+    return (callee as { name: string }).name
+  }
+  if (callee.type === 'MemberExpression') {
+    const obj = (callee as { object: { type: string; name?: string } }).object
+    return obj && obj.type === 'Identifier' ? obj.name : undefined
+  }
+  return
+}
+
+function staticTitle(node: TitleNode | undefined): string | undefined {
+  if (!node) {
+    return
+  }
+  if (node.type === 'StringLiteral') {
+    return (node as { value: string }).value
+  }
+  if (node.type === 'TemplateLiteral') {
+    const tl = node as {
+      expressions: unknown[]
+      quasis: Array<{ value: { cooked?: string } }>
+    }
+    if (tl.expressions.length === 0) {
+      return tl.quasis.map((q) => q.value.cooked ?? '').join('')
+    }
+  }
+  return
+}
+
+const isSuiteFn = (n?: string): boolean =>
+  (!!n && (SUITE_FN_NAMES as readonly string[]).includes(n)) || n === 'Feature'
+const isTestFn = (n?: string): boolean =>
+  !!n && (TEST_FN_NAMES as readonly string[]).includes(n)
+
+function handleEnterCallExpression(
+  p: NodePath<CallExpression>,
+  out: Loc[],
+  suiteStack: string[]
+): void {
+  const root = rootCalleeName(p.node.callee as CalleeNode)
+  if (!root) {
+    return
+  }
+  const ttl = staticTitle(p.node.arguments?.[0] as TitleNode | undefined)
+  if (!ttl) {
+    return
+  }
+  if (isSuiteFn(root)) {
+    out.push({
+      type: 'suite',
+      name: ttl,
+      titlePath: [...suiteStack, ttl],
+      line: p.node.loc?.start.line,
+      column: p.node.loc?.start.column
+    })
+    suiteStack.push(ttl)
+  } else if (isTestFn(root)) {
+    out.push({
+      type: 'test',
+      name: ttl,
+      titlePath: [...suiteStack, ttl],
+      line: p.node.loc?.start.line,
+      column: p.node.loc?.start.column
+    })
+  }
+}
+
+function handleExitCallExpression(
+  p: NodePath<CallExpression>,
+  suiteStack: string[]
+): void {
+  const root = rootCalleeName(p.node.callee as CalleeNode)
+  if (!root || !isSuiteFn(root)) {
+    return
+  }
+  const ttl = staticTitle(p.node.arguments?.[0] as TitleNode | undefined)
+  if (ttl && suiteStack[suiteStack.length - 1] === ttl) {
+    suiteStack.pop()
+  }
+}
+
+/** Parse a JS/TS test/spec file and collect suite/test calls (Mocha/Jasmine)
+ *  with full title paths. */
+export function findTestLocations(filePath: string): Loc[] {
+  if (!fs.existsSync(filePath)) {
+    return []
+  }
+  const src = fs.readFileSync(filePath, 'utf-8')
+  const ast = parse(src, {
+    sourceType: 'module',
+    plugins: [...PARSE_PLUGINS],
+    errorRecovery: true,
+    allowReturnOutsideFunction: true
+  })
+
+  const out: Loc[] = []
+  const suiteStack: string[] = []
+  traverse(ast, {
+    enter(p) {
+      if (p.isCallExpression()) {
+        handleEnterCallExpression(p, out, suiteStack)
+      }
+    },
+    exit(p) {
+      if (p.isCallExpression()) {
+        handleExitCallExpression(p, suiteStack)
+      }
+    }
+  })
+
+  return out
+}
+
+/** Capture a stack trace and pick a user frame. Prefers step-definition
+ *  files, then specs, then `.feature` files. */
+export function getCurrentTestLocation(): {
+  file: string
+  line: number
+  column: number
+} | null {
+  const frames = parseStackTrace(new Error())
+
+  const pick = (predicate: (f: StackFrameLike) => boolean) => {
+    const f = frames.find((fr) => {
+      const fn = fr.getFileName()
+      return !!fn && !fn.includes('node_modules') && predicate(fr)
+    })
+    return f
+      ? {
+          file: f.getFileName() as string,
+          line: f.getLineNumber() as number,
+          column: f.getColumnNumber() as number
+        }
+      : null
+  }
+
+  const step = pick((fr) => {
+    const fn = fr.getFileName() as string
+    return STEP_FILE_RE.test(fn) || STEP_DIR_RE.test(fn)
+  })
+  if (step) {
+    return step
+  }
+
+  const spec = pick((fr) => SPEC_FILE_RE.test(fr.getFileName() as string))
+  if (spec) {
+    return spec
+  }
+
+  const feature = pick((fr) => FEATURE_FILE_RE.test(fr.getFileName() as string))
+  if (feature) {
+    return feature
+  }
+
+  return null
+}
diff --git a/packages/service/src/utils/source-mapping.ts b/packages/service/src/utils/source-mapping.ts
new file mode 100644
index 00000000..51fe3d85
--- /dev/null
+++ b/packages/service/src/utils/source-mapping.ts
@@ -0,0 +1,291 @@
+import fs from 'fs'
+
+import {
+  TEST_FN_NAMES,
+  SUITE_FN_NAMES,
+  FEATURE_FILE_RE,
+  FEATURE_OR_SCENARIO_LINE_RE
+} from '../constants.js'
+import { findStepDefinitionLocation } from './step-defs.js'
+import {
+  findTestLocations,
+  getCurrentTestLocation,
+  type Loc
+} from './ast-locations.js'
+
+export { findTestLocations, getCurrentTestLocation }
+
+// ── Spec-file pointer + AST cache ───────────────────────────────────────────
+let CURRENT_SPEC_FILE: string | undefined
+export function setCurrentSpecFile(file?: string) {
+  CURRENT_SPEC_FILE = file
+}
+
+const _astCache = new Map<string, Loc[]>()
+
+// ── Text fallback helpers ───────────────────────────────────────────────────
+function normalizeFullTitle(full?: string): string {
+  return String(full || '')
+    .replace(/^\d+:\s*/, '') // drop worker prefix like "0: "
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function offsetToLineCol(
+  src: string,
+  offset: number
+): { line: number; column: number } {
+  let line = 1
+  let col = 1
+  for (let i = 0; i < offset && i < src.length; i++) {
+    if (src.charCodeAt(i) === 10) {
+      line++
+      col = 1
+    } else {
+      col++
+    }
+  }
+  return { line, column: col }
+}
+
+/** Textual fallback for the AST scan: find it/test/specify("<title>", ...). */
+function findTestLocationByText(
+  file: string,
+  title: string
+): { file: string; line: number; column: number } | undefined {
+  try {
+    const src = fs.readFileSync(file, 'utf-8')
+    const q = `(['"\`])${escapeRegExp(title)}\\1`
+    const call = String.raw`\b(?:${(TEST_FN_NAMES as readonly string[]).join('|')})\s*\(\s*${q}`
+    const re = new RegExp(call)
+    const m = re.exec(src)
+    if (m && typeof m.index === 'number') {
+      const { line, column } = offsetToLineCol(src, m.index)
+      return { file, line, column }
+    }
+  } catch {
+    /* unreadable file */
+  }
+  return undefined
+}
+
+function findSuiteLocationByText(
+  file: string,
+  title: string
+): { file: string; line: number; column: number } | undefined {
+  try {
+    const src = fs.readFileSync(file, 'utf-8')
+    const q = `(['"\`])${escapeRegExp(title)}\\1`
+    const call = String.raw`\b(?:${(SUITE_FN_NAMES as readonly string[]).join('|')})\s*\(\s*${q}`
+    const re = new RegExp(call)
+    const m = re.exec(src)
+    if (m && typeof m.index === 'number') {
+      const { line, column } = offsetToLineCol(src, m.index)
+      return { file, line, column }
+    }
+  } catch {
+    /* unreadable file */
+  }
+  return undefined
+}
+
+// ── Stats enrichers ─────────────────────────────────────────────────────────
+/**
+ * Subset of stats fields {@link mapTestToSource}/{@link mapSuiteToSource}
+ * read. The wdio reporter's TestStats/SuiteStats classes carry many more
+ * fields (hooks, retries, etc.) that vary by reporter version, so the
+ * function parameters stay `unknown` and we narrow internally with one cast
+ * per call instead of per-field `as any` sprinkled through the body.
+ */
+interface StatsHintShape {
+  title?: string
+  fullTitle?: string
+  file?: string
+  specFile?: string
+  specs?: string[]
+}
+
+const asHint = (stats: unknown): StatsHintShape =>
+  (stats ?? {}) as StatsHintShape
+
+/** Pull the most-relevant hint path from a stats fragment. Falls through:
+ *  specs[0] → file → specFile → caller hint → tracked current spec file. */
+function hintFromStats(
+  stats: StatsHintShape,
+  hintFile: string | undefined
+): string | undefined {
+  if (Array.isArray(stats.specs) && stats.specs[0]) {
+    return stats.specs[0]
+  }
+  return stats.file || stats.specFile || hintFile || CURRENT_SPEC_FILE
+}
+
+/**
+ * Enrich test stats with `file`/`line`/`column`:
+ *  - Cucumber: prefer step-definition file/line
+ *  - Mocha/Jasmine: AST with suite path; fallback to runtime stack
+ */
+function resolveTestFromAst(
+  file: string,
+  title: string,
+  fullTitle: string
+): { file: string; line?: number; column?: number } | undefined {
+  if (!_astCache.has(file)) {
+    try {
+      _astCache.set(file, findTestLocations(file))
+    } catch {
+      /* parse errors */
+    }
+  }
+  const locs = _astCache.get(file)
+  if (!locs?.length) {
+    return undefined
+  }
+  const match =
+    locs.find(
+      (l) =>
+        l.type === 'test' &&
+        l.name === title &&
+        fullTitle.includes(l.titlePath.join(' '))
+    ) || locs.find((l) => l.type === 'test' && l.name === title)
+  if (!match) {
+    return undefined
+  }
+  return { file, line: match.line, column: match.column }
+}
+
+export function mapTestToSource(testStats: unknown, hintFile?: string): void {
+  const t = asHint(testStats)
+  const title = String(t.title ?? '').trim()
+  const fullTitle = normalizeFullTitle(t.fullTitle)
+
+  // Cucumber-like step: resolve step-definition location
+  if (/^(Given|When|Then|And|But)\b/i.test(title)) {
+    const hint = hintFromStats(t, hintFile)
+    const stepLoc = findStepDefinitionLocation(
+      title,
+      hint && FEATURE_FILE_RE.test(hint) ? hint : undefined
+    )
+    if (stepLoc) {
+      Object.assign(testStats as object, stepLoc)
+      return
+    }
+  }
+
+  // Mocha/Jasmine static mapping via AST. The .file-first fallback ORDER
+  // here matches the previous behavior — .file beats .specs[0].
+  const file =
+    t.file ||
+    (Array.isArray(t.specs) ? t.specs[0] : undefined) ||
+    t.specFile ||
+    hintFile ||
+    CURRENT_SPEC_FILE
+
+  if (file && !FEATURE_FILE_RE.test(file)) {
+    const astLoc = resolveTestFromAst(file, title, fullTitle)
+    if (astLoc) {
+      Object.assign(testStats as object, astLoc)
+      return
+    }
+    const textLoc = findTestLocationByText(file, title)
+    if (textLoc) {
+      Object.assign(testStats as object, textLoc)
+      return
+    }
+  }
+
+  const runtimeLoc = getCurrentTestLocation()
+  if (runtimeLoc) {
+    Object.assign(testStats as object, runtimeLoc)
+  }
+}
+
+/**
+ * Enrich a suite with file/line:
+ *  - Mocha/Jasmine: map describe/context by title path using AST
+ *  - Cucumber: find Feature/Scenario line in .feature file
+ */
+function mapFeatureSuiteFromFile(
+  file: string,
+  title: string
+): { file: string; line: number; column: number } | undefined {
+  try {
+    const src = fs.readFileSync(file, 'utf-8').split(/\r?\n/)
+    const norm = (s: string) => s.trim().replace(/\s+/g, ' ')
+    const want = norm(title)
+    for (let i = 0; i < src.length; i++) {
+      const m = src[i].match(FEATURE_OR_SCENARIO_LINE_RE)
+      if (m && norm(m[2]) === want) {
+        return { file, line: i + 1, column: 1 }
+      }
+    }
+  } catch {
+    /* unreadable file */
+  }
+  return undefined
+}
+
+function resolveSuiteFromAst(
+  file: string,
+  title: string,
+  suitePath: string[]
+): { file: string; line?: number; column?: number } | undefined {
+  try {
+    if (!_astCache.has(file)) {
+      _astCache.set(file, findTestLocations(file))
+    }
+    const locs = _astCache.get(file)
+    if (!locs?.length) {
+      return undefined
+    }
+    const match =
+      locs.find(
+        (l) =>
+          l.type === 'suite' &&
+          Array.isArray(l.titlePath) &&
+          l.titlePath.length === suitePath.length &&
+          l.titlePath.every((t: string, i: number) => t === suitePath[i])
+      ) || locs.find((l) => l.type === 'suite' && l.titlePath.at(-1) === title)
+    if (match?.line) {
+      return { file, line: match.line, column: match.column }
+    }
+  } catch {
+    /* ignore */
+  }
+  return undefined
+}
+
+export function mapSuiteToSource(
+  suiteStats: unknown,
+  hintFile?: string,
+  suitePath: string[] = []
+): void {
+  const s = asHint(suiteStats)
+  const title = String(s.title ?? '').trim()
+  const file = s.file || hintFile || CURRENT_SPEC_FILE
+  if (!title || !file) {
+    return
+  }
+  if (FEATURE_FILE_RE.test(file)) {
+    const featureLoc = mapFeatureSuiteFromFile(file, title)
+    if (featureLoc) {
+      Object.assign(suiteStats as object, featureLoc)
+    }
+    return
+  }
+  const astLoc = resolveSuiteFromAst(file, title, suitePath)
+  if (astLoc) {
+    Object.assign(suiteStats as object, astLoc)
+    return
+  }
+
+  // Fallback: text search
+  const textLoc = findSuiteLocationByText(file, title)
+  if (textLoc) {
+    Object.assign(suiteStats as object, textLoc)
+  }
+}
diff --git a/packages/service/src/utils/step-defs.ts b/packages/service/src/utils/step-defs.ts
new file mode 100644
index 00000000..1f07fe8f
--- /dev/null
+++ b/packages/service/src/utils/step-defs.ts
@@ -0,0 +1,348 @@
+import fs from 'fs'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import { parse } from '@babel/parser'
+import type {
+  Node as BabelNode,
+  NodePath,
+  TraverseOptions
+} from '@babel/traverse'
+import type { CallExpression, Identifier, MemberExpression } from '@babel/types'
+
+import {
+  PARSE_PLUGINS,
+  STEP_FN_NAMES,
+  STEP_DEF_REGEX_LITERAL_RE,
+  STEP_DEF_STRING_RE,
+  SOURCE_FILE_EXT_RE,
+  STEPS_DIR_CANDIDATES,
+  STEPS_DIR_ASCENT_MAX,
+  STEPS_GLOBAL_SEARCH_MAX_DEPTH
+} from '../constants.js'
+import type { StepDef } from '../types.js'
+
+const require = createRequire(import.meta.url)
+const traverse = (
+  require('@babel/traverse') as {
+    default: (parent: BabelNode, opts?: TraverseOptions) => void
+  }
+).default
+
+// @cucumber/cucumber-expressions is an optional peer; load lazily. The
+// constructor types vary across versions, so we keep the shapes minimal —
+// only the constructor signatures we actually call.
+interface CucumberExpressionInstance {
+  match(text: string): unknown
+}
+interface CucumberExpressionsModule {
+  CucumberExpression: new (
+    pattern: string,
+    registry: ParameterTypeRegistryInstance
+  ) => CucumberExpressionInstance
+  ParameterTypeRegistry: new () => ParameterTypeRegistryInstance
+}
+type ParameterTypeRegistryInstance = object
+
+let CE: CucumberExpressionsModule | undefined
+try {
+  const ce = require('@cucumber/cucumber-expressions')
+  CE = {
+    CucumberExpression: ce.CucumberExpression,
+    ParameterTypeRegistry: ce.ParameterTypeRegistry
+  }
+} catch {
+  /* optional */
+}
+
+// Ascending search from a starting directory.
+function findStepsDir(startDir: string): string | undefined {
+  let dir = startDir
+  for (let i = 0; i < STEPS_DIR_ASCENT_MAX; i++) {
+    for (const c of STEPS_DIR_CANDIDATES) {
+      const p = path.join(dir, c)
+      if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+        return p
+      }
+    }
+    const up = path.dirname(dir)
+    if (up === dir) {
+      break
+    }
+    dir = up
+  }
+  return undefined
+}
+
+// BFS under cwd for a features/*/(step-definitions|steps) directory.
+let globalStepsDir: string | undefined
+function findStepsDirGlobal(): string | undefined {
+  if (globalStepsDir && fs.existsSync(globalStepsDir)) {
+    return globalStepsDir
+  }
+
+  const root = process.cwd()
+  const queue: { dir: string; depth: number }[] = [{ dir: root, depth: 0 }]
+  const maxDepth = STEPS_GLOBAL_SEARCH_MAX_DEPTH
+  while (queue.length) {
+    const { dir, depth } = queue.shift()!
+    if (depth > maxDepth) {
+      continue
+    }
+
+    const featuresDir = path.join(dir, 'features')
+    if (fs.existsSync(featuresDir) && fs.statSync(featuresDir).isDirectory()) {
+      for (const c of STEPS_DIR_CANDIDATES) {
+        const p = path.join(featuresDir, c)
+        if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+          globalStepsDir = p
+          return p
+        }
+      }
+    }
+
+    for (const entry of fs.readdirSync(dir)) {
+      if (entry.startsWith('.')) {
+        continue
+      }
+      const full = path.join(dir, entry)
+      let st: fs.Stats
+      try {
+        st = fs.statSync(full)
+      } catch {
+        continue
+      }
+      if (st.isDirectory() && !full.includes('node_modules')) {
+        queue.push({ dir: full, depth: depth + 1 })
+      }
+    }
+  }
+  return undefined
+}
+
+function listFiles(dir: string): string[] {
+  const out: string[] = []
+  for (const entry of fs.readdirSync(dir)) {
+    const full = path.join(dir, entry)
+    const st = fs.statSync(full)
+    if (st.isDirectory()) {
+      out.push(...listFiles(full))
+    } else if (SOURCE_FILE_EXT_RE.test(entry)) {
+      out.push(full)
+    }
+  }
+  return out
+}
+
+// Text fallback: scan a file for step definitions on a single line.
+function collectStepDefsFromText(file: string): StepDef[] {
+  const out: StepDef[] = []
+  const src = fs.readFileSync(file, 'utf-8')
+  const lines = src.split(/\r?\n/)
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const mRe = line.match(STEP_DEF_REGEX_LITERAL_RE)
+    if (mRe) {
+      const lit = mRe[2]
+      const lastSlash = lit.lastIndexOf('/')
+      const pattern = lit.slice(1, lastSlash)
+      const flags = lit.slice(lastSlash + 1)
+      try {
+        out.push({
+          kind: 'regex',
+          regex: new RegExp(pattern, flags),
+          file,
+          line: i + 1,
+          column: mRe.index ?? 0
+        })
+        continue
+      } catch {
+        /* malformed regex */
+      }
+    }
+    const mStr = line.match(STEP_DEF_STRING_RE)
+    if (mStr) {
+      const keyword = mStr[1]
+      const text = mStr[3]
+      out.push({
+        kind: 'string',
+        keyword,
+        text,
+        file,
+        line: i + 1,
+        column: mStr.index ?? 0
+      })
+    }
+  }
+  return out
+}
+
+type StepArg =
+  | { type: 'RegExpLiteral'; pattern: string; flags?: string }
+  | { type: 'StringLiteral'; value: string }
+  | { type: string }
+
+function calleeName(callee: CallExpression['callee']): string | undefined {
+  if (callee.type === 'Identifier') {
+    return (callee as Identifier).name
+  }
+  if (callee.type === 'MemberExpression') {
+    const prop = (callee as MemberExpression).property
+    if (prop.type === 'Identifier') {
+      return (prop as Identifier).name
+    }
+  }
+  return undefined
+}
+
+function pushStepDefFromArg(
+  name: string,
+  arg: StepArg | undefined,
+  loc: { file: string; line: number; column: number },
+  defs: StepDef[]
+): boolean {
+  if (arg?.type === 'RegExpLiteral') {
+    const re = arg as { pattern: string; flags?: string }
+    defs.push({
+      kind: 'regex',
+      regex: new RegExp(re.pattern, re.flags ?? ''),
+      ...loc
+    })
+    return true
+  }
+  if (arg?.type === 'StringLiteral') {
+    const sl = arg as { value: string }
+    if (CE && sl.value.includes('{')) {
+      const expr = new CE!.CucumberExpression(
+        sl.value,
+        new CE!.ParameterTypeRegistry()
+      )
+      defs.push({ kind: 'expression', expr, ...loc })
+    } else {
+      defs.push({ kind: 'string', keyword: name, text: sl.value, ...loc })
+    }
+    return true
+  }
+  return false
+}
+
+function collectStepDefsFromFile(file: string, defs: StepDef[]): number {
+  let pushed = 0
+  try {
+    const src = fs.readFileSync(file, 'utf-8')
+    const ast = parse(src, {
+      sourceType: 'module',
+      plugins: [...PARSE_PLUGINS],
+      errorRecovery: true
+    })
+    traverse(ast, {
+      CallExpression(p: NodePath<CallExpression>) {
+        const name = calleeName(p.node.callee)
+        if (!name || !(STEP_FN_NAMES as readonly string[]).includes(name)) {
+          return
+        }
+        const arg = p.node.arguments?.[0] as StepArg | undefined
+        const loc = {
+          file,
+          line: p.node.loc?.start.line ?? 1,
+          column: p.node.loc?.start.column ?? 0
+        }
+        if (pushStepDefFromArg(name, arg, loc, defs)) {
+          pushed++
+        }
+      }
+    })
+  } catch {
+    /* AST errors fall through to text scan */
+  }
+  return pushed
+}
+
+const stepsCache = new Map<string, StepDef[]>()
+function collectStepDefs(stepsDir: string): StepDef[] {
+  const cached = stepsCache.get(stepsDir)
+  if (cached) {
+    return cached
+  }
+  const files = listFiles(stepsDir)
+  const defs: StepDef[] = []
+  for (const file of files) {
+    const pushed = collectStepDefsFromFile(file, defs)
+    if (pushed === 0) {
+      const fromText = collectStepDefsFromText(file)
+      if (fromText.length) {
+        defs.push(...fromText)
+      }
+    }
+  }
+  stepsCache.set(stepsDir, defs)
+  return defs
+}
+
+/**
+ * Resolve a step title (e.g. `Given I open the app`) to the file:line where
+ * the Cucumber step definition is declared. Walks up from `hintPath` first
+ * (per-feature step dirs), then falls back to a global BFS under cwd.
+ */
+export function findStepDefinitionLocation(
+  stepTitle: string,
+  hintPath?: string
+): { file: string; line: number; column: number } | undefined {
+  const baseDir = hintPath
+    ? path.extname(hintPath)
+      ? path.dirname(hintPath)
+      : hintPath
+    : undefined
+
+  let stepsDir = baseDir ? findStepsDir(baseDir) : undefined
+  if (!stepsDir) {
+    stepsDir = findStepsDirGlobal()
+  }
+  if (!stepsDir) {
+    return
+  }
+
+  const defs = collectStepDefs(stepsDir)
+  const title = String(stepTitle ?? '').trim()
+  const titleNoKw = title.replace(/^(Given|When|Then|And|But)\s+/i, '').trim()
+  const match = matchStepDef(defs, title, titleNoKw)
+  if (match) {
+    return { file: match.file, line: match.line, column: match.column }
+  }
+  return
+}
+
+function matchStepDef(
+  defs: StepDef[],
+  title: string,
+  titleNoKw: string
+): StepDef | undefined {
+  const s = defs.find(
+    (d) =>
+      d.kind === 'string' &&
+      (titleNoKw.localeCompare(d.text!, 'en', { sensitivity: 'base' }) === 0 ||
+        title.localeCompare(`${d.keyword} ${d.text}`, 'en', {
+          sensitivity: 'base'
+        }) === 0)
+  )
+  if (s) {
+    return s
+  }
+  const e = defs.find(
+    (d) =>
+      d.kind === 'expression' &&
+      (() => {
+        try {
+          return !!d.expr!.match(titleNoKw) || !!d.expr!.match(title)
+        } catch {
+          return false
+        }
+      })()
+  )
+  if (e) {
+    return e
+  }
+  return defs.find(
+    (d) =>
+      d.kind === 'regex' && (d.regex!.test(titleNoKw) || d.regex!.test(title))
+  )
+}
diff --git a/packages/service/src/video-encoder.ts b/packages/service/src/video-encoder.ts
deleted file mode 100644
index d92cc02f..00000000
--- a/packages/service/src/video-encoder.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import os from 'node:os'
-import { createRequire } from 'node:module'
-
-import logger from '@wdio/logger'
-
-import type { ScreencastFrame, ScreencastOptions } from './types.js'
-
-// fluent-ffmpeg uses `export =` (CommonJS). With module:NodeNext, dynamic
-// import() of such modules doesn't resolve .default correctly in TypeScript.
-// createRequire is the idiomatic way to load CJS modules in ESM.
-const require = createRequire(import.meta.url)
-
-const log = logger('@wdio/devtools-service:VideoEncoder')
-
-/**
- * Encodes an array of CDP screencast frames into a .webm video file using
- * ffmpeg (via fluent-ffmpeg) and the VP8 codec (libvpx).
- *
- * Strategy:
- *   1. Write each frame as a JPEG (or PNG) file in a temp directory.
- *   2. Write an ffconcat manifest that assigns each frame its exact display
- *      duration based on the inter-frame timestamp delta. This produces a
- *      variable-frame-rate video that accurately reflects real timing even
- *      when commands cause long pauses between frames.
- *   3. Run ffmpeg with the concat demuxer → libvpx (VP8) → .webm output.
- *   4. Clean up the temp directory regardless of success or failure.
- *
- * @throws If no frames are provided, if fluent-ffmpeg is not installed, or if
- *         the ffmpeg binary is not found on PATH.
- */
-export async function encodeToVideo(
-  frames: ScreencastFrame[],
-  outputPath: string,
-  options: Pick<ScreencastOptions, 'captureFormat'> = {}
-): Promise<void> {
-  if (frames.length === 0) {
-    throw new Error('VideoEncoder: no frames to encode')
-  }
-
-  // Load fluent-ffmpeg via require so TypeScript is happy with the export=
-  // style module. Wrap in try/catch for a clear missing-package message.
-  // fluent-ffmpeg is an optional peer dependency so we use `any` here.
-
-  let ffmpeg: any
-  try {
-    ffmpeg = require('fluent-ffmpeg')
-  } catch {
-    throw new Error(
-      'VideoEncoder: fluent-ffmpeg is required for screencast encoding. ' +
-        'Install it with: npm install fluent-ffmpeg'
-    )
-  }
-
-  const ext = options.captureFormat === 'png' ? 'png' : 'jpg'
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'wdio-screencast-'))
-
-  try {
-    // ── Step 1: write frame files ──────────────────────────────────────────
-    const manifestLines: string[] = ['ffconcat version 1.0']
-
-    for (let i = 0; i < frames.length; i++) {
-      const frameName = `frame-${String(i).padStart(6, '0')}.${ext}`
-      const framePath = path.join(tmpDir, frameName)
-
-      await fs.writeFile(framePath, Buffer.from(frames[i].data, 'base64'))
-
-      // Duration = time until the NEXT frame (or 100 ms for the last frame).
-      const nextTs = frames[i + 1]?.timestamp ?? frames[i].timestamp + 100
-      const durationSecs = Math.max((nextTs - frames[i].timestamp) / 1000, 0.01)
-
-      manifestLines.push(`file '${framePath}'`)
-      manifestLines.push(`duration ${durationSecs.toFixed(6)}`)
-    }
-
-    // ffconcat requires the last file entry to be listed a second time without
-    // a duration so the muxer knows where the last frame ends.
-    const lastFramePath = path.join(
-      tmpDir,
-      `frame-${String(frames.length - 1).padStart(6, '0')}.${ext}`
-    )
-    manifestLines.push(`file '${lastFramePath}'`)
-
-    const manifestPath = path.join(tmpDir, 'manifest.txt')
-    await fs.writeFile(manifestPath, manifestLines.join('\n'))
-
-    // ── Step 2: encode with ffmpeg ─────────────────────────────────────────
-    log.info(`VideoEncoder: encoding ${frames.length} frames → ${outputPath}`)
-
-    await new Promise<void>((resolve, reject) => {
-      ffmpeg()
-        .input(manifestPath)
-        .inputOptions(['-f', 'concat', '-safe', '0'])
-        // VP8 (libvpx) produces broadly compatible WebM that plays in Chrome,
-        // Firefox, VS Code's built-in media player, and most video players.
-        // VP9 CRF mode has widespread issues with incorrect color-space metadata
-        // (bt470bg instead of bt709) and missing stream PTS that cause players to
-        // report "invalid file" even when the container is well-formed.
-        .videoCodec('libvpx')
-        .outputOptions([
-          // 1 Mbit/s target — good quality at reasonable file size for screencasts
-          '-b:v',
-          '1M',
-          // Standard chroma subsampling required for VP8
-          '-pix_fmt',
-          'yuv420p',
-          // Preserve the variable frame rate from the concat manifest timestamps.
-          // Without this ffmpeg re-timestamps frames to a fixed rate and the
-          // per-frame durations written in the manifest are ignored.
-          '-vsync',
-          'vfr',
-          // Disable alt-ref frames — required for WebM muxer compatibility
-          '-auto-alt-ref',
-          '0',
-          // Mark the video stream as the default track so Chrome/VS Code
-          // select it automatically without needing an explicit track selection
-          '-disposition:v',
-          'default'
-        ])
-        .output(outputPath)
-        .on('end', () => resolve())
-        .on('error', (err: Error) => {
-          const msg = err.message || ''
-          if (
-            msg.includes('Cannot find ffmpeg') ||
-            msg.includes('ENOENT') ||
-            msg.includes('spawn') ||
-            msg.includes('not found')
-          ) {
-            reject(
-              new Error(
-                'VideoEncoder: ffmpeg binary not found on PATH. ' +
-                  'Install ffmpeg: https://ffmpeg.org/download.html'
-              )
-            )
-          } else {
-            reject(new Error(`VideoEncoder: ffmpeg error — ${msg}`))
-          }
-        })
-        .run()
-    })
-
-    log.info(`✓ Screencast video saved: ${outputPath}`)
-  } finally {
-    // Always clean up temp files, even if encoding failed.
-    await fs.rm(tmpDir, { recursive: true, force: true }).catch((rmErr) => {
-      log.warn(`VideoEncoder: failed to clean temp dir — ${rmErr.message}`)
-    })
-  }
-}
diff --git a/packages/service/tests/ast-locations.test.ts b/packages/service/tests/ast-locations.test.ts
new file mode 100644
index 00000000..0a36d87c
--- /dev/null
+++ b/packages/service/tests/ast-locations.test.ts
@@ -0,0 +1,211 @@
+import { describe, it, expect, afterAll } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import {
+  findTestLocations,
+  getCurrentTestLocation
+} from '../src/utils/ast-locations.js'
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wdio-ast-loc-'))
+
+afterAll(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+function writeFile(name: string, content: string): string {
+  const p = path.join(tmpDir, name)
+  fs.writeFileSync(p, content, 'utf-8')
+  return p
+}
+
+describe('findTestLocations', () => {
+  it('returns [] for non-existent files', () => {
+    expect(findTestLocations('/nonexistent/path.spec.ts')).toEqual([])
+  })
+
+  it('captures Mocha describe + it calls with line numbers', () => {
+    const file = writeFile(
+      'mocha.spec.ts',
+      [
+        "describe('Login', () => {",
+        "  it('signs in', () => {})",
+        "  it('signs out', () => {})",
+        '})',
+        ''
+      ].join('\n')
+    )
+    const locs = findTestLocations(file)
+    expect(locs).toHaveLength(3)
+    expect(locs[0]).toMatchObject({
+      type: 'suite',
+      name: 'Login',
+      titlePath: ['Login'],
+      line: 1
+    })
+    expect(locs[1]).toMatchObject({
+      type: 'test',
+      name: 'signs in',
+      titlePath: ['Login', 'signs in'],
+      line: 2
+    })
+    expect(locs[2]).toMatchObject({
+      type: 'test',
+      name: 'signs out',
+      titlePath: ['Login', 'signs out'],
+      line: 3
+    })
+  })
+
+  it('builds nested titlePath through nested describes', () => {
+    const file = writeFile(
+      'nested.spec.ts',
+      [
+        "describe('Outer', () => {",
+        "  describe('Inner', () => {",
+        "    it('passes', () => {})",
+        '  })',
+        '})',
+        ''
+      ].join('\n')
+    )
+    const locs = findTestLocations(file)
+    const test = locs.find((l) => l.type === 'test')
+    expect(test?.titlePath).toEqual(['Outer', 'Inner', 'passes'])
+  })
+
+  it('pops suite stack on exit so siblings keep correct path', () => {
+    const file = writeFile(
+      'siblings.spec.ts',
+      [
+        "describe('A', () => {",
+        "  it('a1', () => {})",
+        '})',
+        "describe('B', () => {",
+        "  it('b1', () => {})",
+        '})',
+        ''
+      ].join('\n')
+    )
+    const locs = findTestLocations(file)
+    const tests = locs.filter((l) => l.type === 'test')
+    expect(tests[0].titlePath).toEqual(['A', 'a1'])
+    expect(tests[1].titlePath).toEqual(['B', 'b1'])
+  })
+
+  it('supports Jasmine `xit` and `fit` via TEST_FN_NAMES', () => {
+    const file = writeFile(
+      'jasmine.spec.ts',
+      ["describe('Pending', () => {", "  it('runs', () => {})", '})', ''].join(
+        '\n'
+      )
+    )
+    const locs = findTestLocations(file)
+    expect(locs.find((l) => l.name === 'runs')).toBeDefined()
+  })
+
+  it('ignores test() calls with non-static (template) titles only when expressions are non-empty', () => {
+    const file = writeFile(
+      'dynamic.spec.ts',
+      [
+        'const x = 1',
+        "describe('Dynamic', () => {",
+        '  it(`run ${x}`, () => {})',
+        "  it('static', () => {})",
+        '})',
+        ''
+      ].join('\n')
+    )
+    const locs = findTestLocations(file)
+    // template literal with expression → skipped; only the static title is captured
+    const tests = locs.filter((l) => l.type === 'test')
+    expect(tests).toHaveLength(1)
+    expect(tests[0].name).toBe('static')
+  })
+
+  it('extracts titles from no-expression template literals', () => {
+    const file = writeFile(
+      'template.spec.ts',
+      [
+        "describe('TL', () => {",
+        '  it(`hello world`, () => {})',
+        '})',
+        ''
+      ].join('\n')
+    )
+    const locs = findTestLocations(file)
+    const test = locs.find((l) => l.type === 'test')
+    expect(test?.name).toBe('hello world')
+  })
+
+  it('handles Cucumber-style "Feature" identifier as a suite root', () => {
+    const file = writeFile(
+      'feature.spec.ts',
+      ["Feature('Auth', () => {", "  it('logs in', () => {})", '})', ''].join(
+        '\n'
+      )
+    )
+    const locs = findTestLocations(file)
+    const feature = locs.find((l) => l.type === 'suite' && l.name === 'Auth')
+    expect(feature).toBeDefined()
+  })
+
+  it('parses files with minor syntactic noise via errorRecovery', () => {
+    // A stray identifier between tests — babel's errorRecovery should keep
+    // going and still capture the surrounding test calls.
+    const file = writeFile(
+      'noisy.spec.ts',
+      [
+        "describe('Noisy', () => {",
+        "  it('first', () => {})",
+        '  stray-identifier',
+        "  it('second', () => {})",
+        '})',
+        ''
+      ].join('\n')
+    )
+    // Babel may still throw on some errors; either it parses (returns locs)
+    // or throws — both behaviors are acceptable. The contract this test
+    // pins is that the FIRST test is still discoverable when parse succeeds.
+    let locs: ReturnType<typeof findTestLocations> = []
+    try {
+      locs = findTestLocations(file)
+    } catch {
+      /* parse failed completely — acceptable */
+    }
+    if (locs.length > 0) {
+      expect(locs.find((l) => l.name === 'first')).toBeDefined()
+    }
+  })
+
+  it('returns no locations for a file with no test calls', () => {
+    const file = writeFile(
+      'utils.ts',
+      ['export function helper() { return 1 }', ''].join('\n')
+    )
+    expect(findTestLocations(file)).toEqual([])
+  })
+
+  it('skips calls with non-static argument shapes', () => {
+    const file = writeFile(
+      'nonstatic.spec.ts',
+      [
+        "const title = 'dyn'",
+        'describe(title, () => {})',
+        "describe('Static', () => {})",
+        ''
+      ].join('\n')
+    )
+    const locs = findTestLocations(file)
+    expect(locs.map((l) => l.name)).toEqual(['Static'])
+  })
+})
+
+describe('getCurrentTestLocation', () => {
+  it('returns null when no spec/step/feature frame is on the stack', () => {
+    // Called directly from test code (the test file is a .test.ts spec but
+    // SPEC_FILE_RE may or may not match it depending on the regex). Either
+    // way, the function should not throw.
+    expect(() => getCurrentTestLocation()).not.toThrow()
+  })
+})
diff --git a/packages/service/tests/index.test.ts b/packages/service/tests/index.test.ts
index 59338114..6d2a56ff 100644
--- a/packages/service/tests/index.test.ts
+++ b/packages/service/tests/index.test.ts
@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type * as DevtoolsCore from '@wdio/devtools-core'
 import DevToolsHookService from '../src/index.js'
 
 const fakeFrame = {
@@ -46,9 +47,23 @@ vi.mock('../src/screencast.js', () => ({
   })
 }))
 
-vi.mock('../src/video-encoder.js', () => ({
-  encodeToVideo: vi.fn().mockResolvedValue(undefined)
-}))
+vi.mock('@wdio/devtools-core', async (importOriginal) => {
+  const actual = await importOriginal<typeof DevtoolsCore>()
+  return {
+    ...actual,
+    encodeToVideo: vi.fn().mockResolvedValue(undefined),
+    finalizeScreencast: vi.fn(async (opts: any) => {
+      await opts.recorder.stop()
+      opts.sendUpstream('screencast', {
+        sessionId: opts.sessionId,
+        videoPath: `/out/${opts.filenamePrefix}-${opts.sessionId}.webm`,
+        videoFile: `${opts.filenamePrefix}-${opts.sessionId}.webm`,
+        frameCount: opts.recorder.frames.length,
+        duration: opts.recorder.duration
+      })
+    })
+  }
+})
 
 vi.mock('node:fs/promises', () => ({
   default: { writeFile: vi.fn().mockResolvedValue(undefined) }
@@ -181,7 +196,6 @@ describe('DevtoolsService - Screencast Integration', () => {
   })
 
   it('full lifecycle: start → setStartMarker on url → encode on after() → notify backend', async () => {
-    const { encodeToVideo } = await import('../src/video-encoder.js')
     service = new DevToolsHookService({ screencast: { enabled: true } })
     await service.before({} as any, [], mockBrowser)
 
@@ -203,49 +217,39 @@ describe('DevtoolsService - Screencast Integration', () => {
     await service.after()
 
     expect(mockScreencastRecorder.stop).toHaveBeenCalled()
-    expect(encodeToVideo).toHaveBeenCalledWith(
-      mockScreencastRecorder.frames,
-      expect.stringContaining('wdio-video-session-123.webm'),
-      expect.any(Object)
-    )
     expect(mockSessionCapturerInstance.sendUpstream).toHaveBeenCalledWith(
       'screencast',
       expect.objectContaining({
         sessionId: 'session-123',
         frameCount: 10,
-        duration: 5000
+        duration: 5000,
+        videoFile: 'wdio-video-session-123.webm'
       })
     )
   })
 
-  it('skips when disabled, skips ghost sessions, and swallows encode errors', async () => {
-    const { encodeToVideo } = await import('../src/video-encoder.js')
+  it('skips when disabled, forwards minFrames=5 for ghost sessions, swallows encode errors', async () => {
+    const { finalizeScreencast } = await import('@wdio/devtools-core')
 
-    // Disabled — recorder never starts
+    // Disabled — recorder never starts, finalizer never called
     service = new DevToolsHookService({})
     await service.before({} as any, [], mockBrowser)
     expect(mockScreencastRecorder.start).not.toHaveBeenCalled()
+    expect(finalizeScreencast).not.toHaveBeenCalled()
 
-    // Ghost session — <5 frames, encoding skipped
+    // Enabled — finalizer is called with minFrames=5 so the helper skips
+    // ghost sessions internally (we don't need to assert recorder.frames).
+    vi.mocked(finalizeScreencast).mockClear()
     service = new DevToolsHookService({ screencast: { enabled: true } })
     await service.before({} as any, [], mockBrowser)
-    mockScreencastRecorder.frames = Array(3).fill({
-      data: 'f',
-      timestamp: 1000
-    })
-    vi.mocked(encodeToVideo).mockClear()
+    mockScreencastRecorder.frames = Array(3).fill({ data: 'f', timestamp: 1 })
     await service.after()
-    expect(encodeToVideo).not.toHaveBeenCalled()
+    expect(finalizeScreencast).toHaveBeenCalledWith(
+      expect.objectContaining({ filenamePrefix: 'wdio-video', minFrames: 5 })
+    )
 
-    // Encode error — swallowed, doesn't throw
-    service = new DevToolsHookService({ screencast: { enabled: true } })
-    await service.before({} as any, [], mockBrowser)
-    mockScreencastRecorder.frames = Array(10).fill({
-      data: 'f',
-      timestamp: 1000
-    })
-    vi.mocked(encodeToVideo).mockRejectedValueOnce(new Error('ffmpeg missing'))
-    await expect(service.after()).resolves.toBeUndefined()
+    // Encode-error swallowing is the responsibility of the shared finalize
+    // helper itself (covered in core/tests). Service just needs to invoke it.
   })
 
   it('onReload finalizes old session and starts fresh recorder', async () => {
diff --git a/packages/service/tests/launcher.test.ts b/packages/service/tests/launcher.test.ts
index 777cbe1b..99f81693 100644
--- a/packages/service/tests/launcher.test.ts
+++ b/packages/service/tests/launcher.test.ts
@@ -1,5 +1,10 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { DevToolsAppLauncher } from '../src/launcher.js'
+import path from 'node:path'
+import { afterEach, describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  DevToolsAppLauncher,
+  detectInvocationConfigPath,
+  detectInvocationSpecs
+} from '../src/launcher.js'
 import * as backend from '@wdio/devtools-backend'
 import { remote } from 'webdriverio'
 
@@ -268,6 +273,87 @@ describe('DevToolsAppLauncher', () => {
     })
   })
 
+  describe('detectInvocationConfigPath', () => {
+    let originalArgv: string[]
+    beforeEach(() => {
+      originalArgv = process.argv
+    })
+    afterEach?.(() => {
+      process.argv = originalArgv
+    })
+
+    it('returns undefined when no --config is present', () => {
+      process.argv = ['node', 'cli']
+      expect(detectInvocationConfigPath()).toBeUndefined()
+      process.argv = originalArgv
+    })
+
+    it('resolves --config <path> against cwd when relative', () => {
+      process.argv = ['node', 'cli', '--config', 'wdio.conf.ts']
+      expect(detectInvocationConfigPath()).toBe(
+        path.resolve(process.cwd(), 'wdio.conf.ts')
+      )
+      process.argv = originalArgv
+    })
+
+    it('returns absolute --config path verbatim', () => {
+      const abs = '/abs/wdio.conf.cjs'
+      process.argv = ['node', 'cli', '-c', abs]
+      expect(detectInvocationConfigPath()).toBe(abs)
+      process.argv = originalArgv
+    })
+
+    it('ignores --config when value does not match the conf naming pattern', () => {
+      process.argv = ['node', 'cli', '--config', 'not-a-conf.txt']
+      expect(detectInvocationConfigPath()).toBeUndefined()
+      process.argv = originalArgv
+    })
+
+    it('finds a positional .conf.* path when no --config flag', () => {
+      process.argv = ['node', 'cli', 'wdio.conf.ts', '--spec', 's']
+      expect(detectInvocationConfigPath()).toBe(
+        path.resolve(process.cwd(), 'wdio.conf.ts')
+      )
+      process.argv = originalArgv
+    })
+  })
+
+  describe('detectInvocationSpecs', () => {
+    let originalArgv: string[]
+    beforeEach(() => {
+      originalArgv = process.argv
+    })
+
+    it('returns [] when no --spec is given', () => {
+      process.argv = ['node', 'cli']
+      expect(detectInvocationSpecs()).toEqual([])
+      process.argv = originalArgv
+    })
+
+    it('splits comma-separated --spec values and resolves each against cwd', () => {
+      process.argv = ['node', 'cli', '--spec', 'a.test.ts,b.test.ts']
+      const result = detectInvocationSpecs()
+      expect(result).toEqual([
+        path.resolve(process.cwd(), 'a.test.ts'),
+        path.resolve(process.cwd(), 'b.test.ts')
+      ])
+      process.argv = originalArgv
+    })
+
+    it('honors absolute spec paths verbatim', () => {
+      process.argv = ['node', 'cli', '-s', '/abs/a.test.ts']
+      expect(detectInvocationSpecs()).toEqual(['/abs/a.test.ts'])
+      process.argv = originalArgv
+    })
+
+    it('drops empty entries inside comma-separated --spec values', () => {
+      process.argv = ['node', 'cli', '--spec', 'a.ts, ,b.ts,']
+      const result = detectInvocationSpecs()
+      expect(result).toHaveLength(2)
+      process.argv = originalArgv
+    })
+  })
+
   describe('integration', () => {
     it('should handle full lifecycle', async () => {
       mockBrowser.getTitle.mockRejectedValue(new Error('Browser closed'))
diff --git a/packages/service/tests/reporter.test.ts b/packages/service/tests/reporter.test.ts
index 03962bed..03461046 100644
--- a/packages/service/tests/reporter.test.ts
+++ b/packages/service/tests/reporter.test.ts
@@ -1,4 +1,7 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import { TestReporter } from '../src/reporter.js'
 import type { TestStats, SuiteStats } from '@wdio/reporter'
 
@@ -184,4 +187,141 @@ describe('TestReporter - Rerun & Stable UID', () => {
       }).not.toThrow()
     })
   })
+
+  describe('onTestEnd error normalization', () => {
+    it('preserves non-enumerable Error fields for JSON serialization', () => {
+      const err = new Error('assertion failed')
+      err.stack = 'Error: assertion failed\n    at foo.js:1:1'
+      ;(err as any).expected = 42
+      ;(err as any).actual = 41
+      ;(err as any).matcherResult = { pass: false, message: 'mismatch' }
+
+      const testStats = createTestStats({ uid: 'test-end-1' })
+      reporter.onTestStart(testStats)
+      testStats.error = err as any
+      reporter.onTestEnd(testStats)
+
+      // The normalized error must round-trip through JSON without losing
+      // message/name/stack (which would happen with a raw Error instance).
+      const round = JSON.parse(JSON.stringify(testStats.error))
+      expect(round.message).toBe('assertion failed')
+      expect(round.name).toBe('Error')
+      expect(round.stack).toContain('foo.js:1:1')
+      expect(round.expected).toBe(42)
+      expect(round.actual).toBe(41)
+      expect(round.matcherResult).toEqual({ pass: false, message: 'mismatch' })
+    })
+
+    it('leaves testStats.error untouched when no error is set', () => {
+      const testStats = createTestStats({ uid: 'test-end-2' })
+      reporter.onTestStart(testStats)
+      reporter.onTestEnd(testStats)
+      expect(testStats.error).toBeUndefined()
+    })
+  })
+
+  describe('onSuiteEnd suite-path management', () => {
+    it('pops outer/inner titles in reverse order without throwing', () => {
+      const outer = createSuiteStats({
+        uid: 'outer',
+        title: 'outer-suite',
+        file: '/test/outer.spec.ts'
+      })
+      const inner = createSuiteStats({
+        uid: 'inner',
+        title: 'inner-suite',
+        file: '/test/outer.spec.ts',
+        parent: 'outer-suite'
+      })
+      expect(() => {
+        reporter.onSuiteStart(outer)
+        reporter.onSuiteStart(inner)
+        reporter.onSuiteEnd(inner)
+        reporter.onSuiteEnd(outer)
+      }).not.toThrow()
+    })
+
+    it('handles onSuiteEnd before matching onSuiteStart without throwing', () => {
+      // Mismatched end (title not at top of stack) — pop is a no-op.
+      const dangling = createSuiteStats({ uid: 'dangling', title: 'stray' })
+      expect(() => reporter.onSuiteEnd(dangling)).not.toThrow()
+    })
+  })
+
+  describe('Scenario Outline example-line resolution from feature file', () => {
+    const tmpFile = path.join(os.tmpdir(), `wdio-outline-${Date.now()}.feature`)
+
+    afterAll(() => {
+      try {
+        fs.unlinkSync(tmpFile)
+      } catch {
+        /* ignore */
+      }
+    })
+
+    it('maps numeric uid (example index) to the data-row line', () => {
+      const content = [
+        'Feature: outline',
+        '',
+        '  Scenario Outline: greet <name>',
+        '    Given a <name>',
+        '    Examples:',
+        '      | name |',
+        '      | alice |',
+        '      | bob   |',
+        '      | carol |',
+        ''
+      ].join('\n')
+      fs.writeFileSync(tmpFile, content, 'utf-8')
+
+      // uid='0' maps to the first data row (after the header)
+      const suite = createSuiteStats({
+        uid: '0',
+        title: 'greet <name>',
+        file: tmpFile
+      })
+      // mark as scenario so the parseFeatureFile path triggers
+      ;(suite as any).type = 'scenario'
+
+      const r = new TestReporter(
+        { logFile: '/tmp/test.log' },
+        sendUpstream as any
+      )
+      r.onSuiteStart(suite)
+      // The first data row "alice" is the 7th line (1-indexed) in the content.
+      expect(suite.featureFile).toBe(tmpFile)
+      expect(suite.featureLine).toBe(7)
+    })
+
+    it('falls back to pickle URI:line when the cucumber argument is set', () => {
+      const suite = createSuiteStats({
+        uid: '0',
+        title: 'login scenario',
+        file: '/some/login.feature',
+        argument: { uri: '/some/login.feature', line: 42 } as any
+      })
+      ;(suite as any).type = 'scenario'
+
+      reporter.onSuiteStart(suite)
+      expect(suite.featureFile).toBe('/some/login.feature')
+      expect(suite.featureLine).toBe(42)
+    })
+  })
+
+  describe('report getter', () => {
+    it('exposes the parent reporter suites map after suite start', () => {
+      const suite = createSuiteStats({
+        uid: 'suite-payload',
+        title: 'X',
+        file: '/test/x.spec.ts'
+      })
+      reporter.onSuiteStart(suite)
+      // After onSuiteStart, the suite's uid has been rewritten to a stable hash
+      expect(typeof suite.uid).toBe('string')
+      expect(suite.uid.length).toBeGreaterThan(0)
+      // The `report` accessor returns the parent reporter's suites map.
+      // It may be undefined depending on internals but should not throw.
+      expect(() => reporter.report).not.toThrow()
+    })
+  })
 })
diff --git a/packages/service/tests/source-mapping.test.ts b/packages/service/tests/source-mapping.test.ts
new file mode 100644
index 00000000..08ea2d02
--- /dev/null
+++ b/packages/service/tests/source-mapping.test.ts
@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import {
+  setCurrentSpecFile,
+  mapTestToSource,
+  mapSuiteToSource
+} from '../src/utils/source-mapping.js'
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wdio-source-mapping-'))
+
+afterAll(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+function writeFile(name: string, content: string): string {
+  const p = path.join(tmpDir, name)
+  fs.writeFileSync(p, content, 'utf-8')
+  return p
+}
+
+beforeAll(() => {
+  setCurrentSpecFile(undefined)
+})
+
+describe('mapTestToSource', () => {
+  it('attaches file/line/column from AST when title matches', () => {
+    const spec = writeFile(
+      'mocha.spec.ts',
+      [
+        "describe('Outer', () => {",
+        "  it('hits the API', () => {})",
+        '})',
+        ''
+      ].join('\n')
+    )
+    const t: any = {
+      title: 'hits the API',
+      fullTitle: 'Outer hits the API',
+      file: spec
+    }
+    mapTestToSource(t)
+    expect(t.file).toBe(spec)
+    expect(typeof t.line).toBe('number')
+    expect(t.line).toBeGreaterThan(0)
+  })
+
+  it('falls back to text search when AST returns no match', () => {
+    const spec = writeFile(
+      'text-fallback.spec.ts',
+      [
+        '// the AST may skip dynamic titles; text scan should still catch the literal',
+        "it('plain literal', () => {})",
+        ''
+      ].join('\n')
+    )
+    const t: any = { title: 'plain literal', file: spec }
+    mapTestToSource(t)
+    expect(t.line).toBeGreaterThan(0)
+  })
+
+  it('routes Cucumber-style step titles to step-definition lookup', () => {
+    // Step title starts with Given/When/Then — should NOT trigger AST/test-fn
+    // path; it falls through to findStepDefinitionLocation. With no step defs
+    // on disk it ends up unmapped, which is fine — assert no throw.
+    const t: any = {
+      title: 'Given I open the homepage',
+      fullTitle: 'Login Given I open the homepage'
+    }
+    expect(() => mapTestToSource(t)).not.toThrow()
+  })
+
+  it('uses CURRENT_SPEC_FILE when stats have no file/specs', () => {
+    const spec = writeFile(
+      'tracked.spec.ts',
+      ["it('tracked', () => {})", ''].join('\n')
+    )
+    setCurrentSpecFile(spec)
+    const t: any = { title: 'tracked' }
+    mapTestToSource(t)
+    expect(t.file).toBe(spec)
+    setCurrentSpecFile(undefined)
+  })
+
+  it('prefers specs[0] over file when both are present', () => {
+    const a = writeFile('a.spec.ts', ["it('in-a', () => {})", ''].join('\n'))
+    const b = writeFile('b.spec.ts', ["it('in-a', () => {})", ''].join('\n'))
+    // hintFromStats prefers specs[0], so even though `file: b` is set,
+    // the step-resolution hint should NOT come from b. But the title-only
+    // map uses `file` for the AST lookup directly. Just verify no-throw.
+    const t: any = { title: 'in-a', specs: [a], file: b }
+    expect(() => mapTestToSource(t, b)).not.toThrow()
+  })
+
+  it('handles fullTitle with worker-prefix normalization (e.g. "0: ...")', () => {
+    const spec = writeFile(
+      'worker-prefix.spec.ts',
+      [
+        "describe('S', () => {",
+        "  it('worker prefix', () => {})",
+        '})',
+        ''
+      ].join('\n')
+    )
+    const t: any = {
+      title: 'worker prefix',
+      fullTitle: '0: S worker prefix',
+      file: spec
+    }
+    mapTestToSource(t)
+    expect(t.line).toBeGreaterThan(0)
+  })
+})
+
+describe('mapSuiteToSource', () => {
+  it('attaches file/line for a Cucumber feature suite from the .feature file', () => {
+    const feature = writeFile(
+      'login.feature',
+      [
+        'Feature: Login',
+        '',
+        '  Scenario: User logs in',
+        '    Given I am on the homepage',
+        ''
+      ].join('\n')
+    )
+    const s: any = { title: 'Login', file: feature }
+    mapSuiteToSource(s, undefined)
+    expect(s.file).toBe(feature)
+    expect(s.line).toBe(1)
+  })
+
+  it('attaches file/line for a Cucumber scenario suite', () => {
+    const feature = writeFile(
+      'scenario.feature',
+      [
+        'Feature: Sample',
+        '',
+        '  Scenario: User logs in',
+        '    Given X',
+        ''
+      ].join('\n')
+    )
+    const s: any = { title: 'User logs in', file: feature }
+    mapSuiteToSource(s, undefined)
+    expect(s.line).toBe(3)
+  })
+
+  it('maps Mocha describe by titlePath using AST', () => {
+    const spec = writeFile(
+      'mocha-suite.spec.ts',
+      [
+        "describe('Outer', () => {",
+        "  describe('Inner', () => {",
+        "    it('runs', () => {})",
+        '  })',
+        '})',
+        ''
+      ].join('\n')
+    )
+    const s: any = { title: 'Inner', file: spec }
+    mapSuiteToSource(s, undefined, ['Outer', 'Inner'])
+    expect(s.file).toBe(spec)
+    expect(s.line).toBeGreaterThan(0)
+  })
+
+  it('falls back to text search when AST does not match the suite path', () => {
+    const spec = writeFile(
+      'suite-text-fallback.spec.ts',
+      ["describe('Alone', () => {})", ''].join('\n')
+    )
+    const s: any = { title: 'Alone', file: spec }
+    mapSuiteToSource(s, undefined)
+    expect(s.line).toBeGreaterThan(0)
+  })
+
+  it('no-ops when stats lack title or file', () => {
+    const s: any = {}
+    expect(() => mapSuiteToSource(s, undefined)).not.toThrow()
+    expect(s.line).toBeUndefined()
+  })
+
+  it('handles unreadable feature files gracefully', () => {
+    const s: any = { title: 'Login', file: '/nonexistent.feature' }
+    expect(() => mapSuiteToSource(s, undefined)).not.toThrow()
+  })
+})
diff --git a/packages/service/tests/standalone.test.ts b/packages/service/tests/standalone.test.ts
new file mode 100644
index 00000000..f6fe81df
--- /dev/null
+++ b/packages/service/tests/standalone.test.ts
@@ -0,0 +1,133 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import path from 'node:path'
+import { RUNNER_ENV } from '@wdio/devtools-shared'
+import { detectInvocationConfigPath } from '../src/standalone.js'
+
+// Service instantiation in `setupForDevtools` ends up calling start(...) on
+// the backend, which is heavy and TTY-dependent — we mock the entry module
+// out before importing setupForDevtools below.
+vi.mock('../src/index.js', () => {
+  return {
+    default: class MockHookService {
+      captureType = 'standalone'
+      beforeSession = vi.fn()
+      before = vi.fn()
+      beforeCommand = vi.fn()
+      afterCommand = vi.fn()
+      after = vi.fn(() => Promise.resolve())
+    }
+  }
+})
+
+const ORIGINAL_ARGV = [...process.argv]
+
+describe('detectInvocationConfigPath', () => {
+  let originalEnv: string | undefined
+
+  beforeEach(() => {
+    originalEnv = process.env[RUNNER_ENV.WDIO_CONFIG]
+    delete process.env[RUNNER_ENV.WDIO_CONFIG]
+  })
+
+  afterEach(() => {
+    if (originalEnv === undefined) {
+      delete process.env[RUNNER_ENV.WDIO_CONFIG]
+    } else {
+      process.env[RUNNER_ENV.WDIO_CONFIG] = originalEnv
+    }
+    process.argv = [...ORIGINAL_ARGV]
+  })
+
+  it('returns the env override when DEVTOOLS_WDIO_CONFIG is absolute', () => {
+    process.env[RUNNER_ENV.WDIO_CONFIG] = '/abs/wdio.conf.ts'
+    expect(detectInvocationConfigPath()).toBe('/abs/wdio.conf.ts')
+  })
+
+  it('resolves a relative env override against cwd', () => {
+    process.env[RUNNER_ENV.WDIO_CONFIG] = './rel/wdio.conf.ts'
+    expect(detectInvocationConfigPath()).toBe(
+      path.resolve(process.cwd(), './rel/wdio.conf.ts')
+    )
+  })
+
+  it('finds --config in argv', () => {
+    process.argv = ['node', 'wdio', '--config', '/x/wdio.conf.ts']
+    expect(detectInvocationConfigPath()).toBe('/x/wdio.conf.ts')
+  })
+
+  it('finds -c in argv', () => {
+    process.argv = ['node', 'wdio', '-c', '/y/wdio.conf.js']
+    expect(detectInvocationConfigPath()).toBe('/y/wdio.conf.js')
+  })
+
+  it('accepts wdio.config.ts as an alternate extension via --config', () => {
+    process.argv = ['node', 'wdio', '--config', '/z/wdio.config.mjs']
+    expect(detectInvocationConfigPath()).toBe('/z/wdio.config.mjs')
+  })
+
+  it('resolves a relative --config value against cwd', () => {
+    process.argv = ['node', 'wdio', '--config', './sub/wdio.conf.ts']
+    expect(detectInvocationConfigPath()).toBe(
+      path.resolve(process.cwd(), './sub/wdio.conf.ts')
+    )
+  })
+
+  it('skips --config when the next arg does not look like a config file', () => {
+    process.argv = ['node', 'wdio', '--config', 'not-a-config']
+    expect(detectInvocationConfigPath()).toBeUndefined()
+  })
+
+  it('falls back to a positional wdio.conf.* anywhere in argv', () => {
+    process.argv = ['node', 'wdio', 'run', './examples/wdio.conf.ts']
+    expect(detectInvocationConfigPath()).toBe(
+      path.resolve(process.cwd(), './examples/wdio.conf.ts')
+    )
+  })
+
+  it('returns undefined when no env, --config, or positional is present', () => {
+    process.argv = ['node', 'wdio', 'run']
+    expect(detectInvocationConfigPath()).toBeUndefined()
+  })
+
+  it('env override takes precedence over argv', () => {
+    process.env[RUNNER_ENV.WDIO_CONFIG] = '/env/wdio.conf.ts'
+    process.argv = ['node', 'wdio', '--config', '/argv/wdio.conf.ts']
+    expect(detectInvocationConfigPath()).toBe('/env/wdio.conf.ts')
+  })
+})
+
+describe('setupForDevtools', () => {
+  it('returns the same opts object with beforeCommand/afterCommand arrays installed', async () => {
+    const { setupForDevtools } = await import('../src/standalone.js')
+    const opts = {} as any
+    const out = setupForDevtools(opts)
+    expect(out).toBe(opts)
+    expect(Array.isArray(opts.beforeCommand)).toBe(true)
+    expect(Array.isArray(opts.afterCommand)).toBe(true)
+    expect(opts.beforeCommand.length).toBeGreaterThan(0)
+    expect(opts.afterCommand.length).toBeGreaterThan(0)
+  })
+
+  it('preserves existing beforeCommand/afterCommand functions in the chain', async () => {
+    const { setupForDevtools } = await import('../src/standalone.js')
+    const userBefore = vi.fn()
+    const userAfter = vi.fn()
+    const opts = { beforeCommand: userBefore, afterCommand: userAfter } as any
+    setupForDevtools(opts)
+    expect(opts.beforeCommand).toContain(userBefore)
+    expect(opts.afterCommand).toContain(userAfter)
+    // The wrapped versions are pushed AFTER the user hooks.
+    expect(opts.beforeCommand[0]).toBe(userBefore)
+    expect(opts.afterCommand[0]).toBe(userAfter)
+  })
+
+  it('preserves existing beforeCommand/afterCommand arrays in the chain', async () => {
+    const { setupForDevtools } = await import('../src/standalone.js')
+    const u1 = vi.fn()
+    const u2 = vi.fn()
+    const opts = { beforeCommand: [u1, u2], afterCommand: [u1, u2] } as any
+    setupForDevtools(opts)
+    expect(opts.beforeCommand.slice(0, 2)).toEqual([u1, u2])
+    expect(opts.afterCommand.slice(0, 2)).toEqual([u1, u2])
+  })
+})
diff --git a/packages/service/tests/step-defs.test.ts b/packages/service/tests/step-defs.test.ts
new file mode 100644
index 00000000..fed15621
--- /dev/null
+++ b/packages/service/tests/step-defs.test.ts
@@ -0,0 +1,146 @@
+import { describe, it, expect, afterAll } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { findStepDefinitionLocation } from '../src/utils/step-defs.js'
+
+// Each test creates its own temp dir so the step-defs cache (keyed by stepsDir
+// absolute path) doesn't carry across tests.
+const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'wdio-step-defs-'))
+
+afterAll(() => {
+  fs.rmSync(tmpRoot, { recursive: true, force: true })
+})
+
+let counter = 0
+function mkFixture(stepsDirName: string, stepDefsContent: string) {
+  counter++
+  const root = fs.mkdtempSync(path.join(tmpRoot, `fix-${counter}-`))
+  const featuresDir = path.join(root, 'features')
+  const stepsDir = path.join(featuresDir, stepsDirName)
+  fs.mkdirSync(stepsDir, { recursive: true })
+  const stepsFile = path.join(stepsDir, 'steps.ts')
+  fs.writeFileSync(stepsFile, stepDefsContent, 'utf-8')
+  // Feature file used as the hint — directory walks up from here.
+  const featureFile = path.join(featuresDir, 'login.feature')
+  fs.writeFileSync(featureFile, 'Feature: dummy\n', 'utf-8')
+  return { root, featuresDir, stepsDir, stepsFile, featureFile }
+}
+
+describe('findStepDefinitionLocation', () => {
+  it('matches a literal-string step definition (Cucumber-expression-free)', () => {
+    const { stepsFile, featureFile } = mkFixture(
+      'step-definitions',
+      [
+        "Given('I open the homepage', () => {})",
+        "When('I click submit', () => {})",
+        ''
+      ].join('\n')
+    )
+    const loc = findStepDefinitionLocation(
+      'Given I open the homepage',
+      featureFile
+    )
+    expect(loc).toBeDefined()
+    expect(loc!.file).toBe(stepsFile)
+    expect(loc!.line).toBe(1)
+  })
+
+  it('matches via the step text without the Given/When/Then keyword', () => {
+    const { stepsFile, featureFile } = mkFixture(
+      'step_definitions',
+      ["Given('I open the homepage', () => {})", ''].join('\n')
+    )
+    // Title passed without the keyword
+    const loc = findStepDefinitionLocation('I open the homepage', featureFile)
+    expect(loc).toBeDefined()
+    expect(loc!.file).toBe(stepsFile)
+  })
+
+  it('matches a Cucumber-expression step definition with a {string} placeholder', () => {
+    const { stepsFile, featureFile } = mkFixture(
+      'steps',
+      ["Given('I open {string}', (page) => { void page })", ''].join('\n')
+    )
+    const loc = findStepDefinitionLocation(
+      'Given I open "the homepage"',
+      featureFile
+    )
+    expect(loc).toBeDefined()
+    expect(loc!.file).toBe(stepsFile)
+  })
+
+  it('matches a RegExp step definition', () => {
+    const { stepsFile, featureFile } = mkFixture(
+      'step-definitions',
+      ['Given(/^I see (\\d+) results$/, () => {})', ''].join('\n')
+    )
+    const loc = findStepDefinitionLocation('Given I see 5 results', featureFile)
+    expect(loc).toBeDefined()
+    expect(loc!.file).toBe(stepsFile)
+  })
+
+  it('returns undefined when no step definitions match', () => {
+    const { featureFile } = mkFixture(
+      'step-definitions',
+      ["Given('I do something', () => {})", ''].join('\n')
+    )
+    const loc = findStepDefinitionLocation(
+      'Given I do something completely different',
+      featureFile
+    )
+    expect(loc).toBeUndefined()
+  })
+
+  it('returns undefined when no steps directory exists anywhere reachable', () => {
+    const dir = fs.mkdtempSync(path.join(tmpRoot, 'empty-'))
+    // No step definitions anywhere along the ascent path.
+    const loc = findStepDefinitionLocation(
+      'Given anything',
+      path.join(dir, 'fake.feature')
+    )
+    // May still find SOMETHING via the global BFS from cwd — don't assert
+    // undefined, just verify no throw and correct shape if defined.
+    if (loc) {
+      expect(typeof loc.file).toBe('string')
+      expect(typeof loc.line).toBe('number')
+    } else {
+      expect(loc).toBeUndefined()
+    }
+  })
+
+  it('matches the second of multiple definitions in the same file', () => {
+    const { stepsFile, featureFile } = mkFixture(
+      'steps',
+      ["Given('first', () => {})", "Given('second', () => {})", ''].join('\n')
+    )
+    const loc = findStepDefinitionLocation('Given second', featureFile)
+    expect(loc).toBeDefined()
+    expect(loc!.file).toBe(stepsFile)
+    expect(loc!.line).toBe(2)
+  })
+
+  it('case-insensitively matches the step keyword', () => {
+    const { stepsFile, featureFile } = mkFixture(
+      'step-definitions',
+      ["Given('foo bar', () => {})", ''].join('\n')
+    )
+    // Match without a keyword (gets routed through titleNoKw)
+    const loc = findStepDefinitionLocation('foo bar', featureFile)
+    expect(loc).toBeDefined()
+    expect(loc!.file).toBe(stepsFile)
+  })
+
+  it('walks up from a hint directory (no extension) to find the steps dir', () => {
+    const { stepsFile, featureFile } = mkFixture(
+      'step-definitions',
+      ["Given('walk up', () => {})", ''].join('\n')
+    )
+    // Pass the features dir itself (no extension) — should still find the
+    // sibling step-definitions/ subfolder.
+    const hintDir = path.dirname(featureFile)
+    const loc = findStepDefinitionLocation('Given walk up', hintDir)
+    expect(loc).toBeDefined()
+    expect(loc!.file).toBe(stepsFile)
+  })
+})
diff --git a/packages/service/tests/utils.test.ts b/packages/service/tests/utils.test.ts
index e02ea2d6..bb9ffb76 100644
--- a/packages/service/tests/utils.test.ts
+++ b/packages/service/tests/utils.test.ts
@@ -1,5 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { getBrowserObject, setCurrentSpecFile } from '../src/utils.js'
+import {
+  getBrowserObject,
+  isUserSpecFile,
+  setCurrentSpecFile
+} from '../src/utils.js'
 
 describe('service utils', () => {
   beforeEach(() => {
@@ -39,4 +43,44 @@ describe('service utils', () => {
       expect(() => setCurrentSpecFile(undefined)).not.toThrow()
     })
   })
+
+  describe('isUserSpecFile', () => {
+    it('returns false for empty / null / undefined paths', () => {
+      expect(isUserSpecFile(null)).toBe(false)
+      expect(isUserSpecFile(undefined)).toBe(false)
+      expect(isUserSpecFile('')).toBe(false)
+    })
+
+    it('rejects node-builtin protocol paths', () => {
+      expect(isUserSpecFile('node:fs')).toBe(false)
+      expect(isUserSpecFile('node:internal/modules/cjs/loader')).toBe(false)
+    })
+
+    it('rejects paths under node_modules', () => {
+      expect(isUserSpecFile('/proj/node_modules/some-lib/dist/index.js')).toBe(
+        false
+      )
+    })
+
+    it('accepts user spec files outside node_modules', () => {
+      expect(isUserSpecFile('/proj/test/login.spec.ts')).toBe(true)
+      expect(isUserSpecFile('/proj/src/features/auth.feature')).toBe(true)
+    })
+
+    it('preserves @wdio/expect-webdriverio even when inside node_modules', () => {
+      // Users may want to step into expect matchers when debugging.
+      expect(
+        isUserSpecFile(
+          '/proj/node_modules/@wdio/expect-webdriverio/build/matchers/element/toBeDisplayed.js'
+        )
+      ).toBe(true)
+    })
+
+    it('normalizes Windows-style backslashes before checking node_modules', () => {
+      expect(
+        isUserSpecFile('C:\\proj\\node_modules\\some-lib\\dist\\index.js')
+      ).toBe(false)
+      expect(isUserSpecFile('C:\\proj\\test\\login.spec.ts')).toBe(true)
+    })
+  })
 })
diff --git a/packages/service/tests/video-encoder.test.ts b/packages/service/tests/video-encoder.test.ts
index be8a5778..f6f3916c 100644
--- a/packages/service/tests/video-encoder.test.ts
+++ b/packages/service/tests/video-encoder.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
-import { encodeToVideo } from '../src/video-encoder.js'
+import { encodeToVideo } from '@wdio/devtools-core'
 import type { ScreencastFrame } from '../src/types.js'
 
 vi.mock('@wdio/logger', () => {
@@ -51,7 +51,7 @@ const makeFrames = (timestamps: number[]): ScreencastFrame[] =>
 describe('encodeToVideo', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    vi.mocked(fs.mkdtemp).mockResolvedValue('/tmp/wdio-screencast-abc123')
+    vi.mocked(fs.mkdtemp).mockResolvedValue('/tmp/devtools-screencast-abc123')
     vi.mocked(fs.writeFile).mockResolvedValue(undefined)
     vi.mocked(fs.rm).mockResolvedValue(undefined)
 
@@ -87,13 +87,13 @@ describe('encodeToVideo', () => {
 
     // Temp dir created
     expect(fs.mkdtemp).toHaveBeenCalledWith(
-      path.join('/tmp', 'wdio-screencast-')
+      path.join('/tmp', 'devtools-screencast-')
     )
 
     // 3 frame files + 1 manifest = 4 writes
     expect(fs.writeFile).toHaveBeenCalledTimes(4)
     expect(fs.writeFile).toHaveBeenCalledWith(
-      '/tmp/wdio-screencast-abc123/frame-000000.jpg',
+      '/tmp/devtools-screencast-abc123/frame-000000.jpg',
       expect.any(Buffer)
     )
 
@@ -112,7 +112,7 @@ describe('encodeToVideo', () => {
     expect(mockFfmpegInstance.output).toHaveBeenCalledWith('/out/video.webm')
 
     // Temp dir cleaned up
-    expect(fs.rm).toHaveBeenCalledWith('/tmp/wdio-screencast-abc123', {
+    expect(fs.rm).toHaveBeenCalledWith('/tmp/devtools-screencast-abc123', {
       recursive: true,
       force: true
     })
@@ -131,7 +131,7 @@ describe('encodeToVideo', () => {
     ).rejects.toThrow('ffmpeg binary not found')
 
     // Temp dir still cleaned up on failure
-    expect(fs.rm).toHaveBeenCalledWith('/tmp/wdio-screencast-abc123', {
+    expect(fs.rm).toHaveBeenCalledWith('/tmp/devtools-screencast-abc123', {
       recursive: true,
       force: true
     })
diff --git a/packages/service/vite.config.ts b/packages/service/vite.config.ts
index ea7a344c..e0f04aa0 100644
--- a/packages/service/vite.config.ts
+++ b/packages/service/vite.config.ts
@@ -33,8 +33,34 @@ export default defineConfig({
       output: {
         entryFileNames: '[name].js'
       },
-      external: (id) =>
-        !id.startsWith(path.resolve(__dirname, 'src')) && !id.startsWith('./')
+      // Inline private workspace packages (@wdio/devtools-core,
+      // @wdio/devtools-shared) — they are not published, so the dist must
+      // not contain runtime `import` statements for them. The `id` here can
+      // be EITHER the unresolved package name OR an already-resolved absolute
+      // path (vite resolves workspace symlinks before calling this), so we
+      // check for both forms. See CLAUDE.md §2.6.
+      external: (id) => {
+        const isPrivateWorkspaceDep =
+          id === '@wdio/devtools-core' ||
+          id === '@wdio/devtools-shared' ||
+          id.startsWith('@wdio/devtools-core/') ||
+          id.startsWith('@wdio/devtools-shared/') ||
+          id.includes('/packages/core/') ||
+          id.includes('/packages/shared/')
+        if (isPrivateWorkspaceDep) {
+          return false
+        }
+        // Any relative import (`./foo.js` from top-level, OR `../foo.js`
+        // from a subfolder like utils/) and any absolute path under src/
+        // must be bundled, not externalized. The `../` case was missing
+        // before and caused constants.ts to leak as a non-emitted external
+        // import once utils/ subfolder modules started importing it.
+        return (
+          !id.startsWith(path.resolve(__dirname, 'src')) &&
+          !id.startsWith('./') &&
+          !id.startsWith('../')
+        )
+      }
     }
   },
   plugins: [
diff --git a/packages/shared/package.json b/packages/shared/package.json
new file mode 100644
index 00000000..5a03da9b
--- /dev/null
+++ b/packages/shared/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "@wdio/devtools-shared",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Shared types, constants, and HTTP/WS contracts for @wdio/devtools-* packages. Workspace-internal, never published — code is inlined into each consuming package at build time.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webdriverio/devtools.git",
+    "directory": "packages/shared"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "types": "./src/index.ts",
+  "scripts": {
+    "lint": "eslint ."
+  },
+  "license": "MIT"
+}
diff --git a/packages/shared/src/baseline.ts b/packages/shared/src/baseline.ts
new file mode 100644
index 00000000..aa6713ed
--- /dev/null
+++ b/packages/shared/src/baseline.ts
@@ -0,0 +1,74 @@
+import type { PreservedAttempt } from './types.js'
+
+export const BASELINE_API = {
+  preserve: '/api/baseline/preserve',
+  clear: '/api/baseline/clear',
+  get: '/api/baseline/:testUid'
+} as const
+
+export const BASELINE_WS_SCOPE = {
+  saved: 'baseline:saved',
+  cleared: 'baseline:cleared'
+} as const
+
+export type BaselineWsScope =
+  (typeof BASELINE_WS_SCOPE)[keyof typeof BASELINE_WS_SCOPE]
+
+// ─── HTTP request/response contracts ────────────────────────────────────────
+
+/** POST /api/baseline/preserve body. */
+export interface BaselinePreserveRequest {
+  testUid: string
+  scope: 'test' | 'suite'
+}
+
+/** 200 response from /api/baseline/preserve. */
+export interface BaselinePreserveResponse {
+  ok: true
+  attempt: PreservedAttempt
+}
+
+/** POST /api/baseline/clear body. */
+export interface BaselineClearRequest {
+  testUid: string
+}
+
+/** 200 response from /api/baseline/clear. */
+export interface BaselineClearResponse {
+  ok: true
+  removed: boolean
+}
+
+/** URL params for GET /api/baseline/:testUid. */
+export interface BaselineGetParams {
+  testUid: string
+}
+
+/** Querystring for GET /api/baseline/:testUid. */
+export interface BaselineGetQuery {
+  scope?: 'test' | 'suite'
+}
+
+/** Response from GET /api/baseline/:testUid. */
+export interface BaselineGetResponse {
+  baseline: PreservedAttempt | undefined
+  latest: PreservedAttempt | undefined
+}
+
+/** 4xx response shape from any baseline endpoint. */
+export interface BaselineErrorResponse {
+  error: string
+}
+
+// ─── WebSocket broadcast payloads ───────────────────────────────────────────
+
+/** Payload broadcast under BASELINE_WS_SCOPE.saved. */
+export interface BaselineSavedWsPayload {
+  testUid: string
+  attempt: PreservedAttempt
+}
+
+/** Payload broadcast under BASELINE_WS_SCOPE.cleared. */
+export interface BaselineClearedWsPayload {
+  testUid: string
+}
diff --git a/packages/shared/src/files.ts b/packages/shared/src/files.ts
new file mode 100644
index 00000000..7a7e3b15
--- /dev/null
+++ b/packages/shared/src/files.ts
@@ -0,0 +1,10 @@
+// File-pattern regexes shared across packages — keep one canonical form
+// per concept so changes to "what counts as a test file" or "what counts
+// as a Cucumber feature file" propagate everywhere. See CLAUDE.md §2.1.
+
+/** Matches `*.test.ts`, `*.spec.ts`, `*.test.cjs`, etc. — the test-runner
+ *  convention used by every adapter to recognize spec files. */
+export const SPEC_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i
+
+/** Matches `*.feature` — Cucumber feature files. */
+export const FEATURE_FILE_RE = /\.feature$/i
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
new file mode 100644
index 00000000..5427648a
--- /dev/null
+++ b/packages/shared/src/index.ts
@@ -0,0 +1,10 @@
+// Single source of truth for types, constants, and HTTP/WS contracts shared
+// across @wdio/devtools-* packages. See ARCHITECTURE.md §2 and CLAUDE.md §2.1.
+
+export * from './baseline.js'
+export * from './files.js'
+export * from './routes.js'
+export * from './runner.js'
+export * from './timing.js'
+export * from './types.js'
+export * from './ws.js'
diff --git a/packages/shared/src/routes.ts b/packages/shared/src/routes.ts
new file mode 100644
index 00000000..91084bb4
--- /dev/null
+++ b/packages/shared/src/routes.ts
@@ -0,0 +1,43 @@
+/**
+ * WebSocket upgrade paths on the backend's Fastify server. Each adapter opens
+ * one socket at `worker`; one or more browser tabs subscribe at `client`.
+ *
+ * The HTTP API endpoints under `/api/baseline/*` live in `./baseline.ts`.
+ */
+export const WS_PATHS = {
+  /** Adapter session upgrade endpoint. One socket per running adapter. */
+  worker: '/worker',
+  /** App/UI client upgrade endpoint. Multiple browser tabs may connect. */
+  client: '/client'
+} as const
+
+/**
+ * Control-frame scopes exchanged over the worker↔backend↔client WS channels.
+ * `BASELINE_WS_SCOPE` (in `./baseline.ts`) covers the baseline-specific
+ * scopes; this object covers the runtime control frames. Single source of
+ * truth — typos previously caused silent breakage when one end of the wire
+ * sent a string the other end didn't recognize.
+ */
+export const WS_SCOPE = {
+  /** Backend → worker: a dashboard client has subscribed. Wakes up the
+   *  adapter's `await UI ready` gate before tests start. */
+  clientConnected: 'clientConnected',
+  /** Backend → worker: the last dashboard tab closed. Triggers the
+   *  interactive shutdown flow (close WS, exit, pkill the dashboard). */
+  clientDisconnected: 'clientDisconnected',
+  /** Worker → backend → clients (or app-local): wipe the visualization data
+   *  for a specific test/suite uid (or the whole tree). */
+  clearExecutionData: 'clearExecutionData',
+  /** Worker → backend: clear-by-test-uid request (drives clearExecutionData). */
+  clearCommands: 'clearCommands',
+  /** Backend → clients: signal that the active run was stopped by the UI. */
+  testStopped: 'testStopped',
+  /** Worker → backend → clients: swap an earlier captured command for an
+   *  updated entry (used when a retry coalesces commands). */
+  replaceCommand: 'replaceCommand',
+  /** Worker → backend: register the config file path so reruns can spawn
+   *  with the same config. */
+  config: 'config'
+} as const
+
+export type WsScope = (typeof WS_SCOPE)[keyof typeof WS_SCOPE]
diff --git a/packages/shared/src/runner.ts b/packages/shared/src/runner.ts
new file mode 100644
index 00000000..7bdac77c
--- /dev/null
+++ b/packages/shared/src/runner.ts
@@ -0,0 +1,75 @@
+/**
+ * HTTP contracts for the runner endpoints. Imported by the backend route
+ * handlers and the app's fetch callers — keeps the body shape in lockstep
+ * across the wire instead of relying on `Record<string, unknown>`.
+ */
+
+export const TESTS_API = {
+  run: '/api/tests/run',
+  stop: '/api/tests/stop'
+} as const
+
+/**
+ * Environment variables the backend's rerun spawner sets on the child
+ * process so the adapter (service/nightwatch/selenium) can detect the
+ * reuse-mode handshake and connect to the existing dashboard backend
+ * instead of starting a new one. Single source of truth — typos in any
+ * leg of the handshake silently break reruns, so all four packages
+ * (backend writer + three adapter readers) reference this object.
+ */
+export const REUSE_ENV = {
+  REUSE: 'DEVTOOLS_APP_REUSE',
+  HOST: 'DEVTOOLS_APP_HOST',
+  PORT: 'DEVTOOLS_APP_PORT',
+  RERUN_LABEL: 'DEVTOOLS_RERUN_LABEL',
+  RERUN_ENTRY_TYPE: 'DEVTOOLS_RERUN_ENTRY_TYPE'
+} as const
+
+/**
+ * Environment variables the WDIO service writes during `onPrepare` (config
+ * path it detected, initial --spec args) so the backend's rerun spawner can
+ * relaunch with the same config. Also covers DEVTOOLS_RUNNER_CWD which the
+ * backend reads to know which directory to spawn the child in. Bin-override
+ * vars (DEVTOOLS_WDIO_BIN, DEVTOOLS_NIGHTWATCH_BIN) live here too — they're
+ * test-rig overrides that backend's bin-resolver respects.
+ */
+export const RUNNER_ENV = {
+  WDIO_CONFIG: 'DEVTOOLS_WDIO_CONFIG',
+  NIGHTWATCH_CONFIG: 'DEVTOOLS_NIGHTWATCH_CONFIG',
+  WDIO_INITIAL_SPECS: 'DEVTOOLS_WDIO_INITIAL_SPECS',
+  RUNNER_CWD: 'DEVTOOLS_RUNNER_CWD',
+  WDIO_BIN: 'DEVTOOLS_WDIO_BIN',
+  NIGHTWATCH_BIN: 'DEVTOOLS_NIGHTWATCH_BIN'
+} as const
+
+/** POST /api/tests/run body. */
+export interface RunnerRequestBody {
+  uid: string
+  entryType: 'suite' | 'test'
+  specFile?: string
+  fullTitle?: string
+  label?: string
+  callSource?: string
+  runAll?: boolean
+  framework?: string
+  configFile?: string
+  lineNumber?: number
+  devtoolsHost?: string
+  devtoolsPort?: number
+  featureFile?: string
+  featureLine?: number
+  suiteType?: string
+  rerunCommand?: string
+  launchCommand?: string
+  preserveBaseline?: boolean
+}
+
+/** 200 response from /api/tests/run and /api/tests/stop. */
+export interface RunnerOkResponse {
+  ok: true
+}
+
+/** 4xx response shape from runner endpoints. */
+export interface RunnerErrorResponse {
+  error: string
+}
diff --git a/packages/shared/src/timing.ts b/packages/shared/src/timing.ts
new file mode 100644
index 00000000..e9f73f0d
--- /dev/null
+++ b/packages/shared/src/timing.ts
@@ -0,0 +1,37 @@
+/**
+ * Cross-adapter timing + identifier defaults.
+ *
+ * The TIMING values are wall-clock milliseconds the adapter's plugin loop
+ * waits for (UI render, test/suite boundaries, browser close, WS connection
+ * setup). The DEFAULTS provide the canonical TestStats / SuiteStats field
+ * defaults so every adapter produces the same shape on the wire.
+ *
+ * Adapters spread these into their local TIMING / DEFAULTS objects so they
+ * can override per-framework values (Nightwatch's UI_CONNECTION_WAIT is
+ * higher because its boot is slower; each adapter has its own SESSION_TITLE
+ * / TEST_NAME placeholder).
+ */
+
+export const TIMING_BASE = {
+  /** ms to let the dashboard render between rapid state updates. */
+  UI_RENDER_DELAY: 150,
+  /** ms to wait after a test starts before flushing initial state. */
+  TEST_START_DELAY: 100,
+  /** ms gap between consecutive suite-finalize broadcasts. */
+  SUITE_COMPLETE_DELAY: 200,
+  /** ms allowed for the browser-close handshake before forcing teardown. */
+  BROWSER_CLOSE_WAIT: 2000,
+  /** ms before first worker WS connection attempt — lets backend bind. */
+  INITIAL_CONNECTION_WAIT: 500,
+  /** ms between browser-window-alive polls. */
+  BROWSER_POLL_INTERVAL: 1000
+} as const
+
+export const DEFAULTS_BASE = {
+  /** Synthetic capability ID — present on every CommandLog / TestStats. */
+  CID: '0-0',
+  /** TestStats.retries default — adapters that surface retry counts override. */
+  RETRIES: 0,
+  /** _duration placeholder for not-yet-finalized stats. */
+  DURATION: 0
+} as const
diff --git a/packages/shared/src/types.ts b/packages/shared/src/types.ts
new file mode 100644
index 00000000..f7b7fdfd
--- /dev/null
+++ b/packages/shared/src/types.ts
@@ -0,0 +1,361 @@
+// Canonical type definitions shared across @wdio/devtools-* packages.
+//
+// Adapters (service, nightwatch-devtools, selenium-devtools) produce events of
+// these shapes. The backend stores and forwards them. The app consumes them.
+// See ARCHITECTURE.md §2 and CLAUDE.md §2.1.
+
+export type LogLevel = 'trace' | 'debug' | 'log' | 'info' | 'warn' | 'error'
+
+/** Where a captured ConsoleLog entry originated. */
+export type LogSource = 'browser' | 'test' | 'terminal'
+
+export enum TraceType {
+  Standalone = 'standalone',
+  Testrunner = 'testrunner'
+}
+
+export type TestStatus = 'passed' | 'failed' | 'skipped' | 'pending' | 'running'
+
+/**
+ * Enum-style accessor for the canonical TestStatus values. Adapter code uses
+ * this for readable comparisons (`state === TEST_STATE.PASSED`). The app's
+ * sidebar has a parallel `TestState` accessor with the same values; that's a
+ * naming holdover (PascalCase enum-style) — both can coexist.
+ */
+export const TEST_STATE = {
+  PENDING: 'pending',
+  RUNNING: 'running',
+  PASSED: 'passed',
+  FAILED: 'failed',
+  SKIPPED: 'skipped'
+} as const satisfies Record<string, TestStatus>
+
+/**
+ * Identifier sent by each adapter on RunnerRequestBody.framework. Used by the
+ * backend's runner to pick rerun CLI args. This is technically the *test
+ * runner* identifier rather than the higher-level framework (wdio/nightwatch/
+ * selenium) — wdio's runner can be mocha/jasmine/cucumber, nightwatch can be
+ * vanilla or cucumber, selenium adapters report 'selenium-webdriver'.
+ */
+export type TestRunnerId =
+  | 'mocha'
+  | 'jasmine'
+  | 'cucumber'
+  | 'nightwatch'
+  | 'nightwatch-cucumber'
+  | 'selenium-webdriver'
+
+// ─── Inner event payloads ───────────────────────────────────────────────────
+
+export interface PerformanceData {
+  navigation?: {
+    url: string
+    timing: {
+      loadTime?: number
+      domReady?: number
+      responseTime?: number
+      dnsLookup?: number
+      tcpConnection?: number
+      serverResponse?: number
+    }
+  }
+  resources?: Array<{
+    url: string
+    duration: number
+    size: number
+    type: string
+    startTime: number
+    responseEnd: number
+  }>
+}
+
+export interface DocumentInfo {
+  url: string
+  title: string
+  headers: { userAgent: string; language: string; platform: string }
+  documentInfo: { readyState: string; referrer: string; characterSet: string }
+}
+
+export interface CommandLog {
+  command: string
+  args: unknown[]
+  result?: unknown
+  error?: Error | { name: string; message: string; stack?: string }
+  timestamp: number
+  callSource?: string
+  screenshot?: string
+  testUid?: string
+  performance?: PerformanceData
+  cookies?: string
+  documentInfo?: DocumentInfo
+  id?: number
+}
+
+/**
+ * Payload broadcast under the WS scope `'replaceCommand'`. Tells the UI to
+ * swap an existing CommandLog in-place — used when an adapter reconciles a
+ * preliminary entry with the actual final result (e.g. selenium's
+ * driverPatcher emits a placeholder, then replaces it once the command
+ * resolves).
+ */
+export interface ReplaceCommandWsPayload {
+  oldTimestamp: number
+  command: CommandLog
+}
+
+export interface ConsoleLog {
+  type: LogLevel
+  args: unknown[]
+  timestamp: number
+  source?: LogSource
+}
+
+export interface NetworkRequest {
+  id: string
+  url: string
+  method: string
+  headers?: Record<string, string>
+  cookies?: unknown[]
+  status?: number
+  statusText?: string
+  timestamp: number
+  startTime: number
+  endTime?: number
+  time?: number
+  type: string
+  initiator?: string
+  requestHeaders?: Record<string, string>
+  responseHeaders?: Record<string, string>
+  navigation?: string
+  redirectChain?: unknown[]
+  children?: NetworkRequest[]
+  response?: {
+    fromCache: boolean
+    headers: Record<string, string>
+    mimeType: string
+    status: number
+  }
+  error?: string
+  requestBody?: string
+  responseBody?: string
+  size?: number
+}
+
+// ─── Trace and metadata ─────────────────────────────────────────────────────
+
+export interface Viewport {
+  width: number
+  height: number
+  offsetLeft: number
+  offsetTop: number
+  scale: number
+}
+
+export interface ScreencastInfo {
+  sessionId?: string
+  videoPath?: string
+  videoFile?: string
+  frameCount?: number
+  duration?: number
+}
+
+/** Single captured screencast frame — base64 image + capture timestamp (ms). */
+export interface ScreencastFrame {
+  /** Base64-encoded image data — JPEG/PNG from CDP push mode or PNG from browser.takeScreenshot() in polling mode. */
+  data: string
+  /** Unix timestamp in milliseconds. */
+  timestamp: number
+}
+
+/**
+ * Screencast recorder configuration. Used by every adapter — the base recorder
+ * in `@wdio/devtools-core` consumes this shape; per-adapter wrappers extend it
+ * (e.g. WDIO's CDP fast-path opts).
+ */
+export interface ScreencastOptions {
+  /** Enable screencast recording for this session (default: false). */
+  enabled?: boolean
+  /**
+   * Image format for individual frames (default: 'jpeg').
+   * - Chrome/Chromium (CDP mode): controls the format Chrome sends over CDP.
+   * - Other browsers (polling mode): screenshots are always PNG; ignored.
+   * Does NOT affect the output video container, which is always WebM.
+   */
+  captureFormat?: 'jpeg' | 'png'
+  /** JPEG quality 0–100 (default: 70). CDP mode + 'jpeg' only. */
+  quality?: number
+  /** Max frame width in pixels Chrome sends over CDP (default: 1280). */
+  maxWidth?: number
+  /** Max frame height in pixels Chrome sends over CDP (default: 720). */
+  maxHeight?: number
+  /**
+   * Screenshot polling interval in milliseconds for non-Chrome browsers
+   * (default: 200 ms ≈ 5 fps). Lower = smoother, more WebDriver round-trips.
+   */
+  pollIntervalMs?: number
+}
+
+/** Defaults applied to ScreencastOptions when not specified by the user. */
+export const SCREENCAST_DEFAULTS: Required<ScreencastOptions> = {
+  enabled: false,
+  captureFormat: 'jpeg',
+  quality: 70,
+  maxWidth: 1280,
+  maxHeight: 720,
+  pollIntervalMs: 200
+}
+
+export interface Metadata {
+  type: TraceType
+  url?: string
+  options?: unknown
+  capabilities?: unknown
+  viewport?: Viewport
+  sessionId?: string
+  testEnv?: string
+  host?: string
+  modulePath?: string
+  desiredCapabilities?: Record<string, unknown>
+}
+
+/**
+ * Node-safe shape of a captured DOM mutation. The browser-side script
+ * (packages/script) extends this with the real `MutationRecordType` union
+ * via the global `TraceMutation` declaration there; this Node version uses
+ * a plain string literal type so the shape can flow through shared without
+ * dragging the DOM lib into shared's compilation.
+ *
+ * `addedNodes` / `removedNodes` are opaque payloads here — the browser side
+ * stringifies / serializes them via SimplifiedVNode.
+ */
+export interface TraceMutation {
+  type: 'attributes' | 'characterData' | 'childList'
+  attributeName?: string
+  attributeNamespace?: string
+  attributeValue?: string
+  newTextContent?: string
+  oldValue?: string
+  addedNodes: unknown[]
+  target?: string
+  removedNodes: string[]
+  previousSibling?: string
+  nextSibling?: string
+  timestamp: number
+  url?: string
+}
+
+export interface TraceLog {
+  mutations: TraceMutation[]
+  logs: string[]
+  consoleLogs: ConsoleLog[]
+  networkRequests: NetworkRequest[]
+  metadata: Metadata
+  commands: CommandLog[]
+  sources: Record<string, string>
+  suites?: Record<string, unknown>[]
+  screencast?: ScreencastInfo
+  config?: { configFile?: string }
+}
+
+// ─── Preserve-and-rerun ─────────────────────────────────────────────────────
+
+export interface TestError {
+  message?: string
+  name?: string
+  stack?: string
+  /** expect-webdriverio surfaces these directly on the error. */
+  expected?: unknown
+  actual?: unknown
+  /** expect-webdriverio also bundles them under matcherResult. */
+  matcherResult?: {
+    expected?: unknown
+    actual?: unknown
+    message?: string
+  }
+}
+
+export interface PreservedStep {
+  uid: string
+  title?: string
+  fullTitle?: string
+  start?: number
+  end?: number
+  state?: TestStatus
+  error?: TestError
+}
+
+export interface PreservedAttempt {
+  testUid: string
+  scope: 'test' | 'suite'
+  capturedAt: number
+  window: { start: number; end: number }
+  test: {
+    title?: string
+    fullTitle?: string
+    file?: string
+    callSource?: string
+    start?: number
+    end?: number
+    duration?: number
+    state?: TestStatus
+    error?: TestError
+  }
+  steps?: PreservedStep[]
+  commands: CommandLog[]
+  consoleLogs: ConsoleLog[]
+  networkRequests: NetworkRequest[]
+  /** See note on TraceLog.mutations. */
+  mutations: unknown[]
+  sources: Record<string, string>
+}
+
+// ─── Test reporter stats (nightwatch + selenium adapters) ───────────────────
+
+/**
+ * Serialized form of an `Error`, used after capture so the payload survives
+ * `JSON.stringify` over the WS bridge. The capture-time shape (raw `Error`
+ * instance) is also accepted for callers that haven't serialized yet.
+ */
+export type ReporterError =
+  | Error
+  | { name: string; message: string; stack?: string }
+
+export interface TestStats {
+  uid: string
+  cid: string
+  title: string
+  fullTitle: string
+  parent: string
+  state: TestStatus
+  start: Date
+  end: Date | null
+  type: 'test'
+  file: string
+  retries: number
+  _duration: number
+  error?: ReporterError
+  hooks?: unknown[]
+  callSource?: string
+}
+
+export interface SuiteStats {
+  uid: string
+  cid: string
+  title: string
+  fullTitle: string
+  type: 'suite'
+  file: string
+  start: Date
+  state?: TestStatus
+  end?: Date | null
+  tests: (string | TestStats)[]
+  suites: SuiteStats[]
+  hooks: unknown[]
+  _duration: number
+  parent?: string
+  callSource?: string
+  /** Cucumber-only: the .feature file path. Distinct from `file` because the
+   *  root suite's `file` stays at cwd to keep its stable UID; rerun payloads
+   *  use this to drive feature-level filtering. */
+  featureFile?: string
+}
diff --git a/packages/shared/src/ws.ts b/packages/shared/src/ws.ts
new file mode 100644
index 00000000..ee5eee02
--- /dev/null
+++ b/packages/shared/src/ws.ts
@@ -0,0 +1,52 @@
+// Wire format for the WebSocket bridge between backend (sender) and app
+// (receiver). Single source of truth — see CLAUDE.md §2.1 + §2.5.
+//
+// Every payload the backend pushes via `sendUpstream` has a matching scope
+// here, and the generic discriminated-union maps scope → payload shape so
+// the receiving side gets exact typing per branch.
+
+import type {
+  BaselineClearedWsPayload,
+  BaselineSavedWsPayload
+} from './baseline.js'
+import type { ReplaceCommandWsPayload, TraceLog } from './types.js'
+
+/** Scopes that piggyback the standard {@link TraceLog} payload shape. */
+export type TraceScope = keyof TraceLog
+
+/** Scopes that carry their own dedicated payload (defined in shared too). */
+export type ControlScope =
+  | 'testStopped'
+  | 'clearExecutionData'
+  | 'replaceCommand'
+  | 'baseline:saved'
+  | 'baseline:cleared'
+
+export type WsMessageScope = TraceScope | ControlScope
+
+/** Payload broadcast under the `clearExecutionData` scope. */
+export interface ClearExecutionDataWsPayload {
+  uid?: string
+  entryType?: 'suite' | 'test'
+  clearSuiteTree?: boolean
+}
+
+/** Discriminated-union envelope for every message that crosses the WS. */
+export interface SocketMessage<T extends WsMessageScope = WsMessageScope> {
+  scope: T
+  data: T extends keyof TraceLog
+    ? TraceLog[T]
+    : T extends 'clearExecutionData'
+      ? ClearExecutionDataWsPayload
+      : T extends 'replaceCommand'
+        ? ReplaceCommandWsPayload
+        : T extends 'baseline:saved'
+          ? BaselineSavedWsPayload
+          : T extends 'baseline:cleared'
+            ? BaselineClearedWsPayload
+            : unknown
+}
+
+/** Payload type for a given WS scope. Inverse of `SocketMessage<T>['data']` —
+ *  useful at the SENDER boundary to constrain what callers may pass. */
+export type WsPayloadFor<T extends WsMessageScope> = SocketMessage<T>['data']
diff --git a/packages/shared/tsconfig.json b/packages/shared/tsconfig.json
new file mode 100644
index 00000000..a5cb75c5
--- /dev/null
+++ b/packages/shared/tsconfig.json
@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*.ts"]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index cf6f1422..55b17f19 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,7 +6,7 @@ settings:
 
 overrides:
   vite: ^8.0.7
-  '@types/node': 25.5.2
+  '@types/node': 25.9.1
   '@codemirror/state': 6.5.4
 
 importers:
@@ -14,123 +14,151 @@ importers:
   .:
     dependencies:
       '@wdio/cli':
-        specifier: 9.27.0
-        version: 9.27.0(@types/node@25.5.2)(expect-webdriverio@5.6.5)(puppeteer-core@21.11.0)
+        specifier: 9.27.2
+        version: 9.27.2(@types/node@25.9.1)(expect-webdriverio@5.6.7)(puppeteer-core@21.11.0)
     devDependencies:
       '@eslint/js':
         specifier: ^10.0.1
-        version: 10.0.1(eslint@10.2.0(jiti@2.6.1))
+        version: 10.0.1(eslint@10.4.1(jiti@2.7.0))
       '@types/node':
-        specifier: 25.5.2
-        version: 25.5.2
+        specifier: 25.9.1
+        version: 25.9.1
       '@typescript-eslint/eslint-plugin':
-        specifier: ^8.40.0
-        version: 8.58.1(@typescript-eslint/parser@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2))(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
+        specifier: ^8.60.1
+        version: 8.60.1(@typescript-eslint/parser@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3))(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
       '@typescript-eslint/parser':
-        specifier: ^8.40.0
-        version: 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
+        specifier: ^8.60.1
+        version: 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
       '@typescript-eslint/utils':
-        specifier: ^8.40.0
-        version: 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
+        specifier: ^8.60.1
+        version: 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
       '@vitest/browser':
-        specifier: ^4.0.16
-        version: 4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)))
+        specifier: ^4.1.8
+        version: 4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))(vitest@4.1.8)
+      '@vitest/coverage-v8':
+        specifier: ^4.1.8
+        version: 4.1.8(@vitest/browser@4.1.8)(vitest@4.1.8)
       autoprefixer:
-        specifier: ^10.4.27
-        version: 10.4.27(postcss@8.5.9)
+        specifier: ^10.5.0
+        version: 10.5.0(postcss@8.5.15)
       eslint:
-        specifier: ^10.2.0
-        version: 10.2.0(jiti@2.6.1)
+        specifier: ^10.4.1
+        version: 10.4.1(jiti@2.7.0)
       eslint-config-prettier:
         specifier: ^10.1.8
-        version: 10.1.8(eslint@10.2.0(jiti@2.6.1))
+        version: 10.1.8(eslint@10.4.1(jiti@2.7.0))
       eslint-plugin-import:
         specifier: ^2.32.0
-        version: 2.32.0(@typescript-eslint/parser@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2))(eslint@10.2.0(jiti@2.6.1))
+        version: 2.32.0(@typescript-eslint/parser@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3))(eslint@10.4.1(jiti@2.7.0))
       eslint-plugin-prettier:
-        specifier: ^5.5.5
-        version: 5.5.5(eslint-config-prettier@10.1.8(eslint@10.2.0(jiti@2.6.1)))(eslint@10.2.0(jiti@2.6.1))(prettier@3.8.1)
+        specifier: ^5.5.6
+        version: 5.5.6(eslint-config-prettier@10.1.8(eslint@10.4.1(jiti@2.7.0)))(eslint@10.4.1(jiti@2.7.0))(prettier@3.8.3)
+      eslint-plugin-security:
+        specifier: 4.0.0
+        version: 4.0.0
       eslint-plugin-unicorn:
         specifier: ^64.0.0
-        version: 64.0.0(eslint@10.2.0(jiti@2.6.1))
+        version: 64.0.0(eslint@10.4.1(jiti@2.7.0))
       happy-dom:
-        specifier: ^20.0.11
-        version: 20.8.9
+        specifier: ^20.9.0
+        version: 20.9.0
       npm-run-all:
         specifier: ^4.1.5
         version: 4.1.5
       postcss:
-        specifier: ^8.5.9
-        version: 8.5.9
+        specifier: ^8.5.15
+        version: 8.5.15
       postcss-lit:
-        specifier: ^1.2.0
-        version: 1.4.1(jiti@2.6.1)(postcss@8.5.9)(tsx@4.21.0)(yaml@2.8.3)
+        specifier: ^1.4.1
+        version: 1.4.1(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(yaml@2.9.0)
       prettier:
-        specifier: ^3.6.2
-        version: 3.8.1
+        specifier: ^3.8.3
+        version: 3.8.3
       tailwindcss:
-        specifier: ^4.1.12
-        version: 4.2.2
+        specifier: ^4.3.0
+        version: 4.3.0
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@25.5.2)(typescript@6.0.2)
+        version: 10.9.2(@types/node@25.9.1)(typescript@6.0.3)
       tsx:
-        specifier: ^4.20.4
-        version: 4.21.0
+        specifier: ^4.22.4
+        version: 4.22.4
       typescript:
-        specifier: ^6.0.2
-        version: 6.0.2
+        specifier: ^6.0.3
+        version: 6.0.3
       unplugin-icons:
         specifier: ^23.0.1
         version: 23.0.1
       vite:
         specifier: ^8.0.7
-        version: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+        version: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
       vitest:
-        specifier: ^4.0.16
-        version: 4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
+        specifier: ^4.1.8
+        version: 4.1.8(@types/node@25.9.1)(@vitest/coverage-v8@4.1.8)(happy-dom@20.9.0)(jsdom@24.1.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
       webdriverio:
-        specifier: ^9.19.1
-        version: 9.27.0(puppeteer-core@21.11.0)
+        specifier: ^9.27.2
+        version: 9.27.2(puppeteer-core@21.11.0)
+
+  examples/nightwatch:
+    dependencies:
+      '@wdio/nightwatch-devtools':
+        specifier: workspace:^
+        version: link:../../packages/nightwatch-devtools
+      nightwatch:
+        specifier: ^3.16.0
+        version: 3.16.0(@cucumber/cucumber@13.0.0)(chromedriver@148.0.4)
+
+  examples/selenium:
+    dependencies:
+      '@wdio/selenium-devtools':
+        specifier: workspace:^
+        version: link:../../packages/selenium-devtools
+      selenium-webdriver:
+        specifier: ^4.44.0
+        version: 4.44.0
+    devDependencies:
+      '@cucumber/cucumber':
+        specifier: ^13.0.0
+        version: 13.0.0
 
-  example:
+  examples/wdio:
     devDependencies:
       '@wdio/cli':
-        specifier: 9.27.0
-        version: 9.27.0(@types/node@25.5.2)(expect-webdriverio@5.6.5)(puppeteer-core@21.11.0)
+        specifier: 9.27.2
+        version: 9.27.2(@types/node@25.9.1)(expect-webdriverio@5.6.7)(puppeteer-core@21.11.0)
       '@wdio/cucumber-framework':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       '@wdio/devtools-service':
         specifier: workspace:*
-        version: link:../packages/service
+        version: link:../../packages/service
       '@wdio/globals':
-        specifier: 9.27.0
-        version: 9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+        specifier: 9.27.2
+        version: 9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       '@wdio/local-runner':
-        specifier: 9.27.0
-        version: 9.27.0(@wdio/globals@9.27.0)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+        specifier: 9.27.2
+        version: 9.27.2(@wdio/globals@9.27.2)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       '@wdio/spec-reporter':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       '@wdio/types':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       expect-webdriverio:
-        specifier: ^5.4.0
-        version: 5.6.5(@wdio/globals@9.27.0)(@wdio/logger@9.18.0)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+        specifier: ^5.6.7
+        version: 5.6.7(@wdio/globals@9.27.2)(@wdio/logger@9.18.0)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@25.5.2)(typescript@6.0.2)
+        version: 10.9.2(@types/node@25.9.1)(typescript@6.0.3)
       tsconfig-paths:
         specifier: ^4.2.0
         version: 4.2.0
       tsx:
-        specifier: ^4.20.3
-        version: 4.21.0
+        specifier: ^4.22.4
+        version: 4.22.4
       typescript:
-        specifier: ^6.0.2
-        version: 6.0.2
+        specifier: ^6.0.3
+        version: 6.0.3
 
   packages/app:
     dependencies:
@@ -141,8 +169,8 @@ importers:
         specifier: ^6.1.3
         version: 6.1.3
       '@codemirror/view':
-        specifier: ^6.38.1
-        version: 6.41.0
+        specifier: ^6.43.0
+        version: 6.43.0
       '@iconify-json/mdi':
         specifier: ^1.2.3
         version: 1.2.3
@@ -153,14 +181,14 @@ importers:
         specifier: workspace:*
         version: link:../service
       '@wdio/protocols':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       codemirror:
         specifier: ^6.0.2
         version: 6.0.2
       lit:
-        specifier: ^3.3.2
-        version: 3.3.2
+        specifier: ^3.3.3
+        version: 3.3.3
       placeholder-loading:
         specifier: ^0.7.0
         version: 0.7.0
@@ -168,45 +196,48 @@ importers:
         specifier: ^2.5.3
         version: 2.5.3
       preact:
-        specifier: ^10.27.1
-        version: 10.29.1
+        specifier: ^10.29.2
+        version: 10.29.2
     devDependencies:
       '@tailwindcss/postcss':
-        specifier: ^4.1.18
-        version: 4.2.2
+        specifier: ^4.3.0
+        version: 4.3.0
+      '@wdio/devtools-shared':
+        specifier: workspace:^
+        version: link:../shared
       '@wdio/reporter':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       autoprefixer:
-        specifier: ^10.4.21
-        version: 10.4.21(postcss@8.5.6)
+        specifier: ^10.5.0
+        version: 10.5.0(postcss@8.5.15)
       postcss:
-        specifier: ^8.5.6
-        version: 8.5.6
+        specifier: ^8.5.15
+        version: 8.5.15
       postcss-import:
         specifier: ^16.1.1
-        version: 16.1.1(postcss@8.5.6)
+        version: 16.1.1(postcss@8.5.15)
       rollup:
-        specifier: ^4.47.0
-        version: 4.60.1
+        specifier: ^4.61.0
+        version: 4.61.0
       stylelint:
-        specifier: ^17.6.0
-        version: 17.6.0(typescript@6.0.2)
+        specifier: ^17.12.0
+        version: 17.12.0(typescript@6.0.3)
       stylelint-config-recommended:
         specifier: ^18.0.0
-        version: 18.0.0(stylelint@17.6.0(typescript@6.0.2))
+        version: 18.0.0(stylelint@17.12.0(typescript@6.0.3))
       stylelint-config-tailwindcss:
         specifier: ^1.0.1
-        version: 1.0.1(stylelint@17.6.0(typescript@6.0.2))(tailwindcss@4.2.2)
+        version: 1.0.1(stylelint@17.12.0(typescript@6.0.3))(tailwindcss@4.3.0)
       tailwindcss:
-        specifier: ~4.2.2
-        version: 4.2.2
+        specifier: ~4.3.0
+        version: 4.3.0
       typescript:
-        specifier: 6.0.2
-        version: 6.0.2
+        specifier: 6.0.3
+        version: 6.0.3
       vite:
         specifier: ^8.0.7
-        version: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+        version: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
 
   packages/backend:
     dependencies:
@@ -214,14 +245,14 @@ importers:
         specifier: ^10.3.0
         version: 10.3.0
       '@fastify/static':
-        specifier: ^9.0.0
-        version: 9.1.0
+        specifier: ^9.1.3
+        version: 9.1.3
       '@fastify/websocket':
         specifier: ^11.2.0
         version: 11.2.0
       '@wdio/cli':
-        specifier: 9.27.0
-        version: 9.27.0(@types/node@25.5.2)(expect-webdriverio@5.6.5)(puppeteer-core@21.11.0)
+        specifier: 9.27.2
+        version: 9.27.2(@types/node@25.9.1)(expect-webdriverio@5.6.7)(puppeteer-core@21.11.0)
       '@wdio/devtools-app':
         specifier: workspace:^
         version: link:../app
@@ -229,20 +260,23 @@ importers:
         specifier: 9.18.0
         version: 9.18.0
       fastify:
-        specifier: ^5.8.4
-        version: 5.8.4
+        specifier: ^5.8.5
+        version: 5.8.5
       get-port:
-        specifier: ^7.1.0
+        specifier: ^7.2.0
         version: 7.2.0
       import-meta-resolve:
-        specifier: ^4.1.0
+        specifier: ^4.2.0
         version: 4.2.0
       shell-quote:
-        specifier: ^1.8.3
-        version: 1.8.3
+        specifier: ^1.8.4
+        version: 1.8.4
       tree-kill:
         specifier: ^1.2.2
         version: 1.2.2
+      ws:
+        specifier: ^8.21.0
+        version: 8.21.0
     devDependencies:
       '@types/shell-quote':
         specifier: ^1.7.5
@@ -250,12 +284,33 @@ importers:
       '@types/ws':
         specifier: ^8.18.1
         version: 8.18.1
+      '@wdio/devtools-shared':
+        specifier: workspace:^
+        version: link:../shared
       nodemon:
         specifier: ^3.1.14
         version: 3.1.14
+      tsup:
+        specifier: ^8.5.1
+        version: 8.5.1(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0)
+
+  packages/core:
+    devDependencies:
+      '@types/ws':
+        specifier: ^8.18.1
+        version: 8.18.1
+      '@wdio/devtools-script':
+        specifier: workspace:*
+        version: link:../script
+      '@wdio/devtools-shared':
+        specifier: workspace:^
+        version: link:../shared
+      stacktrace-parser:
+        specifier: ^0.1.11
+        version: 0.1.11
       ws:
-        specifier: ^8.18.3
-        version: 8.20.0
+        specifier: ^8.21.0
+        version: 8.21.0
 
   packages/nightwatch-devtools:
     dependencies:
@@ -266,11 +321,14 @@ importers:
         specifier: workspace:*
         version: link:../script
       '@wdio/logger':
-        specifier: ^9.6.0
+        specifier: ^9.18.0
         version: 9.18.0
       devtools:
         specifier: ^8.42.0
         version: 8.42.0
+      fluent-ffmpeg:
+        specifier: ^2.1.3
+        version: 2.1.3
       import-meta-resolve:
         specifier: ^4.2.0
         version: 4.2.0
@@ -278,27 +336,36 @@ importers:
         specifier: ^0.1.11
         version: 0.1.11
       webdriverio:
-        specifier: ^9.18.0
-        version: 9.27.0(puppeteer-core@21.11.0)
+        specifier: ^9.27.2
+        version: 9.27.2(puppeteer-core@21.11.0)
       ws:
-        specifier: ^8.18.3
-        version: 8.20.0
+        specifier: ^8.21.0
+        version: 8.21.0
     devDependencies:
       '@types/node':
-        specifier: 25.5.2
-        version: 25.5.2
+        specifier: 25.9.1
+        version: 25.9.1
       '@types/ws':
         specifier: ^8.18.1
         version: 8.18.1
+      '@wdio/devtools-core':
+        specifier: workspace:^
+        version: link:../core
+      '@wdio/devtools-shared':
+        specifier: workspace:^
+        version: link:../shared
       chromedriver:
-        specifier: ^148.0.3
-        version: 148.0.3
+        specifier: ^148.0.4
+        version: 148.0.4
       nightwatch:
-        specifier: ^3.0.0
-        version: 3.15.0(@cucumber/cucumber@11.3.0)(chromedriver@148.0.3)
+        specifier: ^3.16.0
+        version: 3.16.0(@cucumber/cucumber@13.0.0)(chromedriver@148.0.4)
+      tsup:
+        specifier: ^8.5.1
+        version: 8.5.1(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0)
       typescript:
-        specifier: ^6.0.2
-        version: 6.0.2
+        specifier: ^6.0.3
+        version: 6.0.3
 
   packages/script:
     dependencies:
@@ -306,18 +373,18 @@ importers:
         specifier: ^3.1.1
         version: 3.1.1
       parse5:
-        specifier: ^8.0.0
-        version: 8.0.0
+        specifier: ^8.0.1
+        version: 8.0.1
       preact:
-        specifier: ^10.27.1
-        version: 10.29.1
+        specifier: ^10.29.2
+        version: 10.29.2
       vite-plugin-singlefile:
-        specifier: ^2.3.2
-        version: 2.3.2(rollup@4.60.1)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
+        specifier: ^2.3.3
+        version: 2.3.3(rollup@4.61.0)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
     devDependencies:
       vite:
         specifier: ^8.0.7
-        version: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+        version: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
 
   packages/selenium-devtools:
     dependencies:
@@ -328,45 +395,54 @@ importers:
         specifier: workspace:*
         version: link:../script
       '@wdio/logger':
-        specifier: ^9.6.0
+        specifier: ^9.18.0
         version: 9.18.0
       stacktrace-parser:
         specifier: ^0.1.11
         version: 0.1.11
       webdriverio:
-        specifier: ^9.18.0
-        version: 9.27.0(puppeteer-core@21.11.0)
+        specifier: ^9.27.2
+        version: 9.27.2(puppeteer-core@21.11.0)
       ws:
-        specifier: ^8.18.3
-        version: 8.20.0
+        specifier: ^8.21.0
+        version: 8.21.0
     devDependencies:
       '@cucumber/cucumber':
-        specifier: ^11.1.0
-        version: 11.3.0
+        specifier: ^13.0.0
+        version: 13.0.0
       '@types/node':
-        specifier: 25.5.2
-        version: 25.5.2
+        specifier: 25.9.1
+        version: 25.9.1
       '@types/ws':
         specifier: ^8.18.1
         version: 8.18.1
+      '@wdio/devtools-core':
+        specifier: workspace:^
+        version: link:../core
+      '@wdio/devtools-shared':
+        specifier: workspace:^
+        version: link:../shared
       chromedriver:
-        specifier: ^147.0.1
-        version: 147.0.1
+        specifier: ^148.0.4
+        version: 148.0.4
       jest:
-        specifier: ^29.7.0
-        version: 29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
+        specifier: ^30.4.2
+        version: 30.4.2(@types/node@25.9.1)(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3))
       mocha:
-        specifier: ^10.7.0
-        version: 10.8.2
+        specifier: ^11.7.6
+        version: 11.7.6
       selenium-webdriver:
-        specifier: ^4.27.0
-        version: 4.27.0
+        specifier: ^4.44.0
+        version: 4.44.0
+      tsup:
+        specifier: ^8.5.1
+        version: 8.5.1(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0)
       typescript:
-        specifier: ^6.0.2
-        version: 6.0.2
+        specifier: ^6.0.3
+        version: 6.0.3
       vitest:
-        specifier: ^2.1.9
-        version: 2.1.9(@types/node@25.5.2)(@vitest/browser@4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))))(esbuild@0.27.7)(happy-dom@20.8.9)(jiti@2.6.1)(jsdom@24.1.3)(tsx@4.21.0)(yaml@2.8.3)
+        specifier: ^4.1.8
+        version: 4.1.8(@types/node@25.9.1)(@vitest/coverage-v8@4.1.8)(happy-dom@20.9.0)(jsdom@24.1.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
     optionalDependencies:
       fluent-ffmpeg:
         specifier: ^2.1.3
@@ -375,14 +451,14 @@ importers:
   packages/service:
     dependencies:
       '@babel/parser':
-        specifier: ^7.28.4
-        version: 7.29.2
+        specifier: ^7.29.7
+        version: 7.29.7
       '@babel/traverse':
-        specifier: ^7.28.4
-        version: 7.29.0
+        specifier: ^7.29.7
+        version: 7.29.7
       '@babel/types':
-        specifier: ^7.28.4
-        version: 7.29.0
+        specifier: ^7.29.7
+        version: 7.29.7
       '@wdio/devtools-backend':
         specifier: workspace:^
         version: link:../backend
@@ -393,11 +469,11 @@ importers:
         specifier: 9.18.0
         version: 9.18.0
       '@wdio/reporter':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       '@wdio/types':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       devtools:
         specifier: ^8.42.0
         version: 8.42.0
@@ -405,17 +481,20 @@ importers:
         specifier: ^2.1.3
         version: 2.1.3
       import-meta-resolve:
-        specifier: ^4.1.0
+        specifier: ^4.2.0
         version: 4.2.0
       stack-trace:
-        specifier: 1.0.0-pre2
-        version: 1.0.0-pre2
+        specifier: ^1.0.0
+        version: 1.0.0
+      stacktrace-parser:
+        specifier: ^0.1.11
+        version: 0.1.11
       webdriverio:
         specifier: ^9.19.1
-        version: 9.27.0(puppeteer-core@21.11.0)
+        version: 9.27.2(puppeteer-core@21.11.0)
       ws:
-        specifier: ^8.18.3
-        version: 8.20.0
+        specifier: ^8.21.0
+        version: 8.21.0
     devDependencies:
       '@types/babel__core':
         specifier: ^7.20.5
@@ -424,7 +503,7 @@ importers:
         specifier: ^7.28.0
         version: 7.28.0
       '@types/fluent-ffmpeg':
-        specifier: ^2.1.27
+        specifier: ^2.1.28
         version: 2.1.28
       '@types/stack-trace':
         specifier: ^0.0.33
@@ -432,21 +511,29 @@ importers:
       '@types/ws':
         specifier: ^8.18.1
         version: 8.18.1
+      '@wdio/devtools-core':
+        specifier: workspace:^
+        version: link:../core
+      '@wdio/devtools-shared':
+        specifier: workspace:^
+        version: link:../shared
       '@wdio/globals':
-        specifier: 9.27.0
-        version: 9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+        specifier: 9.27.2
+        version: 9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       '@wdio/protocols':
-        specifier: 9.27.0
-        version: 9.27.0
+        specifier: 9.27.2
+        version: 9.27.2
       typescript:
-        specifier: 6.0.2
-        version: 6.0.2
+        specifier: 6.0.3
+        version: 6.0.3
       vite:
         specifier: ^8.0.7
-        version: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+        version: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
       vite-plugin-dts:
-        specifier: ^4.5.4
-        version: 4.5.4(@types/node@25.5.2)(rollup@4.60.1)(typescript@6.0.2)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
+        specifier: ^5.0.2
+        version: 5.0.2(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(esbuild@0.28.0)(rolldown@1.0.3)(rollup@4.61.0)(typescript@6.0.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+
+  packages/shared: {}
 
 packages:
 
@@ -460,62 +547,62 @@ packages:
   '@asamuzakjp/css-color@3.2.0':
     resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==}
 
-  '@babel/code-frame@7.29.0':
-    resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==}
+  '@babel/code-frame@7.29.7':
+    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/compat-data@7.29.0':
-    resolution: {integrity: sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==}
+  '@babel/compat-data@7.29.7':
+    resolution: {integrity: sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/core@7.29.0':
-    resolution: {integrity: sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==}
+  '@babel/core@7.29.7':
+    resolution: {integrity: sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/generator@7.29.1':
-    resolution: {integrity: sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==}
+  '@babel/generator@7.29.7':
+    resolution: {integrity: sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-compilation-targets@7.28.6':
-    resolution: {integrity: sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==}
+  '@babel/helper-compilation-targets@7.29.7':
+    resolution: {integrity: sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-globals@7.28.0':
-    resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
+  '@babel/helper-globals@7.29.7':
+    resolution: {integrity: sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-module-imports@7.28.6':
-    resolution: {integrity: sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==}
+  '@babel/helper-module-imports@7.29.7':
+    resolution: {integrity: sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-module-transforms@7.28.6':
-    resolution: {integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==}
+  '@babel/helper-module-transforms@7.29.7':
+    resolution: {integrity: sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
 
-  '@babel/helper-plugin-utils@7.28.6':
-    resolution: {integrity: sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==}
+  '@babel/helper-plugin-utils@7.29.7':
+    resolution: {integrity: sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-string-parser@7.27.1':
-    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+  '@babel/helper-string-parser@7.29.7':
+    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-identifier@7.28.5':
-    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
+  '@babel/helper-validator-identifier@7.29.7':
+    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-option@7.27.1':
-    resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
+  '@babel/helper-validator-option@7.29.7':
+    resolution: {integrity: sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helpers@7.29.2':
-    resolution: {integrity: sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==}
+  '@babel/helpers@7.29.7':
+    resolution: {integrity: sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/parser@7.29.2':
-    resolution: {integrity: sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==}
+  '@babel/parser@7.29.7':
+    resolution: {integrity: sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
@@ -540,8 +627,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-syntax-import-attributes@7.28.6':
-    resolution: {integrity: sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==}
+  '@babel/plugin-syntax-import-attributes@7.29.7':
+    resolution: {integrity: sha512-zGYcYfq/WmZ4V+kBIXQon9dSSc8ircGZqw9ZaNhhGj9nZkeBu1jHLBDQqYYi5WA9uawvA2sIMbry2nCFhf5Djg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -556,8 +643,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-syntax-jsx@7.28.6':
-    resolution: {integrity: sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==}
+  '@babel/plugin-syntax-jsx@7.29.7':
+    resolution: {integrity: sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -604,22 +691,22 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-syntax-typescript@7.28.6':
-    resolution: {integrity: sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==}
+  '@babel/plugin-syntax-typescript@7.29.7':
+    resolution: {integrity: sha512-ngr+82Sh0xMz25TPCZi+nC2iTzjfCdWS2ONXTp/PtSCHCgaCNBpdMqgvJ2ccdLlClVZ7sisIgB914j/JFe+RZA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/template@7.28.6':
-    resolution: {integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==}
+  '@babel/template@7.29.7':
+    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/traverse@7.29.0':
-    resolution: {integrity: sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==}
+  '@babel/traverse@7.29.7':
+    resolution: {integrity: sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/types@7.29.0':
-    resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
+  '@babel/types@7.29.7':
+    resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
     engines: {node: '>=6.9.0'}
 
   '@bazel/runfiles@6.5.0':
@@ -628,32 +715,36 @@ packages:
   '@bcoe/v8-coverage@0.2.3':
     resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==}
 
+  '@bcoe/v8-coverage@1.0.2':
+    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
+    engines: {node: '>=18'}
+
   '@blazediff/core@1.9.1':
     resolution: {integrity: sha512-ehg3jIkYKulZh+8om/O25vkvSsXXwC+skXmyA87FFx6A/45eqOkZsBltMw/TVteb0mloiGT8oGRTcjRAz66zaA==}
 
-  '@cacheable/memory@2.0.8':
-    resolution: {integrity: sha512-FvEb29x5wVwu/Kf93IWwsOOEuhHh6dYCJF3vcKLzXc0KXIW181AOzv6ceT4ZpBHDvAfG60eqb+ekmrnLHIy+jw==}
+  '@cacheable/memory@2.0.9':
+    resolution: {integrity: sha512-HdMx6DoGywB30vacDbBsITbIX4pgFqj1zsrV58jZBUw3klzkNoXhj7qOqAgledhxG7YZI5rBSJg7Zp8/VG0DuA==}
 
   '@cacheable/utils@2.4.1':
     resolution: {integrity: sha512-eiFgzCbIneyMlLOmNG4g9xzF7Hv3Mga4LjxjcSC/ues6VYq2+gUbQI8JqNuw/ZM8tJIeIaBGpswAsqV2V7ApgA==}
 
-  '@codemirror/autocomplete@6.19.1':
-    resolution: {integrity: sha512-q6NenYkEy2fn9+JyjIxMWcNjzTL/IhwqfzOut1/G3PrIFkrbl4AL7Wkse5tLrQUUyqGoAKU5+Pi5jnnXxH5HGw==}
+  '@codemirror/autocomplete@6.20.2':
+    resolution: {integrity: sha512-G5FPkgIiLjOgZMjqVjvuKQ1rGPtHogLldJr33eFJdVLtmwY+giGrlv/ewljLz6b9BSQLkjxuwBc6g6omDM+YxQ==}
 
-  '@codemirror/commands@6.10.0':
-    resolution: {integrity: sha512-2xUIc5mHXQzT16JnyOFkh8PvfeXuIut3pslWGfsGOhxP/lpgRm9HOl/mpzLErgt5mXDovqA0d11P21gofRLb9w==}
+  '@codemirror/commands@6.10.3':
+    resolution: {integrity: sha512-JFRiqhKu+bvSkDLI+rUhJwSxQxYb759W5GBezE8Uc8mHLqC9aV/9aTC7yJSqCtB3F00pylrLCwnyS91Ap5ej4Q==}
 
   '@codemirror/lang-javascript@6.2.5':
     resolution: {integrity: sha512-zD4e5mS+50htS7F+TYjBPsiIFGanfVqg4HyUz6WNFikgOPf2BgKlx+TQedI1w6n/IqRBVBbBWmGFdLB/7uxO4A==}
 
-  '@codemirror/language@6.11.3':
-    resolution: {integrity: sha512-9HBM2XnwDj7fnu0551HkGdrUrrqmYq/WC5iv6nbY2WdicXdGbhR/gfbZOH73Aqj4351alY1+aoG9rCNfiwS1RA==}
+  '@codemirror/language@6.12.3':
+    resolution: {integrity: sha512-QwCZW6Tt1siP37Jet9Tb02Zs81TQt6qQrZR2H+eGMcFsL1zMrk2/b9CLC7/9ieP1fjIUMgviLWMmgiHoJrj+ZA==}
 
-  '@codemirror/lint@6.9.1':
-    resolution: {integrity: sha512-te7To1EQHePBQQzasDKWmK2xKINIXpk+xAiSYr9ZN+VB4KaT+/Hi2PEkeErTk5BV3PTz1TLyQL4MtJfPkKZ9sw==}
+  '@codemirror/lint@6.9.6':
+    resolution: {integrity: sha512-6Kp7r6XfCi/D/5sdXieMfg9pJU1bUEx96WITuLU6ESaKizCz0QHFMjY/TaFSbigDdEAIgi93itLBIUETP4oK+A==}
 
-  '@codemirror/search@6.5.11':
-    resolution: {integrity: sha512-KmWepDE6jUdL6n8cAAqIpRmLPBZ5ZKnicE8oGU/s3QrAVID+0VhLFrzUucVKHG5035/BSykhExDL/Xm7dHthiA==}
+  '@codemirror/search@6.7.0':
+    resolution: {integrity: sha512-ZvGm99wc/s2cITtMT15LFdn8aH/aS+V+DqyGq/N5ZlV5vWtH+nILvC2nw0zX7ByNoHHDZ2IxxdW38O0tc5nVHg==}
 
   '@codemirror/state@6.5.4':
     resolution: {integrity: sha512-8y7xqG/hpB53l25CIoit9/ngxdfoG+fx+V3SHBrinnhOtLvKHRyAJJuHzkWrR4YXXLX8eXBsejgAAxHUOdW1yw==}
@@ -661,8 +752,8 @@ packages:
   '@codemirror/theme-one-dark@6.1.3':
     resolution: {integrity: sha512-NzBdIvEJmx6fjeremiGp3t/okrLPYT0d9orIc7AFun8oZcRk58aejkqhv6spnz4MLAevrKNPMQYXEWMg4s+sKA==}
 
-  '@codemirror/view@6.41.0':
-    resolution: {integrity: sha512-6H/qadXsVuDY219Yljhohglve8xf4B8xJkVOEWfA5uiYKiTFppjqsvsfR5iPA0RbvRBoOyTZpbLIxe9+0UR8xA==}
+  '@codemirror/view@6.43.0':
+    resolution: {integrity: sha512-V7ZCLQO3Jus9hzh2jVCCPW3mO4IBMr43O37PqSUYautJSnnJF41YlgLw21x0fLJTYvJ+Vkm6Gp+qKGH9pltgXA==}
 
   '@colors/colors@1.5.0':
     resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==}
@@ -683,8 +774,8 @@ packages:
       '@csstools/css-parser-algorithms': ^3.0.5
       '@csstools/css-tokenizer': ^3.0.4
 
-  '@csstools/css-calc@3.1.1':
-    resolution: {integrity: sha512-HJ26Z/vmsZQqs/o3a6bgKslXGFAungXGbinULZO3eMsOyNJHeBBZfup5FiZInOghgoM4Hwnmw+OgbJCNg1wwUQ==}
+  '@csstools/css-calc@3.2.1':
+    resolution: {integrity: sha512-DtdHlgXh5ZkA43cwBcAm+huzgJiwx3ZTWVjBs94kwz2xKqSimDA3lBgCjphYgwgVUMWatSM0pDd8TILB1yrVVg==}
     engines: {node: '>=20.19.0'}
     peerDependencies:
       '@csstools/css-parser-algorithms': ^4.0.0
@@ -709,8 +800,8 @@ packages:
     peerDependencies:
       '@csstools/css-tokenizer': ^4.0.0
 
-  '@csstools/css-syntax-patches-for-csstree@1.1.2':
-    resolution: {integrity: sha512-5GkLzz4prTIpoyeUiIu3iV6CSG3Plo7xRVOFPKI7FVEJ3mZ0A8SwK0XU3Gl7xAkiQ+mDyam+NNp875/C5y+jSA==}
+  '@csstools/css-syntax-patches-for-csstree@1.1.4':
+    resolution: {integrity: sha512-wgsqt92b7C7tQhIdPNxj0n9zuUbQlvAuI1exyzeNrOKOi62SD7ren8zqszmpVREjAOqg8cD2FqYhQfAuKjk4sw==}
     peerDependencies:
       css-tree: ^3.2.1
     peerDependenciesMeta:
@@ -747,20 +838,23 @@ packages:
   '@cucumber/ci-environment@10.0.1':
     resolution: {integrity: sha512-/+ooDMPtKSmvcPMDYnMZt4LuoipfFfHaYspStI4shqw8FyKcfQAmekz6G+QKWjQQrvM+7Hkljwx58MEwPCwwzg==}
 
+  '@cucumber/ci-environment@13.0.0':
+    resolution: {integrity: sha512-cs+3NzfNkGbcmHPddjEv4TKFiBpZRQ6WJEEufB9mw+ExS22V/4R/zpDSEG+fsJ/iSNCd6A2sATdY8PFOyY3YnA==}
+
   '@cucumber/cucumber-expressions@17.1.0':
     resolution: {integrity: sha512-PCv/ppsPynniKPWJr5v566daCVe+pbxQpHGrIu/Ev57cCH9Rv+X0F6lio4Id3Z64TaG7btCRLUGewIgLwmrwOA==}
 
-  '@cucumber/cucumber-expressions@18.0.1':
-    resolution: {integrity: sha512-NSid6bI+7UlgMywl5octojY5NXnxR9uq+JisjOrO52VbFsQM6gTWuQFE8syI10KnIBEdPzuEUSVEeZ0VFzRnZA==}
+  '@cucumber/cucumber-expressions@19.0.1':
+    resolution: {integrity: sha512-tJrTgCZ5/vgDBfAs2pQu0fu88gPJIGQ40AC/3ftg5/i/BwnhX/W1MbaFF8A+tanY1zbUWWarGFJ2QMKItPQ/QQ==}
 
   '@cucumber/cucumber@10.9.0':
     resolution: {integrity: sha512-7XHJ6nmr9IkIag0nv6or82HfelbSInrEe3H4aT6dMHyTehwFLUifG6eQQ+uE4LZIOXAnzLPH37YmqygEO67vCA==}
     engines: {node: 18 || >=20}
     hasBin: true
 
-  '@cucumber/cucumber@11.3.0':
-    resolution: {integrity: sha512-1YGsoAzRfDyVOnRMTSZP/EcFsOBElOKa2r+5nin0DJAeK+Mp0mzjcmSllMgApGtck7Ji87wwy3kFONfHUHMn4g==}
-    engines: {node: 18 || 20 || 22 || >=23}
+  '@cucumber/cucumber@13.0.0':
+    resolution: {integrity: sha512-lUD/IxGZXbfSP+pd7zaYvJIJXBaTZ36CmQxcLDYkilGH8y4ycaOnXe7ll0QFukYFh9/1x6S7pw6lYspJg6g7jw==}
+    engines: {node: 22 || 24 || >=26}
     hasBin: true
 
   '@cucumber/gherkin-streams@5.0.1':
@@ -771,12 +865,20 @@ packages:
       '@cucumber/message-streams': '>=4.0.0'
       '@cucumber/messages': '>=17.1.1'
 
-  '@cucumber/gherkin-utils@9.0.0':
-    resolution: {integrity: sha512-clk4q39uj7pztZuZtyI54V8lRsCUz0Y/p8XRjIeHh7ExeEztpWkp4ca9q1FjUOPfQQ8E7OgqFbqoQQXZ1Bx7fw==}
+  '@cucumber/gherkin-streams@6.0.0':
+    resolution: {integrity: sha512-HLSHMmdDH0vCr7vsVEURcDA4WwnRLdjkhqr6a4HQ3i4RFK1wiDGPjBGVdGJLyuXuRdJpJbFc6QxHvT8pU4t6jw==}
+    hasBin: true
+    peerDependencies:
+      '@cucumber/gherkin': '>=22.0.0'
+      '@cucumber/message-streams': '>=4.0.0'
+      '@cucumber/messages': '>=17.1.1'
+
+  '@cucumber/gherkin-utils@11.0.0':
+    resolution: {integrity: sha512-LJ+s4+TepHTgdKWDR4zbPyT7rQjmYIcukTwNbwNwgqr6i8Gjcmzf6NmtbYDA19m1ZFg6kWbFsmHnj37ZuX+kZA==}
     hasBin: true
 
-  '@cucumber/gherkin-utils@9.2.0':
-    resolution: {integrity: sha512-3nmRbG1bUAZP3fAaUBNmqWO0z0OSkykZZotfLjyhc8KWwDSOrOmMJlBTd474lpA8EWh4JFLAX3iXgynBqBvKzw==}
+  '@cucumber/gherkin-utils@9.0.0':
+    resolution: {integrity: sha512-clk4q39uj7pztZuZtyI54V8lRsCUz0Y/p8XRjIeHh7ExeEztpWkp4ca9q1FjUOPfQQ8E7OgqFbqoQQXZ1Bx7fw==}
     hasBin: true
 
   '@cucumber/gherkin@28.0.0':
@@ -785,24 +887,24 @@ packages:
   '@cucumber/gherkin@29.0.0':
     resolution: {integrity: sha512-6t3V7fFsLlyhLSj4FS+fPz22pPVcFhFZ3QOP7otFYmkhZ4g1ierj5pf7fxJWvEsI555hGatg+Iql6cqK93RFUg==}
 
-  '@cucumber/gherkin@30.0.4':
-    resolution: {integrity: sha512-pb7lmAJqweZRADTTsgnC3F5zbTh3nwOB1M83Q9ZPbUKMb3P76PzK6cTcPTJBHWy3l7isbigIv+BkDjaca6C8/g==}
+  '@cucumber/gherkin@38.0.0':
+    resolution: {integrity: sha512-duEXK+KDfQUzu3vsSzXjkxQ2tirF5PRsc1Xrts6THKHJO6mjw4RjM8RV+vliuDasmhhrmdLcOcM7d9nurNTJKw==}
 
-  '@cucumber/gherkin@31.0.0':
-    resolution: {integrity: sha512-wlZfdPif7JpBWJdqvHk1Mkr21L5vl4EfxVUOS4JinWGf3FLRV6IKUekBv5bb5VX79fkDcfDvESzcQ8WQc07Wgw==}
+  '@cucumber/gherkin@39.1.0':
+    resolution: {integrity: sha512-pqmSO2bUWxJm3TbNrKXlDaHjL6c77+ez9kWmfCd9oRPeTRPEVH3spZvpAqdXYWOZYSNYwWFCAAeZ4RGpkauNoQ==}
 
-  '@cucumber/html-formatter@21.10.1':
-    resolution: {integrity: sha512-isaaNMNnBYThsvaHy7i+9kkk9V3+rhgdkt0pd6TCY6zY1CSRZQ7tG6ST9pYyRaECyfbCeF7UGH0KpNEnh6UNvQ==}
+  '@cucumber/html-formatter@21.6.0':
+    resolution: {integrity: sha512-Qw1tdObBJrgXgXwVjKVjB3hFhFPI8WhIFb+ULy8g5lDl5AdnKDiyDXAMvAWRX+pphnRMMNdkPCt6ZXEfWvUuAA==}
     peerDependencies:
       '@cucumber/messages': '>=18'
 
-  '@cucumber/html-formatter@21.6.0':
-    resolution: {integrity: sha512-Qw1tdObBJrgXgXwVjKVjB3hFhFPI8WhIFb+ULy8g5lDl5AdnKDiyDXAMvAWRX+pphnRMMNdkPCt6ZXEfWvUuAA==}
+  '@cucumber/html-formatter@23.1.0':
+    resolution: {integrity: sha512-DcCSFoGs6jbwzXPgX1CwgJKEE+ZMcIEzq/0Memg0o24maNn9NJizBFHmoFWG4iv/OxHza+mvc+56cTHetfHndw==}
     peerDependencies:
       '@cucumber/messages': '>=18'
 
-  '@cucumber/junit-xml-formatter@0.7.1':
-    resolution: {integrity: sha512-AzhX+xFE/3zfoYeqkT7DNq68wAQfBcx4Dk9qS/ocXM2v5tBv6eFQ+w8zaSfsktCjYzu4oYRH/jh4USD1CYHfaQ==}
+  '@cucumber/junit-xml-formatter@0.13.3':
+    resolution: {integrity: sha512-w9ujOxiuKDtU6fLzJz+wp4Sgp5Xu6ba7ls00LHJccVmQU0Ba7zs+AHnv3iIgPjKZAQe1w8x93dr8Gaubh7Vqkg==}
     peerDependencies:
       '@cucumber/messages': '*'
 
@@ -811,6 +913,11 @@ packages:
     peerDependencies:
       '@cucumber/messages': '>=17.1.1'
 
+  '@cucumber/message-streams@4.1.1':
+    resolution: {integrity: sha512-QCAntLajesWMyX+mZKrj63YghVAts7yKFlZe46XprLbdJZN0ddB+f/Mr9OnyWKC2DHhJ18jzCfKIFCaqpAmUxg==}
+    peerDependencies:
+      '@cucumber/messages': '>=17.1.1'
+
   '@cucumber/messages@24.1.0':
     resolution: {integrity: sha512-hxVHiBurORcobhVk80I9+JkaKaNXkW6YwGOEFIh/2aO+apAN+5XJgUUWjng9NwqaQrW1sCFuawLB1AuzmBaNdQ==}
 
@@ -820,28 +927,33 @@ packages:
   '@cucumber/messages@26.0.1':
     resolution: {integrity: sha512-DIxSg+ZGariumO+Lq6bn4kOUIUET83A4umrnWmidjGFl8XxkBieUZtsmNbLYgH/gnsmP07EfxxdTr0hOchV1Sg==}
 
-  '@cucumber/messages@27.2.0':
-    resolution: {integrity: sha512-f2o/HqKHgsqzFLdq6fAhfG1FNOQPdBdyMGpKwhb7hZqg0yZtx9BVqkTyuoNk83Fcvk3wjMVfouFXXHNEk4nddA==}
+  '@cucumber/messages@32.3.1':
+    resolution: {integrity: sha512-yNQq1KoXRYaEKrWMFmpUQX7TdeQuU9jeGgJAZ3dArTsC/T4NpJ6DnqaJIIgwPnz/wtQIQTNX7/h0rOuF5xY4qQ==}
+
+  '@cucumber/pretty-formatter@3.3.1':
+    resolution: {integrity: sha512-wy8M/Poaqnoom+YP1mzZMfHEE3pP9/0JAYajkjpHTtanp4KJGpAXdukuUYbmmgFjRXUmUSK3s5I+I5+f+q2blA==}
+    peerDependencies:
+      '@cucumber/messages': '*'
 
-  '@cucumber/query@13.6.0':
-    resolution: {integrity: sha512-tiDneuD5MoWsJ9VKPBmQok31mSX9Ybl+U4wqDoXeZgsXHDURqzM3rnpWVV3bC34y9W6vuFxrlwF/m7HdOxwqRw==}
+  '@cucumber/query@15.0.1':
+    resolution: {integrity: sha512-FMfT3orJblRsOxvU2doECBvQmauizYlj+5JsM8atAKKPbnQTj7v2/OrnuykvQpfZNBf19DYbRq1e832vllRP/g==}
     peerDependencies:
       '@cucumber/messages': '*'
 
   '@cucumber/tag-expressions@6.1.0':
     resolution: {integrity: sha512-+3DwRumrCJG27AtzCIL37A/X+A/gSfxOPLg8pZaruh5SLumsTmpvilwroVWBT2fPzmno/tGXypeK5a7NHU4RzA==}
 
-  '@cucumber/tag-expressions@6.1.2':
-    resolution: {integrity: sha512-xa3pER+ntZhGCxRXSguDTKEHTZpUUsp+RzTRNnit+vi5cqnk6abLdSLg5i3HZXU3c74nQ8afQC6IT507EN74oQ==}
+  '@cucumber/tag-expressions@9.1.0':
+    resolution: {integrity: sha512-bvHjcRFZ+J1TqIa9eFNO1wGHqwx4V9ZKV3hYgkuK/VahHx73uiP4rKV3JVrvWSMrwrFvJG6C8aEwnCWSvbyFdQ==}
 
-  '@emnapi/core@1.9.1':
-    resolution: {integrity: sha512-mukuNALVsoix/w1BJwFzwXBN/dHeejQtuVzcDsfOEsdpCumXb/E9j8w11h5S54tT1xhifGfbbSm/ICrObRb3KA==}
+  '@emnapi/core@1.10.0':
+    resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==}
 
-  '@emnapi/runtime@1.9.1':
-    resolution: {integrity: sha512-VYi5+ZVLhpgK4hQ0TAjiQiZ6ol0oe4mBx7mVv7IflsiEp0OWoVsp/+f9Vc1hOhE0TtkORVrI1GvzyreqpgWtkA==}
+  '@emnapi/runtime@1.10.0':
+    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
 
-  '@emnapi/wasi-threads@1.2.0':
-    resolution: {integrity: sha512-N10dEJNSsUx41Z6pZsXU8FjPjpBEplgH24sfkmITrBED1/U2Esum9F3lfLrMjKHHjmi557zQn7kR9R+XWXu5Rg==}
+  '@emnapi/wasi-threads@1.2.1':
+    resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==}
 
   '@esbuild/aix-ppc64@0.27.7':
     resolution: {integrity: sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==}
@@ -849,156 +961,312 @@ packages:
     cpu: [ppc64]
     os: [aix]
 
+  '@esbuild/aix-ppc64@0.28.0':
+    resolution: {integrity: sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
   '@esbuild/android-arm64@0.27.7':
     resolution: {integrity: sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [android]
 
+  '@esbuild/android-arm64@0.28.0':
+    resolution: {integrity: sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
   '@esbuild/android-arm@0.27.7':
     resolution: {integrity: sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==}
     engines: {node: '>=18'}
     cpu: [arm]
     os: [android]
 
+  '@esbuild/android-arm@0.28.0':
+    resolution: {integrity: sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
   '@esbuild/android-x64@0.27.7':
     resolution: {integrity: sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [android]
 
+  '@esbuild/android-x64@0.28.0':
+    resolution: {integrity: sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
   '@esbuild/darwin-arm64@0.27.7':
     resolution: {integrity: sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [darwin]
 
+  '@esbuild/darwin-arm64@0.28.0':
+    resolution: {integrity: sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
   '@esbuild/darwin-x64@0.27.7':
     resolution: {integrity: sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [darwin]
 
+  '@esbuild/darwin-x64@0.28.0':
+    resolution: {integrity: sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
   '@esbuild/freebsd-arm64@0.27.7':
     resolution: {integrity: sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [freebsd]
 
+  '@esbuild/freebsd-arm64@0.28.0':
+    resolution: {integrity: sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
   '@esbuild/freebsd-x64@0.27.7':
     resolution: {integrity: sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [freebsd]
 
+  '@esbuild/freebsd-x64@0.28.0':
+    resolution: {integrity: sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
   '@esbuild/linux-arm64@0.27.7':
     resolution: {integrity: sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [linux]
 
+  '@esbuild/linux-arm64@0.28.0':
+    resolution: {integrity: sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
   '@esbuild/linux-arm@0.27.7':
     resolution: {integrity: sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==}
     engines: {node: '>=18'}
     cpu: [arm]
     os: [linux]
 
+  '@esbuild/linux-arm@0.28.0':
+    resolution: {integrity: sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
   '@esbuild/linux-ia32@0.27.7':
     resolution: {integrity: sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==}
     engines: {node: '>=18'}
     cpu: [ia32]
     os: [linux]
 
+  '@esbuild/linux-ia32@0.28.0':
+    resolution: {integrity: sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
   '@esbuild/linux-loong64@0.27.7':
     resolution: {integrity: sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==}
     engines: {node: '>=18'}
     cpu: [loong64]
     os: [linux]
 
+  '@esbuild/linux-loong64@0.28.0':
+    resolution: {integrity: sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
   '@esbuild/linux-mips64el@0.27.7':
     resolution: {integrity: sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==}
     engines: {node: '>=18'}
     cpu: [mips64el]
     os: [linux]
 
+  '@esbuild/linux-mips64el@0.28.0':
+    resolution: {integrity: sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
   '@esbuild/linux-ppc64@0.27.7':
     resolution: {integrity: sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==}
     engines: {node: '>=18'}
     cpu: [ppc64]
     os: [linux]
 
+  '@esbuild/linux-ppc64@0.28.0':
+    resolution: {integrity: sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
   '@esbuild/linux-riscv64@0.27.7':
     resolution: {integrity: sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==}
     engines: {node: '>=18'}
     cpu: [riscv64]
     os: [linux]
 
+  '@esbuild/linux-riscv64@0.28.0':
+    resolution: {integrity: sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
   '@esbuild/linux-s390x@0.27.7':
     resolution: {integrity: sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==}
     engines: {node: '>=18'}
     cpu: [s390x]
     os: [linux]
 
+  '@esbuild/linux-s390x@0.28.0':
+    resolution: {integrity: sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
   '@esbuild/linux-x64@0.27.7':
     resolution: {integrity: sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [linux]
 
+  '@esbuild/linux-x64@0.28.0':
+    resolution: {integrity: sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
   '@esbuild/netbsd-arm64@0.27.7':
     resolution: {integrity: sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [netbsd]
 
+  '@esbuild/netbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
   '@esbuild/netbsd-x64@0.27.7':
     resolution: {integrity: sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [netbsd]
 
+  '@esbuild/netbsd-x64@0.28.0':
+    resolution: {integrity: sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
   '@esbuild/openbsd-arm64@0.27.7':
     resolution: {integrity: sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [openbsd]
 
+  '@esbuild/openbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
   '@esbuild/openbsd-x64@0.27.7':
     resolution: {integrity: sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [openbsd]
 
+  '@esbuild/openbsd-x64@0.28.0':
+    resolution: {integrity: sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
   '@esbuild/openharmony-arm64@0.27.7':
     resolution: {integrity: sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [openharmony]
 
+  '@esbuild/openharmony-arm64@0.28.0':
+    resolution: {integrity: sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
   '@esbuild/sunos-x64@0.27.7':
     resolution: {integrity: sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [sunos]
 
+  '@esbuild/sunos-x64@0.28.0':
+    resolution: {integrity: sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
   '@esbuild/win32-arm64@0.27.7':
     resolution: {integrity: sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [win32]
 
+  '@esbuild/win32-arm64@0.28.0':
+    resolution: {integrity: sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
   '@esbuild/win32-ia32@0.27.7':
     resolution: {integrity: sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==}
     engines: {node: '>=18'}
     cpu: [ia32]
     os: [win32]
 
+  '@esbuild/win32-ia32@0.28.0':
+    resolution: {integrity: sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
   '@esbuild/win32-x64@0.27.7':
     resolution: {integrity: sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [win32]
 
+  '@esbuild/win32-x64@0.28.0':
+    resolution: {integrity: sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@eslint-community/eslint-utils@4.9.1':
     resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -1013,8 +1281,8 @@ packages:
     resolution: {integrity: sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
-  '@eslint/config-helpers@0.5.5':
-    resolution: {integrity: sha512-eIJYKTCECbP/nsKaaruF6LW967mtbQbsw4JTtSVkUQc9MneSkbrgPJAbKl9nWr0ZeowV8BfsarBmPpBzGelA2w==}
+  '@eslint/config-helpers@0.6.0':
+    resolution: {integrity: sha512-ii6Bw9jJ2zi2cWA2Z+9/QZ/+3DX6kwaV5Q986D/CdP3Lap3w/pgQZ373FV7byY/i7L4IRH/G43I5dz1ClsCbpA==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
   '@eslint/core@1.2.1':
@@ -1034,8 +1302,8 @@ packages:
     resolution: {integrity: sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
-  '@eslint/plugin-kit@0.7.1':
-    resolution: {integrity: sha512-rZAP3aVgB9ds9KOeUSL+zZ21hPmo8dh6fnIFwRQj5EAZl9gzR7wxYbYXYysAM8CTqGmUGyp2S4kUdV17MnGuWQ==}
+  '@eslint/plugin-kit@0.7.2':
+    resolution: {integrity: sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
   '@fastify/accept-negotiator@2.0.1':
@@ -1065,18 +1333,22 @@ packages:
   '@fastify/send@4.1.0':
     resolution: {integrity: sha512-TMYeQLCBSy2TOFmV95hQWkiTYgC/SEx7vMdV+wnZVX4tt8VBLKzmH8vV9OzJehV0+XBfg+WxPMt5wp+JBUKsVw==}
 
-  '@fastify/static@9.1.0':
-    resolution: {integrity: sha512-EPRNQYqEYEYTK8yyGbcM0iHpyJaupb94bey5O6iCQfLTADr02kaZU+qeHSdd9H9TiMwTBVkrMa59V8CMbn3avQ==}
+  '@fastify/static@9.1.3':
+    resolution: {integrity: sha512-aXrYtsiryLhRxRNaxNqsn7FUISeb7rB9q4eHUPIot5aeQBLNahnz1m6thzm7JWC1poSGXS9XrX8DvuMivp2hkQ==}
 
   '@fastify/websocket@11.2.0':
     resolution: {integrity: sha512-3HrDPbAG1CzUCqnslgJxppvzaAZffieOVbLp1DAy1huCSynUWPifSvfdEDUR8HlJLp3sp1A36uOM2tJogADS8w==}
 
-  '@humanfs/core@0.19.1':
-    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+  '@humanfs/core@0.19.2':
+    resolution: {integrity: sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/node@0.16.8':
+    resolution: {integrity: sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==}
     engines: {node: '>=18.18.0'}
 
-  '@humanfs/node@0.16.7':
-    resolution: {integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==}
+  '@humanfs/types@0.15.0':
+    resolution: {integrity: sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==}
     engines: {node: '>=18.18.0'}
 
   '@humanwhocodes/module-importer@1.0.1':
@@ -1093,8 +1365,8 @@ packages:
   '@iconify/types@2.0.0':
     resolution: {integrity: sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==}
 
-  '@iconify/utils@3.1.0':
-    resolution: {integrity: sha512-Zlzem1ZXhI1iHeeERabLNzBHdOa4VhQbqAcOQaMKuTuyZCpwKbC2R4Dd0Zo3g9EAc+Y4fiarO8HIHRAth7+skw==}
+  '@iconify/utils@3.1.3':
+    resolution: {integrity: sha512-LPKOXPn/zV+zis1oOfGWogaXVpqUybF3ZS6SCZIsz8vg0ivVp9+fVqyYB7xq0aiST/VhUQYGO1qo6uoYSiEJqw==}
 
   '@inquirer/ansi@1.0.2':
     resolution: {integrity: sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==}
@@ -1104,7 +1376,7 @@ packages:
     resolution: {integrity: sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1113,7 +1385,7 @@ packages:
     resolution: {integrity: sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1122,7 +1394,7 @@ packages:
     resolution: {integrity: sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1131,7 +1403,7 @@ packages:
     resolution: {integrity: sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1140,7 +1412,7 @@ packages:
     resolution: {integrity: sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1149,7 +1421,7 @@ packages:
     resolution: {integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1162,7 +1434,7 @@ packages:
     resolution: {integrity: sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1171,7 +1443,7 @@ packages:
     resolution: {integrity: sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1180,7 +1452,7 @@ packages:
     resolution: {integrity: sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1189,7 +1461,7 @@ packages:
     resolution: {integrity: sha512-Dx/y9bCQcXLI5ooQ5KyvA4FTgeo2jYj/7plWfV5Ak5wDPKQZgudKez2ixyfz7tKXzcJciTxqLeK7R9HItwiByg==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1198,7 +1470,7 @@ packages:
     resolution: {integrity: sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1207,7 +1479,7 @@ packages:
     resolution: {integrity: sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1216,7 +1488,7 @@ packages:
     resolution: {integrity: sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -1225,19 +1497,11 @@ packages:
     resolution: {integrity: sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
 
-  '@isaacs/balanced-match@4.0.1':
-    resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
-    engines: {node: 20 || >=22}
-
-  '@isaacs/brace-expansion@5.0.0':
-    resolution: {integrity: sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==}
-    engines: {node: 20 || >=22}
-
   '@isaacs/cliui@8.0.2':
     resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
     engines: {node: '>=12'}
@@ -1250,94 +1514,86 @@ packages:
     resolution: {integrity: sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw==}
     engines: {node: '>=8'}
 
-  '@jest/console@29.7.0':
-    resolution: {integrity: sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/console@30.4.1':
+    resolution: {integrity: sha512-v3bhyxUh9Hgmo5p6hAOXe14/R3ZxZDOsvHleh4B07z3m/x4/ngPUXEm9XwK4sF4u+f+P2ORb0Ge+MgpaqRMVDA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/core@29.7.0':
-    resolution: {integrity: sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/core@30.4.2':
+    resolution: {integrity: sha512-TZJA6cPJUFxoWhxaLo8t0VX/MZX2wPWr0uIDvLSHIvN4gu9h02vSzqI2kBADG1ExqQlC+cY09xKMSreivvrChQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
     peerDependenciesMeta:
       node-notifier:
         optional: true
 
-  '@jest/diff-sequences@30.3.0':
-    resolution: {integrity: sha512-cG51MVnLq1ecVUaQ3fr6YuuAOitHK1S4WUJHnsPFE/quQr33ADUx1FfrTCpMCRxvy0Yr9BThKpDjSlcTi91tMA==}
+  '@jest/diff-sequences@30.4.0':
+    resolution: {integrity: sha512-zOpzlfUs45l6u7jm39qr87JCHUDsaeCtvL+kQe/Vn9jSnRB4/5IPXISm0h9I1vZW/o00Kn4UTJ2MOlhnUGwv3g==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/environment@29.7.0':
-    resolution: {integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  '@jest/expect-utils@29.7.0':
-    resolution: {integrity: sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/environment@30.4.1':
+    resolution: {integrity: sha512-AK9yNRqgKxiabqMoe4oW+3/TSSeV8vkdC7BGaxZdU0AFXfOpofTLqdru2GXKZghP3sdgwE9XXpnVwfZ8JnFV4w==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/expect-utils@30.3.0':
-    resolution: {integrity: sha512-j0+W5iQQ8hBh7tHZkTQv3q2Fh/M7Je72cIsYqC4OaktgtO7v1So9UTjp6uPBHIaB6beoF/RRsCgMJKvti0wADA==}
+  '@jest/expect-utils@30.4.1':
+    resolution: {integrity: sha512-ZBn5CglH8fBsQsvs4VWNzD4aWfUYks+IdOOQU3MEK71ol/BcVm+P+rtb1KpiFBpSWSCE27uOahyyf1vfqOVbcQ==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/expect@29.7.0':
-    resolution: {integrity: sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/expect@30.4.1':
+    resolution: {integrity: sha512-ginrj6TMgh2GshLUGCjO94Ptx9HhdZA/I6A9iUfyeLKFtdAjnKzHDgzgP9HYQgbxM1lbXScQ2eUBz2lGeVDPWA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/fake-timers@29.7.0':
-    resolution: {integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/fake-timers@30.4.1':
+    resolution: {integrity: sha512-iW5umdmfPeWzehrVhugFQZqCchSCud5S1l2YT0O9ZhjRR0ExclANDZkiSBwzqtnlOn0J1JXvO+HZ6rkuyOVOgQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/get-type@30.1.0':
     resolution: {integrity: sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/globals@29.7.0':
-    resolution: {integrity: sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/globals@30.4.1':
+    resolution: {integrity: sha512-ZbuY4cmXC8DkxYjfvT2DbcHWL2T6vmsMhXCDcmTB2T0y0gaezBI77ufq5ZAIdcRkYZ7NEQEDg1xFeKbxUJ5v5Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/pattern@30.0.1':
-    resolution: {integrity: sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==}
+  '@jest/pattern@30.4.0':
+    resolution: {integrity: sha512-RAWn3+f9u8BsHijKJ71uHcFp6vmyEt6VvoWXkl6hKF3qVIuWNmudVjg12DlBPGup/frIl5UcUlH5HfEuvHpEXg==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/reporters@29.7.0':
-    resolution: {integrity: sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/reporters@30.4.1':
+    resolution: {integrity: sha512-/SnkPCzEQpUaBH81kjdEdDdo2WZl5hxw+BmLDGWjRkm8o7XlhjwsU36cqwe5PGBE5WYpBvDzRSdXx9rbGuJtNA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
     peerDependenciesMeta:
       node-notifier:
         optional: true
 
-  '@jest/schemas@29.6.3':
-    resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  '@jest/schemas@30.0.5':
-    resolution: {integrity: sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==}
+  '@jest/schemas@30.4.1':
+    resolution: {integrity: sha512-i6b4qw5qnP8c5FEeBJg/uZQ4ddrkN6Ca8qISJh0pr7a5hfn3h3v5x60BEbOC7OYAGZNMs1LfFLwnW2CuK8F57Q==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/source-map@29.6.3':
-    resolution: {integrity: sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/snapshot-utils@30.4.1':
+    resolution: {integrity: sha512-ObY4ljvQ95mt6iwKtVLetR/4yXiAgl3H4nJxhztr0MTjrN97TwDYrnCp/kF60Ec9HdhkWTHSu+Hg05aXfngpOA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/test-result@29.7.0':
-    resolution: {integrity: sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/source-map@30.0.1':
+    resolution: {integrity: sha512-MIRWMUUR3sdbP36oyNyhbThLHyJ2eEDClPCiHVbrYAe5g3CHRArIVpBw7cdSB5fr+ofSfIb2Tnsw8iEHL0PYQg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/test-sequencer@29.7.0':
-    resolution: {integrity: sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/test-result@30.4.1':
+    resolution: {integrity: sha512-/ZG7pgEiOmmWkN9TplKbOu4id2N5lh7FHwRwlkgBVAzGdRH+OkkQ8wX/kIxg4zmd3ZQvAL1RwL2yWsvNYYECTw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/transform@29.7.0':
-    resolution: {integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/test-sequencer@30.4.1':
+    resolution: {integrity: sha512-PeYE+4td5rKjoRPxztObrXU+H8hsjZfxKMXOcmrr34JerSyB/ROOxbbicz8B7A5j9R9VayDnVPvBmedqCsFCdw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/types@29.6.3':
-    resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  '@jest/transform@30.4.1':
+    resolution: {integrity: sha512-Wz0LyktlTvRefoymh+n64hQ84KNXsRGcwdoZ8CSa0Ea+fgYcHZlnk+hDP7v2MS7il2bQ5uTEIxf4/NNfhMN4KQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  '@jest/types@30.3.0':
-    resolution: {integrity: sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==}
+  '@jest/types@30.4.1':
+    resolution: {integrity: sha512-f1x/vJXIfjOlEmejYpbkbgw1gOqpPECwMvMEtBqe47j7H2Hg8h8w3o3ikhSXq3MI15kg+oQ0exWO0uCtTNJLoQ==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jridgewell/gen-mapping@0.3.13':
@@ -1368,26 +1624,26 @@ packages:
   '@keyv/serialize@1.1.1':
     resolution: {integrity: sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==}
 
-  '@lezer/common@1.3.0':
-    resolution: {integrity: sha512-L9X8uHCYU310o99L3/MpJKYxPzXPOS7S0NmBaM7UO/x2Kb2WbmMLSkfvdr1KxRIFYOpbY0Jhn7CfLSUDzL8arQ==}
+  '@lezer/common@1.5.2':
+    resolution: {integrity: sha512-sxQE460fPZyU3sdc8lafxiPwJHBzZRy/udNFynGQky1SePYBdhkBl1kOagA9uT3pxR8K09bOrmTUqA9wb/PjSQ==}
 
-  '@lezer/highlight@1.2.2':
-    resolution: {integrity: sha512-z8TQwaBXXQIvG6i2g3e9cgMwUUXu9Ib7jo2qRRggdhwKpM56Dw3PM3wmexn+EGaaOZ7az0K7sjc3/gcGW7sz7A==}
+  '@lezer/highlight@1.2.3':
+    resolution: {integrity: sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g==}
 
   '@lezer/javascript@1.5.4':
     resolution: {integrity: sha512-vvYx3MhWqeZtGPwDStM2dwgljd5smolYD2lR2UyFcHfxbBQebqx8yjmFmxtJ/E6nN6u1D9srOiVWm3Rb4tmcUA==}
 
-  '@lezer/lr@1.4.2':
-    resolution: {integrity: sha512-pu0K1jCIdnQ12aWNaAVU5bzi7Bd1w54J3ECgANPmYLtQKP0HBj2cE/5coBD66MT10xbtIuUr7tg0Shbsvk0mDA==}
+  '@lezer/lr@1.4.10':
+    resolution: {integrity: sha512-rnCpTIBafOx4mRp43xOxDJbFipJm/c0cia/V5TiGlhmMa+wsSdoGmUN3w5Bqrks/09Q/D4tNAmWaT8p6NRi77A==}
 
-  '@lit-labs/ssr-dom-shim@1.4.0':
-    resolution: {integrity: sha512-ficsEARKnmmW5njugNYKipTm4SFnbik7CXtoencDZzmzo/dQ+2Q0bgkzJuoJP20Aj0F+izzJjOqsnkd6F/o1bw==}
+  '@lit-labs/ssr-dom-shim@1.6.0':
+    resolution: {integrity: sha512-VHb0ALPMTlgKjM6yIxxoQNnpKyUKLD04VzeQdsiXkMqkvYlAHxq9glGLmgbb889/1GsohSOAjvQYoiBppXFqrQ==}
 
   '@lit/context@1.1.6':
     resolution: {integrity: sha512-M26qDE6UkQbZA2mQ3RjJ3Gzd8TxP+/0obMgE5HfkfLhEEyYE3Bui4A5XHiGPjy0MUGAyxB3QgVuw2ciS0kHn6A==}
 
-  '@lit/reactive-element@2.1.1':
-    resolution: {integrity: sha512-N+dm5PAYdQ8e6UlywyyrgI2t++wFGXfHx+dSJ1oBrg6FAxUj40jId++EaRm80MKX5JnlH1sBsyZ5h0bcZKemCg==}
+  '@lit/reactive-element@2.1.2':
+    resolution: {integrity: sha512-pbCDiVMnne1lYUIaYNN5wrwQXDtHaYtg7YEFPeW+hws6U47WeFvISGUWekPGKWOP1ygrs0ef0o1VJMk1exos5A==}
 
   '@lukeed/ms@2.0.2':
     resolution: {integrity: sha512-9I2Zn6+NJLfaGoz9jN3lpwDgAYvfGeNYdbAIjJOqzs4Tpc+VU3Jqq4IofSUBKajiDS8k9fZIg18/z13mpk1bsA==}
@@ -1396,18 +1652,18 @@ packages:
   '@marijn/find-cluster-break@1.0.2':
     resolution: {integrity: sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==}
 
-  '@microsoft/api-extractor-model@7.31.3':
-    resolution: {integrity: sha512-dv4quQI46p0U03TCEpasUf6JrJL3qjMN7JUAobsPElxBv4xayYYvWW9aPpfYV+Jx6hqUcVaLVOeV7+5hxsyoFQ==}
+  '@microsoft/api-extractor-model@7.33.8':
+    resolution: {integrity: sha512-aIcoQggPyer3B6Ze3usz0YWC/oBwUHfRH5ETUsr+oT2BRA6SfTJl7IKPcPZkX4UR+PohowzW4uMxsvjrn8vm+w==}
 
-  '@microsoft/api-extractor@7.53.3':
-    resolution: {integrity: sha512-p2HmQaMSVqMBj3bH3643f8xApKAqrF1jNpPsMCTQOYCYgfwLnvzsve8c+bgBWzCOBBgLK54PB6ZLIWMGLg8CZA==}
+  '@microsoft/api-extractor@7.58.7':
+    resolution: {integrity: sha512-yK6OycD46gIzLRpj6ueVUWPk1ACSpkN1LBo05gY1qPTylbWyUCanXfH7+VgkI5LJrJoRSQR5F04XuCffCXLOBw==}
     hasBin: true
 
-  '@microsoft/tsdoc-config@0.17.1':
-    resolution: {integrity: sha512-UtjIFe0C6oYgTnad4q1QP4qXwLhe6tIpNTRStJ2RZEPIkqQPREAwE5spzVxsdn9UaEMUqhh0AqSx3X4nWAKXWw==}
+  '@microsoft/tsdoc-config@0.18.1':
+    resolution: {integrity: sha512-9brPoVdfN9k9g0dcWkFeA7IH9bbcttzDJlXvkf8b2OBzd5MueR1V2wkKBL0abn0otvmkHJC6aapBOTJDDeMCZg==}
 
-  '@microsoft/tsdoc@0.15.1':
-    resolution: {integrity: sha512-4aErSrCR/On/e5G2hDP0wjooqDdauzEbIq8hIkIe5pXV0rtWJZvdCEKL0ykZxex+IxIwBp0eGeV48hQN07dXtw==}
+  '@microsoft/tsdoc@0.16.0':
+    resolution: {integrity: sha512-xgAyonlVVS+q7Vc7qLW0UrJU7rSFcETRWsqdXZtjzRU8dF+6CkozTK4V4y1LwOX7j8r/vHphjDeMeGI4tNGeGA==}
 
   '@napi-rs/nice-android-arm-eabi@1.1.1':
     resolution: {integrity: sha512-kjirL3N6TnRPv5iuHw36wnucNqXAO46dzK9oPb0wj076R5Xm8PfUVA9nAFB5ZNMmfJQJVKACAPd/Z2KYMppthw==}
@@ -1515,8 +1771,8 @@ packages:
     resolution: {integrity: sha512-xJIPs+bYuc9ASBl+cvGsKbGrJmS6fAKaSZCnT0lhahT5rhA2VVy9/EcIgd2JhtEuFOJNx7UHNn/qiTPTY4nrQw==}
     engines: {node: '>= 10'}
 
-  '@napi-rs/wasm-runtime@1.1.3':
-    resolution: {integrity: sha512-xK9sGVbJWYb08+mTJt3/YV24WxvxpXcXtP6B172paPZ+Ts69Re9dAr7lKwJoeIx8OoeuimEiRZ7umkiUVClmmQ==}
+  '@napi-rs/wasm-runtime@1.1.4':
+    resolution: {integrity: sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==}
     peerDependencies:
       '@emnapi/core': ^1.7.1
       '@emnapi/runtime': ^1.7.1
@@ -1531,6 +1787,9 @@ packages:
   '@nightwatch/nightwatch-inspector@1.0.1':
     resolution: {integrity: sha512-/ax11EOB4eJXT5VioMztcalbCtsNeuFn6icfT75qPLBmkxLvThePSfyGTys+t9AULUR0ug0wMDMiLV1Oy586Fg==}
 
+  '@nodable/entities@2.1.1':
+    resolution: {integrity: sha512-Pig3HxDIoMgjdEH8OCf/dkcTmLFjJRjWuq8jSnklu284/TKOPibSRERmOykiwmyXTtv61mP+44f3GMx0tLAyjg==}
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -1543,8 +1802,8 @@ packages:
     resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
     engines: {node: '>= 8'}
 
-  '@oxc-project/types@0.123.0':
-    resolution: {integrity: sha512-YtECP/y8Mj1lSHiUWGSRzy/C6teUKlS87dEfuVKT09LgQbUsBW1rNg+MiJ4buGu3yuADV60gbIvo9/HplA56Ew==}
+  '@oxc-project/types@0.133.0':
+    resolution: {integrity: sha512-KzkdCd6Uxqnf6l3HOw1xfatAlUURA0g14cvBYFyJ5SaNOQbOUvBr9PKArcPcrNIeRsBdgcUzOGrhKveVpvOIGA==}
 
   '@pinojs/redact@0.4.0':
     resolution: {integrity: sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==}
@@ -1553,9 +1812,9 @@ packages:
     resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
     engines: {node: '>=14'}
 
-  '@pkgr/core@0.2.9':
-    resolution: {integrity: sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==}
-    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
+  '@pkgr/core@0.3.6':
+    resolution: {integrity: sha512-SEeaJLb3qBNF/OaXnaR1NmmBbFYk1zC0ZH/52fATcRPLFg/p791YrcyFFy44Bo9sLaGuSuLp5Q6axbb/O+v/RA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
 
   '@polka/url@1.0.0-next.29':
     resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
@@ -1568,105 +1827,105 @@ packages:
     engines: {node: '>=16.3.0'}
     hasBin: true
 
-  '@puppeteer/browsers@2.13.0':
-    resolution: {integrity: sha512-46BZJYJjc/WwmKjsvDFykHtXrtomsCIrwYQPOP7VfMJoZY2bsDF9oROBABR3paDjDcmkUye1Pb1BqdcdiipaWA==}
+  '@puppeteer/browsers@2.13.2':
+    resolution: {integrity: sha512-5EUZSUIc37H6aIXyWO0Z4y8NlF8NnjgmqeQgOGiswAU7pY0HOo16ho4+alIWmSfdZnjqBRawMsP3I5YqLSn6kw==}
     engines: {node: '>=18'}
     hasBin: true
 
-  '@rolldown/binding-android-arm64@1.0.0-rc.13':
-    resolution: {integrity: sha512-5ZiiecKH2DXAVJTNN13gNMUcCDg4Jy8ZjbXEsPnqa248wgOVeYRX0iqXXD5Jz4bI9BFHgKsI2qmyJynstbmr+g==}
+  '@rolldown/binding-android-arm64@1.0.3':
+    resolution: {integrity: sha512-454rs7jHngixp/NMxd5srYD57OnzSlZ/eFTETjORQHLwJG1lRtmNOJcBerZlfu4GjKqeq8aCCIQrMdHyhI51Hw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [android]
 
-  '@rolldown/binding-darwin-arm64@1.0.0-rc.13':
-    resolution: {integrity: sha512-tz/v/8G77seu8zAB3A5sK3UFoOl06zcshEzhUO62sAEtrEuW/H1CcyoupOrD+NbQJytYgA4CppXPzlrmp4JZKA==}
+  '@rolldown/binding-darwin-arm64@1.0.3':
+    resolution: {integrity: sha512-PcAhP+ynjURNyy8SKGl5DQP94aGuB/7JrXJb/t7P+hanXvQVMWzUvRRhBAcg/lNRadBhoUPqSoP4xw5tR/KBEA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [darwin]
 
-  '@rolldown/binding-darwin-x64@1.0.0-rc.13':
-    resolution: {integrity: sha512-8DakphqOz8JrMYWTJmWA+vDJxut6LijZ8Xcdc4flOlAhU7PNVwo2MaWBF9iXjJAPo5rC/IxEFZDhJ3GC7NHvug==}
+  '@rolldown/binding-darwin-x64@1.0.3':
+    resolution: {integrity: sha512-9YpfeUvSE2RS7wysJ81uOZkXJz7f7Q55H2Gvp3VEw/EsahqDtrphrZ0EwDLK5vvKOzaCrBsjF8JmnMLcUt78Gg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [darwin]
 
-  '@rolldown/binding-freebsd-x64@1.0.0-rc.13':
-    resolution: {integrity: sha512-4wBQFfjDuXYN/SVI8inBF3Aa+isq40rc6VMFbk5jcpolUBTe5cYnMsHZ51nFWsx3PVyyNN3vgoESki0Hmr/4BA==}
+  '@rolldown/binding-freebsd-x64@1.0.3':
+    resolution: {integrity: sha512-yB1IlAsSNHncV6SCTL27/MVGR5htvQsoGxIv5KMGXALp+Ll1wYsn+x98M9MW7qa+NdSbvrrY7ANI4wLJ0n1e6g==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [freebsd]
 
-  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.13':
-    resolution: {integrity: sha512-JW/e4yPIXLms+jmnbwwy5LA/LxVwZUWLN8xug+V200wzaVi5TEGIWQlh8o91gWYFxW609euI98OCCemmWGuPrw==}
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.3':
+    resolution: {integrity: sha512-Yi30IVAAfLUCy2MseFjbB1jAMDl1VMCAas5StnYp8da9+CKvMd2H2cbEjWcw5NPaPqzvYkVIaF1nNUG+b7u/sw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
-  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.13':
-    resolution: {integrity: sha512-ZfKWpXiUymDnavepCaM6KG/uGydJ4l2nBmMxg60Ci4CbeefpqjPWpfaZM7PThOhk2dssqBAcwLc6rAyr0uTdXg==}
+  '@rolldown/binding-linux-arm64-gnu@1.0.3':
+    resolution: {integrity: sha512-jsO7R8To+AdlYgUmN5sHSCZbfhtMBkO0WUx8iORQnPcMMdgr7qM2DQmMwgabs3GhNztdmoKkMKQFHD6DTMCIQw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
 
-  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.13':
-    resolution: {integrity: sha512-bmRg3O6Z0gq9yodKKWCIpnlH051sEfdVwt+6m5UDffAQMUUqU0xjnQqqAUm+Gu7ofAAly9DqiQDtKu2nPDEABA==}
+  '@rolldown/binding-linux-arm64-musl@1.0.3':
+    resolution: {integrity: sha512-VWkUHwWriDciit80wleYwKILoR/KMvxh/IdwS/paX+ZgpuRpCrKLUdadJbc0NpBEiyhpYawsJ73j9aCvOH+f7Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
 
-  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.13':
-    resolution: {integrity: sha512-8Wtnbw4k7pMYN9B/mOEAsQ8HOiq7AZ31Ig4M9BKn2So4xRaFEhtCSa4ZJaOutOWq50zpgR4N5+L/opnlaCx8wQ==}
+  '@rolldown/binding-linux-ppc64-gnu@1.0.3':
+    resolution: {integrity: sha512-5f1laC0SlIR0yDbFCd8acUhvJIag6N3zC5P7oUPN6wX0aOma+uKJ0wBDH5aq7I1PVI2ttTlhJwzwRIBnLiSGEg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ppc64]
     os: [linux]
 
-  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.13':
-    resolution: {integrity: sha512-D/0Nlo8mQuxSMohNJUF2lDXWRsFDsHldfRRgD9bRgktj+EndGPj4DOV37LqDKPYS+osdyhZEH7fTakTAEcW7qg==}
+  '@rolldown/binding-linux-s390x-gnu@1.0.3':
+    resolution: {integrity: sha512-Iq4ko0r4XsgbrF/LunNgHtAGLRRVE2kXonAXQ/MV0mC6jQpMOhW1SvtZja2EhC/kd05++bP78dsqBeIQyYJ6Yg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [s390x]
     os: [linux]
 
-  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.13':
-    resolution: {integrity: sha512-eRrPvat2YaVQcwwKi/JzOP6MKf1WRnOCr+VaI3cTWz3ZoLcP/654z90lVCJ4dAuMEpPdke0n+qyAqXDZdIC4rA==}
+  '@rolldown/binding-linux-x64-gnu@1.0.3':
+    resolution: {integrity: sha512-B8m6tD5+/N5FeNQFbKlLA/2yVq9ycQP1SeedyEYYKWBNR3ZQbkvIUcNnDNM03lO1l5F2roiiFJGgvoLLyZXtSg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
 
-  '@rolldown/binding-linux-x64-musl@1.0.0-rc.13':
-    resolution: {integrity: sha512-PsdONiFRp8hR8KgVjTWjZ9s7uA3uueWL0t74/cKHfM4dR5zXYv4AjB8BvA+QDToqxAFg4ZkcVEqeu5F7inoz5w==}
+  '@rolldown/binding-linux-x64-musl@1.0.3':
+    resolution: {integrity: sha512-pSdpdUJHkuCxun9LE7jvgUB9qsRgaiyNNCX7m/AvHTcq67AiT/Yhoxvw5zPfhrM8k/BfP8ce/hMOpthKDpEUow==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
 
-  '@rolldown/binding-openharmony-arm64@1.0.0-rc.13':
-    resolution: {integrity: sha512-hCNXgC5dI3TVOLrPT++PKFNZ+1EtS0mLQwfXXXSUD/+rGlB65gZDwN/IDuxLpQP4x8RYYHqGomlUXzpO8aVI2w==}
+  '@rolldown/binding-openharmony-arm64@1.0.3':
+    resolution: {integrity: sha512-OXXS3RKJgX2uLwM+gYyuH5omcH8fL1LJs96pZGgtetVCahON57+d4SJHzTgZiOjxgGkSnpXpOsWuPDGAKAigEg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [openharmony]
 
-  '@rolldown/binding-wasm32-wasi@1.0.0-rc.13':
-    resolution: {integrity: sha512-viLS5C5et8NFtLWw9Sw3M/w4vvnVkbWkO7wSNh3C+7G1+uCkGpr6PcjNDSFcNtmXY/4trjPBqUfcOL+P3sWy/g==}
-    engines: {node: '>=14.0.0'}
+  '@rolldown/binding-wasm32-wasi@1.0.3':
+    resolution: {integrity: sha512-JTtb8BWFynicNSoPrehsCzBtOKjZ6jhMiPFEmOiuXg1Fl8dn2KHQob+GuPSGR0dryQa1PQJbzjF3dqO/whhjLg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [wasm32]
 
-  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.13':
-    resolution: {integrity: sha512-Fqa3Tlt1xL4wzmAYxGNFV36Hb+VfPc9PYU+E25DAnswXv3ODDu/yyWjQDbXMo5AGWkQVjLgQExuVu8I/UaZhPQ==}
+  '@rolldown/binding-win32-arm64-msvc@1.0.3':
+    resolution: {integrity: sha512-gEdFFEN70A/jxb2svrWsN3aDL7OUtmvlOy+6fa2jxG8K0wQ1ZbdeLGnidov6Yu5/733dI5ySfzFlQ/cb0bSz1g==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [win32]
 
-  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.13':
-    resolution: {integrity: sha512-/pLI5kPkGEi44TDlnbio3St/5gUFeN51YWNAk/Gnv6mEQBOahRBh52qVFVBpmrnU01n2yysvBML9Ynu7K4kGAQ==}
+  '@rolldown/binding-win32-x64-msvc@1.0.3':
+    resolution: {integrity: sha512-eXB7CHuaQdqmJcc3koCNtNPmT/bj2gc999kUFgBxG8Ac0NdgXc4rkCHhqrgrhN3zddvvvrgzj1e90SuSfmyIXA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [win32]
 
-  '@rolldown/pluginutils@1.0.0-rc.13':
-    resolution: {integrity: sha512-3ngTAv6F/Py35BsYbeeLeecvhMKdsKm4AoOETVhAA+Qc8nrA2I0kF7oa93mE9qnIurngOSpMnQ0x2nQY2FPviA==}
+  '@rolldown/pluginutils@1.0.1':
+    resolution: {integrity: sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==}
 
-  '@rollup/pluginutils@5.3.0':
-    resolution: {integrity: sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==}
+  '@rollup/pluginutils@5.4.0':
+    resolution: {integrity: sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
       rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
@@ -1674,170 +1933,167 @@ packages:
       rollup:
         optional: true
 
-  '@rollup/rollup-android-arm-eabi@4.60.1':
-    resolution: {integrity: sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==}
+  '@rollup/rollup-android-arm-eabi@4.61.0':
+    resolution: {integrity: sha512-dnxczajOqt0gesZlN5pGQ1s1imQVrsmCw5G2Ci4oM+0WvNz3pyRnlWrT7McoZIb8VlFwCawdmbWRmxRn7HI+VQ==}
     cpu: [arm]
     os: [android]
 
-  '@rollup/rollup-android-arm64@4.60.1':
-    resolution: {integrity: sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==}
+  '@rollup/rollup-android-arm64@4.61.0':
+    resolution: {integrity: sha512-Bp3JpGP00Vu3f238ivRrjf7z3xSzVPXqCmaJYA9t2c+c8vKYvOzmXF7LkkeUalTEGd6cZcSWe+PFIP3Vy48fRg==}
     cpu: [arm64]
     os: [android]
 
-  '@rollup/rollup-darwin-arm64@4.60.1':
-    resolution: {integrity: sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==}
+  '@rollup/rollup-darwin-arm64@4.61.0':
+    resolution: {integrity: sha512-zaYIpr670mUmmZ1tVzUFplbQbG7h3Gugx3L5FoqhsC2m/YnLlR1a7zVLmXNPy+iY1tFPEbNG+HHBXZGyId0G5w==}
     cpu: [arm64]
     os: [darwin]
 
-  '@rollup/rollup-darwin-x64@4.60.1':
-    resolution: {integrity: sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==}
+  '@rollup/rollup-darwin-x64@4.61.0':
+    resolution: {integrity: sha512-+P49fvkv2dSoeevUW+lgZ/I2JHSsJCK1Lyjj7Cu6E4UHG4tS9XIefzIjo5qhgELjAclnen1rLzK2PMKJdo+Dyg==}
     cpu: [x64]
     os: [darwin]
 
-  '@rollup/rollup-freebsd-arm64@4.60.1':
-    resolution: {integrity: sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==}
+  '@rollup/rollup-freebsd-arm64@4.61.0':
+    resolution: {integrity: sha512-l3FAAOyKJXH2ea6KNFN+MMgC/rnE94YGLXs2ehYqDcCoHt1DpvgWX75BhUJxN38XojP7Ul+4H8PRn7EdyqSDrw==}
     cpu: [arm64]
     os: [freebsd]
 
-  '@rollup/rollup-freebsd-x64@4.60.1':
-    resolution: {integrity: sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==}
+  '@rollup/rollup-freebsd-x64@4.61.0':
+    resolution: {integrity: sha512-VokPN3TSctKj65cyCNPaUh4vMFA8awxOot/0sp+4J7ZlNRKQEhXhawqPwajoi8H5ZFt61i0ugZJuTKXBjGJ17Q==}
     cpu: [x64]
     os: [freebsd]
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.60.1':
-    resolution: {integrity: sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==}
+  '@rollup/rollup-linux-arm-gnueabihf@4.61.0':
+    resolution: {integrity: sha512-DxH0P3wxm+Yzs/p3zrk9dw1rURu8p0Nv5+MRK/L7OtnLNg5rLZraSBFZ8iUXOd9f2BlhJyEpIZUH/emjq4UJ4g==}
     cpu: [arm]
     os: [linux]
 
-  '@rollup/rollup-linux-arm-musleabihf@4.60.1':
-    resolution: {integrity: sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==}
+  '@rollup/rollup-linux-arm-musleabihf@4.61.0':
+    resolution: {integrity: sha512-T6ZvMNe84kAz6TBWHC7hGAoEtzP1LWYw/AqayGWEF6uISt3Abk/st06LqRD9THd7Xz3NxzurUpzAuEAUbZf+nw==}
     cpu: [arm]
     os: [linux]
 
-  '@rollup/rollup-linux-arm64-gnu@4.60.1':
-    resolution: {integrity: sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==}
+  '@rollup/rollup-linux-arm64-gnu@4.61.0':
+    resolution: {integrity: sha512-q/4hzvQkDs8b4jIBab1pnLiiM0ayTZsN2amBFPDzuyZxjEd4wDwx0UJFYM3cOZzSf5Kw8fnWSprJzIBMkcR44Q==}
     cpu: [arm64]
     os: [linux]
 
-  '@rollup/rollup-linux-arm64-musl@4.60.1':
-    resolution: {integrity: sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==}
+  '@rollup/rollup-linux-arm64-musl@4.61.0':
+    resolution: {integrity: sha512-vvYWX3akdEAY6km+9wAqFDnk6pQsbJKVnj7xawcvs/+fdlYBGp+U+Qq/lLfpIxYIZvZLHMAKD9HLdacSx/r3dw==}
     cpu: [arm64]
     os: [linux]
 
-  '@rollup/rollup-linux-loong64-gnu@4.60.1':
-    resolution: {integrity: sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==}
+  '@rollup/rollup-linux-loong64-gnu@4.61.0':
+    resolution: {integrity: sha512-DePa5cqOxDP/Zp0VOXpeWaGew5iIv5DXp9NYbzkX5PFQyWVX9184WCTh3hvr/7lhXo8ZVlbFLkz8+o/q1dU6gA==}
     cpu: [loong64]
     os: [linux]
 
-  '@rollup/rollup-linux-loong64-musl@4.60.1':
-    resolution: {integrity: sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==}
+  '@rollup/rollup-linux-loong64-musl@4.61.0':
+    resolution: {integrity: sha512-LV8aWMB8UChglMCEzs7RkN0GsH29RJaLLqwm9fCIjlqwxQTiWAqNcc7wjBkH31hV0PU/yVxGYvrYsgfea2qw6g==}
     cpu: [loong64]
     os: [linux]
 
-  '@rollup/rollup-linux-ppc64-gnu@4.60.1':
-    resolution: {integrity: sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==}
+  '@rollup/rollup-linux-ppc64-gnu@4.61.0':
+    resolution: {integrity: sha512-QoNSnwQtaeNu5grdBbsL0tt1uyl5EnS8DA8Mr3nluMXbhdQNyhN+G4tBax7VCdxLKj8YJ0/4OO9Ho84jMnJtKA==}
     cpu: [ppc64]
     os: [linux]
 
-  '@rollup/rollup-linux-ppc64-musl@4.60.1':
-    resolution: {integrity: sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==}
+  '@rollup/rollup-linux-ppc64-musl@4.61.0':
+    resolution: {integrity: sha512-/zZp5MKapIIApE8trN8qLGNSiRN9TUoaUZ1cmVu4XnVdd5LQLOXTtyi+vtfUbNnT3iyjzpPqYeKXmvJ+gJGYWw==}
     cpu: [ppc64]
     os: [linux]
 
-  '@rollup/rollup-linux-riscv64-gnu@4.60.1':
-    resolution: {integrity: sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==}
+  '@rollup/rollup-linux-riscv64-gnu@4.61.0':
+    resolution: {integrity: sha512-RbrzcD3aJ1k3UbtMRRBNwojdVVyXjuVAFTfn/xPa6EEl6GE9Sm/akPgFTb9aAC9pMKGJ6CtWxaGrqWcabH+ySg==}
     cpu: [riscv64]
     os: [linux]
 
-  '@rollup/rollup-linux-riscv64-musl@4.60.1':
-    resolution: {integrity: sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==}
+  '@rollup/rollup-linux-riscv64-musl@4.61.0':
+    resolution: {integrity: sha512-ZF+onDsBso8PJf1XaG9lB+O9RnBpKGnY6OrzC4CSHrtC1jb6jWLTKK4bRqdoCXHd22gyr2hiYmEAm8Wns/BOCw==}
     cpu: [riscv64]
     os: [linux]
 
-  '@rollup/rollup-linux-s390x-gnu@4.60.1':
-    resolution: {integrity: sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==}
+  '@rollup/rollup-linux-s390x-gnu@4.61.0':
+    resolution: {integrity: sha512-Atk0aSIk5Zx2Wuh9dgRQgLP0Koc8hOeYpbWryMXyk8G8/HmPkwPPkMqIIDhrXHHYqfUzSJA/I7IWSBv8xSmRBA==}
     cpu: [s390x]
     os: [linux]
 
-  '@rollup/rollup-linux-x64-gnu@4.60.1':
-    resolution: {integrity: sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==}
+  '@rollup/rollup-linux-x64-gnu@4.61.0':
+    resolution: {integrity: sha512-0uMOcf3eZ5K+K4cYHkdxShFMPlPXCOdfDFEFn9dNYAEEd2cVvmOfH7zFgRVoDgmtQ1m9k5q7qfrHzyMAubKYUA==}
     cpu: [x64]
     os: [linux]
 
-  '@rollup/rollup-linux-x64-musl@4.60.1':
-    resolution: {integrity: sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==}
+  '@rollup/rollup-linux-x64-musl@4.61.0':
+    resolution: {integrity: sha512-mvFtE4A/t/7hRJ7X8Ozmu8FsIkAUat2nzl12pgU337BRmq87AQUJztwHz2Zv5/tjo9/C95E66CK03SI/ToEDJw==}
     cpu: [x64]
     os: [linux]
 
-  '@rollup/rollup-openbsd-x64@4.60.1':
-    resolution: {integrity: sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==}
+  '@rollup/rollup-openbsd-x64@4.61.0':
+    resolution: {integrity: sha512-z9b9+aTxvt8n2rNltMPvyaUfB8NJ+CVyOrGK/MdIKHx7B+lXmZpm/XbRsU7Rpf3fRqJ2uS6mBJiJveCtq8LHDg==}
     cpu: [x64]
     os: [openbsd]
 
-  '@rollup/rollup-openharmony-arm64@4.60.1':
-    resolution: {integrity: sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==}
+  '@rollup/rollup-openharmony-arm64@4.61.0':
+    resolution: {integrity: sha512-jXaXFqKMehsOc+g8R6oo33RRC6w07G9jDBxAE5eAKX7mOcCbZloYIPNhfG9Wl+P9O9IWHFO4OJgPi1Ml2qkt7w==}
     cpu: [arm64]
     os: [openharmony]
 
-  '@rollup/rollup-win32-arm64-msvc@4.60.1':
-    resolution: {integrity: sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==}
+  '@rollup/rollup-win32-arm64-msvc@4.61.0':
+    resolution: {integrity: sha512-OXNWVFocS2IA4+QplhTZZ2a+8hPZR7T8KuozsNmJKK8y7cp83StHvGksfHzPG3wczWTczyWHVQuqeiTUbjiyBg==}
     cpu: [arm64]
     os: [win32]
 
-  '@rollup/rollup-win32-ia32-msvc@4.60.1':
-    resolution: {integrity: sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==}
+  '@rollup/rollup-win32-ia32-msvc@4.61.0':
+    resolution: {integrity: sha512-AlAbNtBO637LxSldqV43z0FfXoGfl2TW1DgAg/bs7aQswFbDewz2SJm3BUhiGfbOVtW571xbc9p+REdxhyN/Eg==}
     cpu: [ia32]
     os: [win32]
 
-  '@rollup/rollup-win32-x64-gnu@4.60.1':
-    resolution: {integrity: sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==}
+  '@rollup/rollup-win32-x64-gnu@4.61.0':
+    resolution: {integrity: sha512-QRSrQXyJ1M4tjNXdR0/G/IgV6lzfQQJYBjlWIEYkY2Xs86DRl/iEpQ4blMDjJxSl7n19eDKKXMg0AmuBVYy8pQ==}
     cpu: [x64]
     os: [win32]
 
-  '@rollup/rollup-win32-x64-msvc@4.60.1':
-    resolution: {integrity: sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==}
+  '@rollup/rollup-win32-x64-msvc@4.61.0':
+    resolution: {integrity: sha512-tkuFxhvKO/HlGd0VsINF6vHSYH8AF8W0TcNxKDK6JZmrehngFj78pToc8iemtnvwilDjs2G/qSzYFhe9U8q+fw==}
     cpu: [x64]
     os: [win32]
 
   '@rtsao/scc@1.1.0':
     resolution: {integrity: sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==}
 
-  '@rushstack/node-core-library@5.18.0':
-    resolution: {integrity: sha512-XDebtBdw5S3SuZIt+Ra2NieT8kQ3D2Ow1HxhDQ/2soinswnOu9e7S69VSwTOLlQnx5mpWbONu+5JJjDxMAb6Fw==}
+  '@rushstack/node-core-library@5.23.1':
+    resolution: {integrity: sha512-wlKmIKIYCKuCASbITvOxLZXepPbwXvrv7S6ig6XNWFchSyhL/E2txmVXspHY49Wu2dzf7nI27a2k/yV5BA3EiA==}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
 
-  '@rushstack/problem-matcher@0.1.1':
-    resolution: {integrity: sha512-Fm5XtS7+G8HLcJHCWpES5VmeMyjAKaWeyZU5qPzZC+22mPlJzAsOxymHiWIfuirtPckX3aptWws+K2d0BzniJA==}
+  '@rushstack/problem-matcher@0.2.1':
+    resolution: {integrity: sha512-gulfhBs6n+I5b7DvjKRfhMGyUejtSgOHTclF/eONr8hcgF1APEDjhxIsfdUYYMzC3rvLwGluqLjbwCFZ8nxrog==}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
 
-  '@rushstack/rig-package@0.6.0':
-    resolution: {integrity: sha512-ZQmfzsLE2+Y91GF15c65L/slMRVhF6Hycq04D4TwtdGaUAbIXXg9c5pKA5KFU7M4QMaihoobp9JJYpYcaY3zOw==}
+  '@rushstack/rig-package@0.7.3':
+    resolution: {integrity: sha512-aAA518n6wxxjCfnTAOjQnm7ngNE0FVHxHAw2pxKlIhxrMn0XQjGcXKF0oKWpjBgJOmsaJpVob/v+zr3zxgPWuA==}
 
-  '@rushstack/terminal@0.19.3':
-    resolution: {integrity: sha512-0P8G18gK9STyO+CNBvkKPnWGMxESxecTYqOcikHOVIHXa9uAuTK+Fw8TJq2Gng1w7W6wTC9uPX6hGNvrMll2wA==}
+  '@rushstack/terminal@0.24.0':
+    resolution: {integrity: sha512-8ZQS4MMaGsv27EXCBiH7WMPkRZrffeDoIevs6z9TM5dzqiY6+Hn4evfK/G+gvgBTjfvfkHIZPQQmalmI2sM4TQ==}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
 
-  '@rushstack/ts-command-line@5.1.3':
-    resolution: {integrity: sha512-Kdv0k/BnnxIYFlMVC1IxrIS0oGQd4T4b7vKfx52Y2+wk2WZSDFIvedr7JrhenzSlm3ou5KwtoTGTGd5nbODRug==}
+  '@rushstack/ts-command-line@5.3.9':
+    resolution: {integrity: sha512-GIHqU+sRGQ3LGWAZu1O+9Yh++qwtyNIIGuNbcWHJjBTm2qRez0cwINUHZ+pQLR8UuzZDcMajrDaNbUYoaL/XtQ==}
 
   '@sec-ant/readable-stream@0.4.1':
     resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==}
 
-  '@sinclair/typebox@0.27.10':
-    resolution: {integrity: sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA==}
-
   '@sinclair/typebox@0.34.49':
     resolution: {integrity: sha512-brySQQs7Jtn0joV8Xh9ZV/hZb9Ozb0pmazDIASBkYKCjXrXU3mpcFahmK/z4YDhGkQvP9mWJbVyahdtU5wQA+A==}
 
@@ -1848,71 +2104,71 @@ packages:
   '@sinonjs/commons@3.0.1':
     resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==}
 
-  '@sinonjs/fake-timers@10.3.0':
-    resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==}
+  '@sinonjs/fake-timers@15.4.0':
+    resolution: {integrity: sha512-DsG+8/LscQIQg68J6Ef3dv10u6nVyetYn923s3/sus5eaGfTo1of5WMZSLf0UJc9KDuKPilPH0UDJCjvNbDNCA==}
 
   '@standard-schema/spec@1.1.0':
     resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
 
-  '@tailwindcss/node@4.2.2':
-    resolution: {integrity: sha512-pXS+wJ2gZpVXqFaUEjojq7jzMpTGf8rU6ipJz5ovJV6PUGmlJ+jvIwGrzdHdQ80Sg+wmQxUFuoW1UAAwHNEdFA==}
+  '@tailwindcss/node@4.3.0':
+    resolution: {integrity: sha512-aFb4gUhFOgdh9AXo4IzBEOzBkkAxm9VigwDJnMIYv3lcfXCJVesNfbEaBl4BNgVRyid92AmdviqwBUBRKSeY3g==}
 
-  '@tailwindcss/oxide-android-arm64@4.2.2':
-    resolution: {integrity: sha512-dXGR1n+P3B6748jZO/SvHZq7qBOqqzQ+yFrXpoOWWALWndF9MoSKAT3Q0fYgAzYzGhxNYOoysRvYlpixRBBoDg==}
+  '@tailwindcss/oxide-android-arm64@4.3.0':
+    resolution: {integrity: sha512-TJPiq67tKlLuObP6RkwvVGDoxCMBVtDgKkLfa/uyj7/FyxvQwHS+UOnVrXXgbEsfUaMgiVvC4KbJnRr26ho4Ng==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [android]
 
-  '@tailwindcss/oxide-darwin-arm64@4.2.2':
-    resolution: {integrity: sha512-iq9Qjr6knfMpZHj55/37ouZeykwbDqF21gPFtfnhCCKGDcPI/21FKC9XdMO/XyBM7qKORx6UIhGgg6jLl7BZlg==}
+  '@tailwindcss/oxide-darwin-arm64@4.3.0':
+    resolution: {integrity: sha512-oMN/WZRb+SO37BmUElEgeEWuU8E/HXRkiODxJxLe1UTHVXLrdVSgfaJV7pSlhRGMSOiXLuxTIjfsF3wYvz8cgQ==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [darwin]
 
-  '@tailwindcss/oxide-darwin-x64@4.2.2':
-    resolution: {integrity: sha512-BlR+2c3nzc8f2G639LpL89YY4bdcIdUmiOOkv2GQv4/4M0vJlpXEa0JXNHhCHU7VWOKWT/CjqHdTP8aUuDJkuw==}
+  '@tailwindcss/oxide-darwin-x64@4.3.0':
+    resolution: {integrity: sha512-N6CUmu4a6bKVADfw77p+iw6Yd9Q3OBhe0veaDX+QazfuVYlQsHfDgxBrsjQ/IW+zywL8mTrNd0SdJT/zgtvMdA==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [darwin]
 
-  '@tailwindcss/oxide-freebsd-x64@4.2.2':
-    resolution: {integrity: sha512-YUqUgrGMSu2CDO82hzlQ5qSb5xmx3RUrke/QgnoEx7KvmRJHQuZHZmZTLSuuHwFf0DJPybFMXMYf+WJdxHy/nQ==}
+  '@tailwindcss/oxide-freebsd-x64@4.3.0':
+    resolution: {integrity: sha512-zDL5hBkQdH5C6MpqbK3gQAgP80tsMwSI26vjOzjJtNCMUo0lFgOItzHKBIupOZNQxt3ouPH7RPhvNhiTfCe5CQ==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [freebsd]
 
-  '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.2':
-    resolution: {integrity: sha512-FPdhvsW6g06T9BWT0qTwiVZYE2WIFo2dY5aCSpjG/S/u1tby+wXoslXS0kl3/KXnULlLr1E3NPRRw0g7t2kgaQ==}
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0':
+    resolution: {integrity: sha512-R06HdNi7A7OEoMsf6d4tjZ71RCWnZQPHj2mnotSFURjNLdBC+cIgXQ7l81CqeoiQftjf6OOblxXMInMgN2VzMA==}
     engines: {node: '>= 20'}
     cpu: [arm]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-arm64-gnu@4.2.2':
-    resolution: {integrity: sha512-4og1V+ftEPXGttOO7eCmW7VICmzzJWgMx+QXAJRAhjrSjumCwWqMfkDrNu1LXEQzNAwz28NCUpucgQPrR4S2yw==}
+  '@tailwindcss/oxide-linux-arm64-gnu@4.3.0':
+    resolution: {integrity: sha512-qTJHELX8jetjhRQHCLilkVLmybpzNQAtaI/gaoVoidn/ufbNDbAo8KlK2J+yPoc8wQxvDxCmh/5lr8nC1+lTbg==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-arm64-musl@4.2.2':
-    resolution: {integrity: sha512-oCfG/mS+/+XRlwNjnsNLVwnMWYH7tn/kYPsNPh+JSOMlnt93mYNCKHYzylRhI51X+TbR+ufNhhKKzm6QkqX8ag==}
+  '@tailwindcss/oxide-linux-arm64-musl@4.3.0':
+    resolution: {integrity: sha512-Z6sukiQsngnWO+l39X4pPbiWT81IC+PLKF+PHxIlyZbGNb9MODfYlXEVlFvej5BOZInWX01kVyzeLvHsXhfczQ==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-x64-gnu@4.2.2':
-    resolution: {integrity: sha512-rTAGAkDgqbXHNp/xW0iugLVmX62wOp2PoE39BTCGKjv3Iocf6AFbRP/wZT/kuCxC9QBh9Pu8XPkv/zCZB2mcMg==}
+  '@tailwindcss/oxide-linux-x64-gnu@4.3.0':
+    resolution: {integrity: sha512-DRNdQRpSGzRGfARVuVkxvM8Q12nh19l4BF/G7zGA1oe+9wcC6saFBHTISrpIcKzhiXtSrlSrluCfvMuledoCTQ==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [linux]
 
-  '@tailwindcss/oxide-linux-x64-musl@4.2.2':
-    resolution: {integrity: sha512-XW3t3qwbIwiSyRCggeO2zxe3KWaEbM0/kW9e8+0XpBgyKU4ATYzcVSMKteZJ1iukJ3HgHBjbg9P5YPRCVUxlnQ==}
+  '@tailwindcss/oxide-linux-x64-musl@4.3.0':
+    resolution: {integrity: sha512-Z0IADbDo8bh6I7h2IQMx601AdXBLfFpEdUotft86evd/8ZPflZe9COPO8Q1vw+pfLWIUo9zN/JGZvwuAJqduqg==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [linux]
 
-  '@tailwindcss/oxide-wasm32-wasi@4.2.2':
-    resolution: {integrity: sha512-eKSztKsmEsn1O5lJ4ZAfyn41NfG7vzCg496YiGtMDV86jz1q/irhms5O0VrY6ZwTUkFy/EKG3RfWgxSI3VbZ8Q==}
+  '@tailwindcss/oxide-wasm32-wasi@4.3.0':
+    resolution: {integrity: sha512-HNZGOUxEmElksYR7S6sC5jTeNGpobAsy9u7Gu0AskJ8/20FR9GqebUyB+HBcU/ax6BHuiuJi+Oda4B+YX6H1yA==}
     engines: {node: '>=14.0.0'}
     cpu: [wasm32]
     bundledDependencies:
@@ -1923,24 +2179,24 @@ packages:
       - '@emnapi/wasi-threads'
       - tslib
 
-  '@tailwindcss/oxide-win32-arm64-msvc@4.2.2':
-    resolution: {integrity: sha512-qPmaQM4iKu5mxpsrWZMOZRgZv1tOZpUm+zdhhQP0VhJfyGGO3aUKdbh3gDZc/dPLQwW4eSqWGrrcWNBZWUWaXQ==}
+  '@tailwindcss/oxide-win32-arm64-msvc@4.3.0':
+    resolution: {integrity: sha512-Pe+RPVTi1T+qymuuRpcdvwSVZjnll/f7n8gBxMMh3xLTctMDKqpdfGimbMyioqtLhUYZxdJ9wGNhV7MKHvgZsQ==}
     engines: {node: '>= 20'}
     cpu: [arm64]
     os: [win32]
 
-  '@tailwindcss/oxide-win32-x64-msvc@4.2.2':
-    resolution: {integrity: sha512-1T/37VvI7WyH66b+vqHj/cLwnCxt7Qt3WFu5Q8hk65aOvlwAhs7rAp1VkulBJw/N4tMirXjVnylTR72uI0HGcA==}
+  '@tailwindcss/oxide-win32-x64-msvc@4.3.0':
+    resolution: {integrity: sha512-Mvrf2kXW/yeW/OTezZlCGOirXRcUuLIBx/5Y12BaPM7wJoryG6dfS/NJL8aBPqtTEx/Vm4T4vKzFUcKDT+TKUA==}
     engines: {node: '>= 20'}
     cpu: [x64]
     os: [win32]
 
-  '@tailwindcss/oxide@4.2.2':
-    resolution: {integrity: sha512-qEUA07+E5kehxYp9BVMpq9E8vnJuBHfJEC0vPC5e7iL/hw7HR61aDKoVoKzrG+QKp56vhNZe4qwkRmMC0zDLvg==}
+  '@tailwindcss/oxide@4.3.0':
+    resolution: {integrity: sha512-F7HZGBeN9I0/AuuJS5PwcD8xayx5ri5GhjYUDBEVYUkexyA/giwbDNjRVrxSezE3T250OU2K/wp/ltWx3UOefg==}
     engines: {node: '>= 20'}
 
-  '@tailwindcss/postcss@4.2.2':
-    resolution: {integrity: sha512-n4goKQbW8RVXIbNKRB/45LzyUqN451deQK0nzIeauVEqjlI49slUlgKYJM2QyUzap/PcpnS7kzSUmPb1sCRvYQ==}
+  '@tailwindcss/postcss@4.3.0':
+    resolution: {integrity: sha512-Jm05Tjx+9yCLGv5qw1c+84Psds8MnyrEQYCB+FFk2lgGiUjlRqdxke4mVTuYrj2xnVZqKim2Apr5ySuQRYAw/w==}
 
   '@teppeis/multimaps@3.0.0':
     resolution: {integrity: sha512-ID7fosbc50TbT0MK0EG12O+gAP3W3Aa/Pz4DaTtQtEvlc9Odaqi0de+xuZ7Li2GtK4HzEX7IuRWS/JmZLksR3Q==}
@@ -1952,8 +2208,8 @@ packages:
   '@tootallnate/quickjs-emscripten@0.23.0':
     resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
 
-  '@tsconfig/node10@1.0.11':
-    resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==}
+  '@tsconfig/node10@1.0.12':
+    resolution: {integrity: sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ==}
 
   '@tsconfig/node12@1.0.11':
     resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==}
@@ -1964,8 +2220,8 @@ packages:
   '@tsconfig/node16@1.0.4':
     resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
 
-  '@tybys/wasm-util@0.10.1':
-    resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
+  '@tybys/wasm-util@0.10.2':
+    resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
 
   '@types/argparse@1.0.38':
     resolution: {integrity: sha512-ebDJ9b0e702Yr7pWgB0jzm+CX4Srzz8RcXtLJDJB+BSccqMa36uyH/zUsSYao5+BD1ytv3k3rPYCq4mAE1hsXA==}
@@ -1994,15 +2250,12 @@ packages:
   '@types/esrecurse@4.3.1':
     resolution: {integrity: sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==}
 
-  '@types/estree@1.0.8':
-    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+  '@types/estree@1.0.9':
+    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
 
   '@types/fluent-ffmpeg@2.1.28':
     resolution: {integrity: sha512-5ovxsDwBcPfJ+eYs1I/ZpcYCnkce7pvH9AHSvrZllAp1ZPpTRDZAFjF3TRFbukxSgIYTTNYePbS0rKUmaxVbXw==}
 
-  '@types/graceful-fs@4.1.9':
-    resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==}
-
   '@types/istanbul-lib-coverage@2.0.6':
     resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==}
 
@@ -2018,14 +2271,14 @@ packages:
   '@types/json5@0.0.29':
     resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==}
 
-  '@types/node@25.5.2':
-    resolution: {integrity: sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg==}
+  '@types/node@25.9.1':
+    resolution: {integrity: sha512-xfrlY7UD5rMJk3ZVJP8BNzS28J36YJg+xp+LPXV1TdWxr8uMH5A860QNxYDGQe/ylDSgjxE52Q9VnO7p75tJxg==}
 
   '@types/normalize-package-data@2.4.4':
     resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==}
 
-  '@types/selenium-webdriver@4.35.5':
-    resolution: {integrity: sha512-wCQCjWmahRkUAO7S703UAvBFkxz4o/rjX4T2AOSWKXSi0sTQPsrXxR0GjtFUT0ompedLkYH4R5HO5Urz0hyeog==}
+  '@types/selenium-webdriver@4.35.6':
+    resolution: {integrity: sha512-8nfyMRi4VvkY9QrQGyY/zkleAhnjnmE8YtdEeoCrWe3izp1P9vo9f5VTNRYF0up+l+kn+VuZah+je+bLddNV+g==}
 
   '@types/shell-quote@1.7.5':
     resolution: {integrity: sha512-+UE8GAGRPbJVQDdxi16dgadcBfQ+KG2vgZhV1+3A1XmHbmwcdwhCUwIdy+d3pAGrbvgRoVSjeI9vOWyq376Yzw==}
@@ -2066,89 +2319,197 @@ packages:
   '@types/yauzl@2.10.3':
     resolution: {integrity: sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==}
 
-  '@typescript-eslint/eslint-plugin@8.58.1':
-    resolution: {integrity: sha512-eSkwoemjo76bdXl2MYqtxg51HNwUSkWfODUOQ3PaTLZGh9uIWWFZIjyjaJnex7wXDu+TRx+ATsnSxdN9YWfRTQ==}
+  '@typescript-eslint/eslint-plugin@8.60.1':
+    resolution: {integrity: sha512-JQ4S5GB0tfjO8BuJ4fcX+HodkzJjYBV+7OJ+wLygaX7OGQ7FudyHL4NSCA6ob+w3Yn+5MkKIozOwQhXeM7opVg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^8.58.1
+      '@typescript-eslint/parser': ^8.60.1
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/parser@8.58.1':
-    resolution: {integrity: sha512-gGkiNMPqerb2cJSVcruigx9eHBlLG14fSdPdqMoOcBfh+vvn4iCq2C8MzUB89PrxOXk0y3GZ1yIWb9aOzL93bw==}
+  '@typescript-eslint/parser@8.60.1':
+    resolution: {integrity: sha512-A0M6ua6H252bVjPvvtSgl2QA4+ET9S5Mtkb2GDyTxIhH/C4qDItT7RQNO5PhMC6NXGYXOR9dIalcDDgBKT7oFA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/project-service@8.58.1':
-    resolution: {integrity: sha512-gfQ8fk6cxhtptek+/8ZIqw8YrRW5048Gug8Ts5IYcMLCw18iUgrZAEY/D7s4hkI0FxEfGakKuPK/XUMPzPxi5g==}
+  '@typescript-eslint/project-service@8.60.1':
+    resolution: {integrity: sha512-eXkTH2bxmXlqD1RnOPmLZ9ZM9D3VwSx04JOwBnP9RQ+yUA5a2Mu7SfW8uaV2Aon53NJzZlZYuX7tn91Izf+xaw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/scope-manager@8.58.1':
-    resolution: {integrity: sha512-TPYUEqJK6avLcEjumWsIuTpuYODTTDAtoMdt8ZZa93uWMTX13Nb8L5leSje1NluammvU+oI3QRr5lLXPgihX3w==}
+  '@typescript-eslint/scope-manager@8.60.1':
+    resolution: {integrity: sha512-gvI5OQoptnxQnchOirukCuQ55svJSTuD/4k5+pC267xyBtYry748R9/c3tYUzb/iE6RZfllRz2lVulLCHkTm4w==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/tsconfig-utils@8.58.1':
-    resolution: {integrity: sha512-JAr2hOIct2Q+qk3G+8YFfqkqi7sC86uNryT+2i5HzMa2MPjw4qNFvtjnw1IiA1rP7QhNKVe21mSSLaSjwA1Olw==}
+  '@typescript-eslint/tsconfig-utils@8.60.1':
+    resolution: {integrity: sha512-nh8w4qAteiKuZu3pSSzG/yGKpw0OlkrKnzFmbVRenKaD4qc+7i1GrmZaLVkr8rk4uipiPGMOW4YsM6WmKZ5CvA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/type-utils@8.58.1':
-    resolution: {integrity: sha512-HUFxvTJVroT+0rXVJC7eD5zol6ID+Sn5npVPWoFuHGg9Ncq5Q4EYstqR+UOqaNRFXi5TYkpXXkLhoCHe3G0+7w==}
+  '@typescript-eslint/type-utils@8.60.1':
+    resolution: {integrity: sha512-sdwTrpjosW7ANQYJ39ZBF1ZyEMEGVB2UsikrserVM/30a/F1dTLnu9bGxEdosugyu5caigjLrR2qiD11asjI1A==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/types@8.58.1':
-    resolution: {integrity: sha512-io/dV5Aw5ezwzfPBBWLoT+5QfVtP8O7q4Kftjn5azJ88bYyp/ZMCsyW1lpKK46EXJcaYMZ1JtYj+s/7TdzmQMw==}
+  '@typescript-eslint/types@8.60.1':
+    resolution: {integrity: sha512-4h0tY8ppCkdCzcrl2YM5M3my0xsE1Tf8om3owEu5oPWmXwkKRmk0j0LGDzYBGUcAlesEbxBhazqu/K4cu3Ug7w==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/typescript-estree@8.58.1':
-    resolution: {integrity: sha512-w4w7WR7GHOjqqPnvAYbazq+Y5oS68b9CzasGtnd6jIeOIeKUzYzupGTB2T4LTPSv4d+WPeccbxuneTFHYgAAWg==}
+  '@typescript-eslint/typescript-estree@8.60.1':
+    resolution: {integrity: sha512-alpRkfG8hlVE5kdJW2GkfgDgXxold3e8e4l6EnmhRmRLbekgAPCCGDVD++sABy9FcgPFroq+uFcCSM1vR57Cew==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/utils@8.58.1':
-    resolution: {integrity: sha512-Ln8R0tmWC7pTtLOzgJzYTXSCjJ9rDNHAqTaVONF4FEi2qwce8mD9iSOxOpLFFvWp/wBFlew0mjM1L1ihYWfBdQ==}
+  '@typescript-eslint/utils@8.60.1':
+    resolution: {integrity: sha512-h2MPBLoNtjc3qZWfY3Tl51yPorQ2McHn8pJfcMNTcIvrrZrr90Ykffit0yjrPFWQcRcUxzH20+6OcVdW4yHtUg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/visitor-keys@8.58.1':
-    resolution: {integrity: sha512-y+vH7QE8ycjoa0bWciFg7OpFcipUuem1ujhrdLtq1gByKwfbC7bPeKsiny9e0urg93DqwGcHey+bGRKCnF1nZQ==}
+  '@typescript-eslint/visitor-keys@8.60.1':
+    resolution: {integrity: sha512-EbGRQg4FhrmwLodl+t3JNAnXHWVr9Vp+Zl1QBZVPY4ByfkzIT8cX3K6QWODHtkIZqqJVEWvhHSx3v5PDHsaQag==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@vitest/browser@4.1.3':
-    resolution: {integrity: sha512-CS9KjO2vijuBlbwz0JIgC0YuoI1BuqWI5ziD3Nll6jkpNYtWdjPMVgGynQ9vZovjsECeUqEeNjWrypP414d0CQ==}
-    peerDependencies:
-      vitest: 4.1.3
+  '@ungap/structured-clone@1.3.1':
+    resolution: {integrity: sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==}
+
+  '@unrs/resolver-binding-android-arm-eabi@1.12.2':
+    resolution: {integrity: sha512-g5T90pqg1bo/7mytQx6F4iBNC0Wsh9cu+z9veDbFjc7HjpesJFWD7QMS0NGStXM075+7dJPPVvBbpZlnrdpi/w==}
+    cpu: [arm]
+    os: [android]
+
+  '@unrs/resolver-binding-android-arm64@1.12.2':
+    resolution: {integrity: sha512-YGCRZv/9GLhwmz6mYDeTsm/92BAyR28l6c2ReweVW5pWgfsitWLY8upvfRlGdoyD8HjeTHSYJWyZGD4KJA/nFQ==}
+    cpu: [arm64]
+    os: [android]
+
+  '@unrs/resolver-binding-darwin-arm64@1.12.2':
+    resolution: {integrity: sha512-u9DiNT1auQMO20A9SyTuG3wUgQWB9Z7KjAg0uFuCDR1FsAY8A0CG2S6JpHS1xwm/w1G08bjXZDcyOCjv1WAm2w==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@unrs/resolver-binding-darwin-x64@1.12.2':
+    resolution: {integrity: sha512-f7rPLi/T1HVKZu/u6t87lroib16n8vrSzcyxI7lg4BGO9UF26KhQL44sd9eOUgrTYhvRXtWOIZT5PejdPyJfUA==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@unrs/resolver-binding-freebsd-x64@1.12.2':
+    resolution: {integrity: sha512-BpcOjWCJub6nRZUS2zA20pmLvjtqAtGejETaIyRLiZiQf++cbrjltLA5NN/xaXfqeOBOSlMFbemIl5/S5tljmg==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@unrs/resolver-binding-linux-arm-gnueabihf@1.12.2':
+    resolution: {integrity: sha512-vZTDvdSISZjJx66OzJqtsOhzifbqRjbmI1Mnu49fQDwog5GtDI4QidRiEAYbZCRj9C8YZEW+3ZjqsyS9GR4k2A==}
+    cpu: [arm]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-arm-musleabihf@1.12.2':
+    resolution: {integrity: sha512-BiPI+IrIlwcW4nLLMM21+B1dFPzd55yAVgVGrdgDjNef+ch03GdxrcyaIz8X9SsQirh/kCQ7mviyWlMxdh2D7g==}
+    cpu: [arm]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-arm64-gnu@1.12.2':
+    resolution: {integrity: sha512-zJc0H99FEPoFfSrNpa91HYfxzfAJCr502oxNK1cfdC9hlaFI43RT+JFCann9JUgZmLzzntChHyn13Sgn9ljHNg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-arm64-musl@1.12.2':
+    resolution: {integrity: sha512-KQ3Lki6l+Pz1k/eBipN41ES+YUK30beLGb9YqcB1O542cyLCNE6GaxrfcY3T6EezmGGk84wb5XyO9loTM9tkcA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-loong64-gnu@1.12.2':
+    resolution: {integrity: sha512-3SJGEh1DborhG6pyxvhPzCT4bbSIVihsvgJc13P1bHG7KLdNDaF9T3gsTwFc7Jw/5Y5/iWOjkEx7Zy0NvCGX3Q==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-loong64-musl@1.12.2':
+    resolution: {integrity: sha512-jiuG/Obbel7uw1PwHNFfrkiKhLAF6mnyZ6aWlOAVN9WqKm8v0OFGnciJIHu8+CMvXLQ8AD51LPzAoUfT21D5Ew==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-ppc64-gnu@1.12.2':
+    resolution: {integrity: sha512-q7xRvVpmcfeL+LlZg8Pbbo6QaTZwDU5BaGZbwfhkEsXJn3Was8xYfE0RBH266xZt0rM6B7i8xAYIvjthuUIWHg==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-riscv64-gnu@1.12.2':
+    resolution: {integrity: sha512-0CVdx6lcnT3Q9inOH8tsMIOJ6ImndllMjqJHg8RLVdB7Vq4SfkEXl9mCSsVNuNA4MCYycRicCUxPCabVHJRr6A==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-riscv64-musl@1.12.2':
+    resolution: {integrity: sha512-iOwlRo9vnp6R6ohHQS11n0NnfdXx/omhkocmIfaPRpQhKZ+3BDMkkdRVh53qjkFkpPddf+FETA28NwGN7l5l+w==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-s390x-gnu@1.12.2':
+    resolution: {integrity: sha512-HYJtLfXq94q8iZNFT1lknx258wlkkWhZeUXJRqzKBBUJ00CvZ+N33zgbCqimLjsyw5Va6uUxhVa12mI+kaveEw==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-x64-gnu@1.12.2':
+    resolution: {integrity: sha512-mPsUhunKKDih5O96Y6enDQyHc1SqBPlY1E/SfMWDM3EdJ95Z9CArPeCVwCCqbP45ljvivdEk8Fxn+SIb1rDAJQ==}
+    cpu: [x64]
+    os: [linux]
+
+  '@unrs/resolver-binding-linux-x64-musl@1.12.2':
+    resolution: {integrity: sha512-azrt6+5ydLd8Vt210AAFis/lZevSfPw93EJRIJG+xPu4WCJ8K0kppCTpMyLPcKT7H15M4Jnt2tMp5bOvCkRC6A==}
+    cpu: [x64]
+    os: [linux]
+
+  '@unrs/resolver-binding-openharmony-arm64@1.12.2':
+    resolution: {integrity: sha512-YZ9hP4O0X9PQb8eO980qmLNGH4zT3I9+SZTdt0Pr0YyuGQhYKoOZkV02VzrzyOZJ5xIJ3UFIenKkUkGg8GjgWQ==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@unrs/resolver-binding-wasm32-wasi@1.12.2':
+    resolution: {integrity: sha512-tYFDIkMxSflfEc/h92ZWNsZlHSwgimbNHSO3PL2JWQHfCuC2q316jMyYU9TIWZsFK2bQwyK5VAdYgn8ygPj69A==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+
+  '@unrs/resolver-binding-win32-arm64-msvc@1.12.2':
+    resolution: {integrity: sha512-qzNyg3xL0VPQmCaUh+N5jSitce6k+uCBfMDesWRnlULOZaqUkaJ0ybdT+UqlAWJoQjuqfIU/0Ptx9bteN4D82g==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@unrs/resolver-binding-win32-ia32-msvc@1.12.2':
+    resolution: {integrity: sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==}
+    cpu: [ia32]
+    os: [win32]
 
-  '@vitest/expect@2.1.9':
-    resolution: {integrity: sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==}
+  '@unrs/resolver-binding-win32-x64-msvc@1.12.2':
+    resolution: {integrity: sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==}
+    cpu: [x64]
+    os: [win32]
 
-  '@vitest/expect@4.1.3':
-    resolution: {integrity: sha512-CW8Q9KMtXDGHj0vCsqui0M5KqRsu0zm0GNDW7Gd3U7nZ2RFpPKSCpeCXoT+/+5zr1TNlsoQRDEz+LzZUyq6gnQ==}
+  '@vitest/browser@4.1.8':
+    resolution: {integrity: sha512-u21VzX07HzlJYpFgkxmjEXar/tG2UqWGgyGG/46SrrPc7rSdCTPw5vuowopO9CIqF8UCUQzDFdbVnNpw6N0BfQ==}
+    peerDependencies:
+      vitest: 4.1.8
 
-  '@vitest/mocker@2.1.9':
-    resolution: {integrity: sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==}
+  '@vitest/coverage-v8@4.1.8':
+    resolution: {integrity: sha512-lt3kovsyHwYe00wq4D1ti0Z974fWj4NLp6siqiyEufUpyFwK9Yhi7rBhac9JL5aA0zoMrJqc4vYPZRUnI7l7nw==}
     peerDependencies:
-      msw: ^2.4.9
-      vite: ^8.0.7
+      '@vitest/browser': 4.1.8
+      vitest: 4.1.8
     peerDependenciesMeta:
-      msw:
-        optional: true
-      vite:
+      '@vitest/browser':
         optional: true
 
-  '@vitest/mocker@4.1.3':
-    resolution: {integrity: sha512-XN3TrycitDQSzGRnec/YWgoofkYRhouyVQj4YNsJ5r/STCUFqMrP4+oxEv3e7ZbLi4og5kIHrZwekDJgw6hcjw==}
+  '@vitest/expect@4.1.8':
+    resolution: {integrity: sha512-h3nDO677RDLEGlBxyQ5CW8RlMThSKSRLUePLOx09gNIWRL40edgA1GCZSZgf1W55MFAG6/Sw14KeaAnqv0NKdQ==}
+
+  '@vitest/mocker@4.1.8':
+    resolution: {integrity: sha512-LEiN/xe4OSIbKe9HQIp5OC24agGD9J5CnmMgsLohVVoOPWL9a2sBoR6VBx43jQZb7Kr1l4RCuyCJzcAa0+dojw==}
     peerDependencies:
       msw: ^2.4.9
       vite: ^8.0.7
@@ -2161,64 +2522,35 @@ packages:
   '@vitest/pretty-format@2.1.9':
     resolution: {integrity: sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==}
 
-  '@vitest/pretty-format@4.1.3':
-    resolution: {integrity: sha512-hYqqwuMbpkkBodpRh4k4cQSOELxXky1NfMmQvOfKvV8zQHz8x8Dla+2wzElkMkBvSAJX5TRGHJAQvK0TcOafwg==}
+  '@vitest/pretty-format@4.1.8':
+    resolution: {integrity: sha512-9GasEBxpZ1VYIpqHf/0+YGg121uSNwCKOJqIrTwWP/TB7DmFCiaBpNl3aPZzoLWfWkuqhbH8vJIVobZkvdo2cA==}
 
-  '@vitest/runner@2.1.9':
-    resolution: {integrity: sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==}
-
-  '@vitest/runner@4.1.3':
-    resolution: {integrity: sha512-VwgOz5MmT0KhlUj40h02LWDpUBVpflZ/b7xZFA25F29AJzIrE+SMuwzFf0b7t4EXdwRNX61C3B6auIXQTR3ttA==}
+  '@vitest/runner@4.1.8':
+    resolution: {integrity: sha512-EmVxeBAfMJvycdjd6Hm+RbFBbA9fKvo0Kx37hNpBYoYeavH3RNsBXWDooR1mgD52dCrxIIuP7UotpfiwOikvcg==}
 
   '@vitest/snapshot@2.1.9':
     resolution: {integrity: sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==}
 
-  '@vitest/snapshot@4.1.3':
-    resolution: {integrity: sha512-9l+k/J9KG5wPJDX9BcFFzhhwNjwkRb8RsnYhaT1vPY7OufxmQFc9sZzScRCPTiETzl37mrIWVY9zxzmdVeJwDQ==}
-
-  '@vitest/spy@2.1.9':
-    resolution: {integrity: sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==}
-
-  '@vitest/spy@4.1.3':
-    resolution: {integrity: sha512-ujj5Uwxagg4XUIfAUyRQxAg631BP6e9joRiN99mr48Bg9fRs+5mdUElhOoZ6rP5mBr8Bs3lmrREnkrQWkrsTCw==}
+  '@vitest/snapshot@4.1.8':
+    resolution: {integrity: sha512-acfZboRmAIf05DEKcBQy33VXojFJjtUdLyo7oOmV9kebb2xdU01UknNiPuPZoJZQyO7DF0gZdTGTpeAzET9QPQ==}
 
-  '@vitest/utils@2.1.9':
-    resolution: {integrity: sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==}
+  '@vitest/spy@4.1.8':
+    resolution: {integrity: sha512-6EevtBp6OZOPF7bmz36HrGMeP3txgVSrgebWxHOafDXGkhIzfXK14f8KF6MuFfgXXUeHxmpD3BQxkV00/3s5mA==}
 
-  '@vitest/utils@4.1.3':
-    resolution: {integrity: sha512-Pc/Oexse/khOWsGB+w3q4yzA4te7W4gpZZAvk+fr8qXfTURZUMj5i7kuxsNK5mP/dEB6ao3jfr0rs17fHhbHdw==}
+  '@vitest/utils@4.1.8':
+    resolution: {integrity: sha512-uOJamYALNhfJ6iolExyQM40yIQwDqYnkKtQ5VCiSe17E33H0aQ/u+1GlRuz4LZBk6Mm3sg90G9hEbmEt37C1Zg==}
 
-  '@volar/language-core@2.4.23':
-    resolution: {integrity: sha512-hEEd5ET/oSmBC6pi1j6NaNYRWoAiDhINbT8rmwtINugR39loROSlufGdYMF9TaKGfz+ViGs1Idi3mAhnuPcoGQ==}
+  '@volar/language-core@2.4.28':
+    resolution: {integrity: sha512-w4qhIJ8ZSitgLAkVay6AbcnC7gP3glYM3fYwKV3srj8m494E3xtrCv6E+bWviiK/8hs6e6t1ij1s2Endql7vzQ==}
 
-  '@volar/source-map@2.4.23':
-    resolution: {integrity: sha512-Z1Uc8IB57Lm6k7q6KIDu/p+JWtf3xsXJqAX/5r18hYOTpJyBn0KXUR8oTJ4WFYOcDzWC9n3IflGgHowx6U6z9Q==}
-
-  '@volar/typescript@2.4.23':
-    resolution: {integrity: sha512-lAB5zJghWxVPqfcStmAP1ZqQacMpe90UrP5RJ3arDyrhy4aCUQqmxPPLB2PWDKugvylmO41ljK7vZ+t6INMTag==}
-
-  '@vue/compiler-core@3.5.22':
-    resolution: {integrity: sha512-jQ0pFPmZwTEiRNSb+i9Ow/I/cHv2tXYqsnHKKyCQ08irI2kdF5qmYedmF8si8mA7zepUFmJ2hqzS8CQmNOWOkQ==}
-
-  '@vue/compiler-dom@3.5.22':
-    resolution: {integrity: sha512-W8RknzUM1BLkypvdz10OVsGxnMAuSIZs9Wdx1vzA3mL5fNMN15rhrSCLiTm6blWeACwUwizzPVqGJgOGBEN/hA==}
-
-  '@vue/compiler-vue2@2.7.16':
-    resolution: {integrity: sha512-qYC3Psj9S/mfu9uVi5WvNZIzq+xnXMhOwbTFKKDD7b1lhpnn71jXSFdTQ+WsIEk0ONCd7VV2IMm7ONl6tbQ86A==}
-
-  '@vue/language-core@2.2.0':
-    resolution: {integrity: sha512-O1ZZFaaBGkKbsRfnVH1ifOK1/1BUkyK+3SQsfnh6PmMmD4qJcTU8godCeA96jjDRTL6zgnK7YzCHfaUlH2r0Mw==}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
+  '@volar/source-map@2.4.28':
+    resolution: {integrity: sha512-yX2BDBqJkRXfKw8my8VarTyjv48QwxdJtvRgUpNE5erCsgEUdI2DsLbpa+rOQVAJYshY99szEcRDmyHbF10ggQ==}
 
-  '@vue/shared@3.5.22':
-    resolution: {integrity: sha512-F4yc6palwq3TT0u+FYf0Ns4Tfl9GRFURDN2gWG7L1ecIaS/4fCIuFOjMTnCyjsu/OK6vaDKLCrGAa+KvvH+h4w==}
+  '@volar/typescript@2.4.28':
+    resolution: {integrity: sha512-Ja6yvWrbis2QtN4ClAKreeUZPVYMARDYZl9LMEv1iQ1QdepB6wn0jTRxA9MftYmYa4DQ4k/DaSZpFPUfxl8giw==}
 
-  '@wdio/cli@9.27.0':
-    resolution: {integrity: sha512-k3kSs1sWTnDwdFLdBua7j5O//0N9k3qTj2nkyfMnkCEzOU00UMV2Y0f/yzNrn8BkkvohrJmwdEQPYx7rNhfj9g==}
+  '@wdio/cli@9.27.2':
+    resolution: {integrity: sha512-DHCtxsAmKu4hMAnEljiJ6v76XidA2A9IgP+5kQipxc7r8Ct22VJfEJnasWKEz35WztATzr6vzhk0JalTHMVunw==}
     engines: {node: '>=18.20.0'}
     hasBin: true
 
@@ -2226,27 +2558,27 @@ packages:
     resolution: {integrity: sha512-/6Z3sfSyhX5oVde0l01fyHimbqRYIVUDBnhDG2EMSCoC2lsaJX3Bm3IYpYHYHHFsgoDCi3B3Gv++t9dn2eSZZw==}
     engines: {node: ^16.13 || >=18}
 
-  '@wdio/config@9.27.0':
-    resolution: {integrity: sha512-9y8z7ugIbU6ycKrA2SqCpKh1/hobut2rDq9CLt/BNVzSlebBBVOTMiAt1XroZzcPnA7/ZqpbkpOsbpPUaAQuNQ==}
+  '@wdio/config@9.27.2':
+    resolution: {integrity: sha512-d31AMKrqADuKdw7F3025Aeunboska402xmbkdXpOKp3W8gwXcC/y9xorMNM1Z6/wYr+DDFBYXn9AgbaURPQ8gQ==}
     engines: {node: '>=18.20.0'}
 
-  '@wdio/cucumber-framework@9.27.0':
-    resolution: {integrity: sha512-kOpgvioEMuOe8kcaoHXLb9vmJGPSl5Kl4UM/b4I9BwElSAsY289HO+zuy5SuXvQYJ92Se35oNeznC8fd5FJwhg==}
+  '@wdio/cucumber-framework@9.27.2':
+    resolution: {integrity: sha512-igjWtX2URbsOHBuyHXneqAgdfR6UBRFOxatKBwmZ+MXXPKw4+UX/HaY6/Zz5gbqOxfxgjLcT8+HCI1iAk+UF2w==}
     engines: {node: '>=18.20.0'}
 
-  '@wdio/dot-reporter@9.27.0':
-    resolution: {integrity: sha512-gYFCTeEHZxzqdXCn/L519HDAFpci+dsdfzLHg+2XMlzIWEGSgHxMIr4/iLjvCwDgCSLeh+XvsBsPm3U+qOtwdg==}
+  '@wdio/dot-reporter@9.27.2':
+    resolution: {integrity: sha512-xoBgmACafV4L7e7e3DUN8UM1N+I225oms38JtxtfgrMfvHm8QtcmZWXfycxEGM28Gm2M3NmeV3oso7hZeBk6Ww==}
     engines: {node: '>=18.20.0'}
 
-  '@wdio/globals@9.27.0':
-    resolution: {integrity: sha512-yT6EAyvEqm+wFD11fg89BMxvFkYLgnIVCihfJx+k73Gm3utL/DfZQpSheQdwrlQzu5p7jHi/JwOD76740F5Peg==}
+  '@wdio/globals@9.27.2':
+    resolution: {integrity: sha512-Rx9bqD4/8iR3CNPMWYxywQSCqsR/WGwIYT2Q0uUmrvPxOdYFridDEhVRGO32kQ55UM5+JXzXppxgwGLRQ60fJg==}
     engines: {node: '>=18.20.0'}
     peerDependencies:
       expect-webdriverio: ^5.6.5
       webdriverio: ^9.0.0
 
-  '@wdio/local-runner@9.27.0':
-    resolution: {integrity: sha512-0AqAbz1UhZ9e72ebqH4/B9/qOy0LVm3iOOYp16Rz2zkE5DOudLPPn3DpakafqW22Z7Q+Wb/23KRttPMrq0rOxw==}
+  '@wdio/local-runner@9.27.2':
+    resolution: {integrity: sha512-VJ9SrOzZSgT8l3QOq+z/+nWZoLMeeEvzivEaVOBFwWOdkvE2JVomE19Ch/OFSXHCoGv3PrvfiiBunphLJ7EZ7A==}
     engines: {node: '>=18.20.0'}
 
   '@wdio/logger@8.38.0':
@@ -2260,46 +2592,46 @@ packages:
   '@wdio/protocols@8.40.3':
     resolution: {integrity: sha512-wK7+eyrB3TAei8RwbdkcyoNk2dPu+mduMBOdPJjp8jf/mavd15nIUXLID1zA+w5m1Qt1DsT1NbvaeO9+aJQ33A==}
 
-  '@wdio/protocols@9.27.0':
-    resolution: {integrity: sha512-rIk69BsY1+6uU2PEN5FiRpI6K7HJ86YHzZRFBe4iRzKXQgGNk1zWzbdVJIuNFoOWsnmYUkK42KSSOT4Le6EmiQ==}
+  '@wdio/protocols@9.27.2':
+    resolution: {integrity: sha512-aek2972uzuoSG5yHLhtFpd463qeB4PklYXbJd7Ta44yKinol+akdPZUc9AQJC9Fxz6kBzxHAp2nfYuppxm+Pqg==}
 
   '@wdio/repl@9.16.2':
     resolution: {integrity: sha512-FLTF0VL6+o5BSTCO7yLSXocm3kUnu31zYwzdsz4n9s5YWt83sCtzGZlZpt7TaTzb3jVUfxuHNQDTb8UMkCu0lQ==}
     engines: {node: '>=18.20.0'}
 
-  '@wdio/reporter@9.27.0':
-    resolution: {integrity: sha512-JsazSrpdKrUEz0RkZcNzHHO9EaoJsWnjzi8Lk3hyI3e2T0M0d/EZTaYwLU+zZXr9VRJBulv8DhRfmBx+gbY2jw==}
+  '@wdio/reporter@9.27.2':
+    resolution: {integrity: sha512-JDbBeSM8TMZ3CRTnF1fJqyUJEYDas6k1xjVZnrGrO8L/8xQ8dG2vaC5wGJz6uMSHazyks8pL3g/RS8dTbTUPbg==}
     engines: {node: '>=18.20.0'}
 
-  '@wdio/runner@9.27.0':
-    resolution: {integrity: sha512-PAuvuq0GaziutDXO8pZkUmca/qFGnGY2O3e4mQtqDUZbkyxYF4W68WJWhkvwuDAvN5GH1V+K/FBmiwL8m+roxw==}
+  '@wdio/runner@9.27.2':
+    resolution: {integrity: sha512-FLsJ/FKd5acsNOKMYWayVyyDBY1Zw91kgwZry9h+ghpbK8uzpkmgOPtGxljsABPrFpv02fk1ICUNjlKvzQBYNQ==}
     engines: {node: '>=18.20.0'}
     peerDependencies:
       expect-webdriverio: ^5.6.5
       webdriverio: ^9.0.0
 
-  '@wdio/spec-reporter@9.27.0':
-    resolution: {integrity: sha512-pSrSfflFGthCc14B/4VZqthrz6T5/N+PDqpIOf+bfwJwtPgVlzZoLzbkKYDmCYHGDlDFt1QrZS9WQ5Qw2Qz/Ow==}
+  '@wdio/spec-reporter@9.27.2':
+    resolution: {integrity: sha512-CGd71d+fxa9UZUBI8frQucv6Iyq8JfdBzET98H1bBqhtFy8xf1f9AaveQ4VvRr0LQKZ6LwmXRfb/bZJcr0yfag==}
     engines: {node: '>=18.20.0'}
 
   '@wdio/types@8.41.0':
     resolution: {integrity: sha512-t4NaNTvJZci3Xv/yUZPH4eTL0hxrVTf5wdwNnYIBrzMnlRDbNefjQ0P7FM7ZjQCLaH92AEH6t/XanUId7Webug==}
     engines: {node: ^16.13 || >=18}
 
-  '@wdio/types@9.27.0':
-    resolution: {integrity: sha512-DQJ+OdRBqUBcQ30DN2Z651hEVh3OoxnlDUSRqlWy9An2AY6v9rYWTj825B6zsj5pLLEToYO1tfwWq0ab183pXg==}
+  '@wdio/types@9.27.2':
+    resolution: {integrity: sha512-nBUq2juoaaibrOacn/cZ5IjZvJa6ZAHlh1B4UjMxOVcd7kzZyXJjfwAP3vNnboK4dyCLHyKLM+TpfFMmoO59OQ==}
     engines: {node: '>=18.20.0'}
 
   '@wdio/utils@8.41.0':
     resolution: {integrity: sha512-0TcTjBiax1VxtJQ/iQA0ZyYOSHjjX2ARVmEI0AMo9+AuIq+xBfnY561+v8k9GqOMPKsiH/HrK3xwjx8xCVS03g==}
     engines: {node: ^16.13 || >=18}
 
-  '@wdio/utils@9.27.0':
-    resolution: {integrity: sha512-fUasd5OKJTy2seJfWnYZ9xlxTtY0p/Kyeuh7Tbb8kcofBqmBi2fTvM3sfZlo1tGQX9yCh+IS2N7hlfyFMmuZ+w==}
+  '@wdio/utils@9.27.2':
+    resolution: {integrity: sha512-QANs93jABp4BfCrX3Vhmrt5usWz2Zo6F6H1hL1+/ibxwG3qYod68PRQIGssoV2Elhql3IUk6o8iRGTDqV0SmIg==}
     engines: {node: '>=18.20.0'}
 
-  '@wdio/xvfb@9.27.0':
-    resolution: {integrity: sha512-sumk8m5wzOPMs8TizfQkWG0MTqe0p1yfu77ouz+xy1hNW+gaSf99uiU3lvz4rSghloM1esKfqRCFQibJI4+d/w==}
+  '@wdio/xvfb@9.27.2':
+    resolution: {integrity: sha512-Rj8AP/VYVd5clZFKy+P7zzoXCKshjrog6lcV65nnUzATbUYT/PpUCy6OhEWHTSmLQY2Oc5ztY/IetLSg4nmB3w==}
     engines: {node: '>=18'}
 
   '@zip.js/zip.js@2.8.26':
@@ -2318,15 +2650,10 @@ packages:
     peerDependencies:
       acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
 
-  acorn-walk@8.3.4:
-    resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==}
+  acorn-walk@8.3.5:
+    resolution: {integrity: sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==}
     engines: {node: '>=0.4.0'}
 
-  acorn@8.15.0:
-    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
-    engines: {node: '>=0.4.0'}
-    hasBin: true
-
   acorn@8.16.0:
     resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==}
     engines: {node: '>=0.4.0'}
@@ -2364,20 +2691,14 @@ packages:
       ajv:
         optional: true
 
-  ajv@6.14.0:
-    resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
-
-  ajv@8.12.0:
-    resolution: {integrity: sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==}
-
-  ajv@8.13.0:
-    resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==}
+  ajv@6.15.0:
+    resolution: {integrity: sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==}
 
   ajv@8.18.0:
     resolution: {integrity: sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==}
 
-  alien-signals@0.4.14:
-    resolution: {integrity: sha512-itUAVzhczTmP2U5yX67xVpsbbOiquusbWVyA9N+sy6+r6YVbFkahXvNCeEPWEOMhwDYwbVbGHFkVL03N9I5g+Q==}
+  ajv@8.20.0:
+    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
 
   ansi-align@3.0.1:
     resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==}
@@ -2504,6 +2825,9 @@ packages:
     resolution: {integrity: sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==}
     engines: {node: '>=4'}
 
+  ast-v8-to-istanbul@1.0.3:
+    resolution: {integrity: sha512-jCMQ6ZylLPudp0CDfBmQBZUsrh1/8psbmu9ibeVWKuHWD0YrH9YABwlKu5kVEFoT0GCQQW9Z/SxfuEbbkGQCRg==}
+
   astral-regex@2.0.0:
     resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==}
     engines: {node: '>=8'}
@@ -2529,15 +2853,8 @@ packages:
     resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==}
     engines: {node: '>=8.0.0'}
 
-  autoprefixer@10.4.21:
-    resolution: {integrity: sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==}
-    engines: {node: ^10 || ^12 || >=14}
-    hasBin: true
-    peerDependencies:
-      postcss: ^8.1.0
-
-  autoprefixer@10.4.27:
-    resolution: {integrity: sha512-NP9APE+tO+LuJGn7/9+cohklunJsXWiaWEfV3si4Gi/XHDwVNgkwr1J3RQYFIvPy76GmJ9/bW8vyoU1LcxwKHA==}
+  autoprefixer@10.5.0:
+    resolution: {integrity: sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==}
     engines: {node: ^10 || ^12 || >=14}
     hasBin: true
     peerDependencies:
@@ -2550,48 +2867,45 @@ packages:
   avvio@9.2.0:
     resolution: {integrity: sha512-2t/sy01ArdHHE0vRH5Hsay+RtCZt3dLPji7W7/MMOCEgze5b7SNDC4j5H6FnVgPkI1MTNFGzHdHrVXDDl7QSSQ==}
 
-  axe-core@4.11.1:
-    resolution: {integrity: sha512-BASOg+YwO2C+346x3LZOeoovTIoTrRqEsqMa6fmfAV0P+U9mFr9NsyOEpiYvFjbc64NMrSswhV50WdXzdb/Z5A==}
+  axe-core@4.12.0:
+    resolution: {integrity: sha512-FTavr/7Ba0IptwGOPxnQvdyW2tAsdLBMTBXz7rKH6xJ2skpyxpBxyHkDdBs4lf69yRqYpkqCdfhnwS8YULGOmg==}
     engines: {node: '>=4'}
 
-  axios@1.14.0:
-    resolution: {integrity: sha512-3Y8yrqLSwjuzpXuZ0oIYZ/XGgLwUIBU3uLvbcpb0pidD9ctpShJd43KSlEEkVQg6DS0G9NKyzOvBfUtDKEyHvQ==}
-
   axios@1.16.1:
     resolution: {integrity: sha512-caYkukvroVPO8KrzuJEb50Hm07KwfBZPEC3VeFHTsqWHvKTsy54hjJz9BS/cdaypROE2rH6xvm9mHX4fgWkr3A==}
 
-  b4a@1.8.0:
-    resolution: {integrity: sha512-qRuSmNSkGQaHwNbM7J78Wwy+ghLEYF1zNrSeMxj4Kgw6y33O3mXcQ6Ie9fRvfU/YnxWkOchPXbaLb73TkIsfdg==}
+  b4a@1.8.1:
+    resolution: {integrity: sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==}
     peerDependencies:
       react-native-b4a: '*'
     peerDependenciesMeta:
       react-native-b4a:
         optional: true
 
-  babel-jest@29.7.0:
-    resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  babel-jest@30.4.1:
+    resolution: {integrity: sha512-fATAbM8piYxkiXQp3RBXmZHxZVNJZAVXXfyeyCN2Tida3+qJ8ea9UxhiJ2y4fLO90ZImKt6k9FlcH2+rLkJGhw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
-      '@babel/core': ^7.8.0
+      '@babel/core': ^7.11.0 || ^8.0.0-0
 
-  babel-plugin-istanbul@6.1.1:
-    resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==}
-    engines: {node: '>=8'}
+  babel-plugin-istanbul@7.0.1:
+    resolution: {integrity: sha512-D8Z6Qm8jCvVXtIRkBnqNHX0zJ37rQcFJ9u8WOS6tkYOsRdHBzypCstaxWiu5ZIlqQtviRYbgnRLSoCEvjqcqbA==}
+    engines: {node: '>=12'}
 
-  babel-plugin-jest-hoist@29.6.3:
-    resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  babel-plugin-jest-hoist@30.4.0:
+    resolution: {integrity: sha512-9EdtWM/sSfXLOGLwSn+GS6pIXyBnL07/8gyJlwFXjWy4DxMOyItqyUT29d4lQiS380EZwYlX7/At4PgBS+m2aA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   babel-preset-current-node-syntax@1.2.0:
     resolution: {integrity: sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==}
     peerDependencies:
       '@babel/core': ^7.0.0 || ^8.0.0-0
 
-  babel-preset-jest@29.6.3:
-    resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  babel-preset-jest@30.4.0:
+    resolution: {integrity: sha512-lBY4jxsNmCnSiu7kquw8ZC9F4+XLMOKypT3RnNHPvU2Kpd4W0xaPuLr5ZkRyOsvLYAY4yaW1ZwTW4xB7NIiZzg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
-      '@babel/core': ^7.0.0
+      '@babel/core': ^7.11.0 || ^8.0.0-beta.1
 
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
@@ -2600,16 +2914,16 @@ packages:
     resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
     engines: {node: 18 || 20 || >=22}
 
-  bare-events@2.8.2:
-    resolution: {integrity: sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==}
+  bare-events@2.9.1:
+    resolution: {integrity: sha512-Z0oHEHAFDZkffN8Qc39zNZjQlMDkPJRyyyZieU1VH7u8c5S+qHZ2S8ixdKIAxEjfHO7FJxXmJWgteOghVanIsg==}
     peerDependencies:
       bare-abort-controller: '*'
     peerDependenciesMeta:
       bare-abort-controller:
         optional: true
 
-  bare-fs@4.6.0:
-    resolution: {integrity: sha512-2YkS7NuiJceSEbyEOdSNLE9tsGd+f4+f7C+Nik/MCk27SYdwIMPT/yRKvg++FZhQXgk0KWJKJyXX9RhVV0RGqA==}
+  bare-fs@4.7.2:
+    resolution: {integrity: sha512-aTvMFUWkBmjzKtEQMDGGDNF8bkfpD5N1b/FCwt7A3wrU4t1o/e/85Wzkluh6JlODCjqVESYCkQCdTXqZ9G7VFg==}
     engines: {bare: '>=1.16.0'}
     peerDependencies:
       bare-buffer: '*'
@@ -2617,15 +2931,15 @@ packages:
       bare-buffer:
         optional: true
 
-  bare-os@3.8.7:
-    resolution: {integrity: sha512-G4Gr1UsGeEy2qtDTZwL7JFLo2wapUarz7iTMcYcMFdS89AIQuBoyjgXZz0Utv7uHs3xA9LckhVbeBi8lEQrC+w==}
+  bare-os@3.9.1:
+    resolution: {integrity: sha512-6M5XjcnsygQNPMCMPXSK379xrJFiZ/AEMNBmFEmQW8d/789VQATvriyi5r0HYTL9TkQ26rn3kgdTG3aisbrXkQ==}
     engines: {bare: '>=1.14.0'}
 
-  bare-path@3.0.0:
-    resolution: {integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==}
+  bare-path@3.0.1:
+    resolution: {integrity: sha512-ghj2DSK/2e99a1anTVPCV4m4YIYtrbXhfM7V3D7XZLOTsybnYyaJloymGqssQc8l/or0UoDyRtNQkmkEF/ysgQ==}
 
-  bare-stream@2.12.0:
-    resolution: {integrity: sha512-w28i8lkBgREV3rPXGbgK+BO66q+ZpKqRWrZLiCdmmUlLPrQ45CzkvRhN+7lnv00Gpi2zy5naRxnUFAxCECDm9g==}
+  bare-stream@2.13.1:
+    resolution: {integrity: sha512-Vp0cnjYyrEC4whYTymQ+YZi6pBpfiICZO3cfRG8sy67ZNWe951urv1x4eW1BKNngw3U+3fPYb5JQvHbCtxH7Ow==}
     peerDependencies:
       bare-abort-controller: '*'
       bare-buffer: '*'
@@ -2638,26 +2952,17 @@ packages:
       bare-events:
         optional: true
 
-  bare-url@2.4.0:
-    resolution: {integrity: sha512-NSTU5WN+fy/L0DDenfE8SXQna4voXuW0FHM7wH8i3/q9khUSchfPbPezO4zSFMnDGIf9YE+mt/RWhZgNRKRIXA==}
+  bare-url@2.4.3:
+    resolution: {integrity: sha512-Kccpc7ACfXaxfeInfqKcZtW4pT5YBn1mesc4sCsun6sRwtbJ4h+sNOaksUpYEJUKfN65YWC6Bw2OJEFiKxq8nQ==}
 
   base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
-  baseline-browser-mapping@2.10.16:
-    resolution: {integrity: sha512-Lyf3aK28zpsD1yQMiiHD4RvVb6UdMoo8xzG2XzFIfR9luPzOpcBlAsT/qfB1XWS1bxWT+UtE4WmQgsp297FYOA==}
+  baseline-browser-mapping@2.10.33:
+    resolution: {integrity: sha512-bA6+tcSLpz2tIEdDXZPpPTIuxBcC4+w6SieaYyfigIa4h8GlFxbA17v22Vx3JUtuZQj9SgOsnbK+aTBzyDyEuw==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
-  baseline-browser-mapping@2.8.20:
-    resolution: {integrity: sha512-JMWsdF+O8Orq3EMukbUN1QfbLK9mX2CkUmQBcW2T0s8OmdAUL5LLM/6wFwSrqXzlXB13yhyK9gTKS1rIizOduQ==}
-    hasBin: true
-
-  basic-ftp@5.0.5:
-    resolution: {integrity: sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==}
-    engines: {node: '>=10.0.0'}
-    deprecated: Security vulnerability fixed in 5.2.1, please upgrade
-
   basic-ftp@5.3.1:
     resolution: {integrity: sha512-bopVNp6ugyA150DDuZfPFdt1KZ5a94ZDiwX4hMgZDzF+GttD80lEy8kj98kbyhLXnPvhtIo93mdnLIjpCAeeOw==}
     engines: {node: '>=10.0.0'}
@@ -2686,17 +2991,14 @@ packages:
     resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==}
     engines: {node: '>=10'}
 
-  brace-expansion@1.1.12:
-    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
-
-  brace-expansion@1.1.13:
-    resolution: {integrity: sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==}
+  brace-expansion@1.1.15:
+    resolution: {integrity: sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==}
 
-  brace-expansion@2.0.3:
-    resolution: {integrity: sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==}
+  brace-expansion@2.1.1:
+    resolution: {integrity: sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==}
 
-  brace-expansion@5.0.5:
-    resolution: {integrity: sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==}
+  brace-expansion@5.0.6:
+    resolution: {integrity: sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==}
     engines: {node: 18 || 20 || >=22}
 
   braces@3.0.3:
@@ -2706,11 +3008,6 @@ packages:
   browser-stdout@1.3.1:
     resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==}
 
-  browserslist@4.27.0:
-    resolution: {integrity: sha512-AXVQwdhot1eqLihwasPElhX2tAZiBjWdJ9i/Zcj2S6QYIjkx62OKSfnobkriB81C3l4w0rVy3Nt4jaTBltYEpw==}
-    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
-    hasBin: true
-
   browserslist@4.28.2:
     resolution: {integrity: sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==}
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
@@ -2743,23 +3040,29 @@ packages:
     resolution: {integrity: sha512-9q/rDEGSb/Qsvv2qvzIzdluL5k7AaJOTrw23z9reQthrbF7is4CtlT0DXyO1oei2DCp4uojjzQ7igaSHp1kAEQ==}
     engines: {node: '>=0.2.0'}
 
-  builtin-modules@5.0.0:
-    resolution: {integrity: sha512-bkXY9WsVpY7CvMhKSR6pZilZu9Ln5WDrKVBUXf2S443etkmEO4V58heTecXcUIsNsi4Rx8JUO4NfX1IcQl4deg==}
+  builtin-modules@5.2.0:
+    resolution: {integrity: sha512-02yxLeyxF4dNl6SlY6/5HfRSrSdZ/sCPoxy2kZNP5dZZX8LSAD9aE2gtJIUgWrsQTiMPl3mxESyrobSwvRGisQ==}
     engines: {node: '>=18.20'}
 
+  bundle-require@5.1.0:
+    resolution: {integrity: sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    peerDependencies:
+      esbuild: '>=0.18'
+
   cac@6.7.14:
     resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
     engines: {node: '>=8'}
 
-  cacheable@2.3.4:
-    resolution: {integrity: sha512-djgxybDbw9fL/ZWMI3+CE8ZilNxcwFkVtDc1gJ+IlOSSWkSMPQabhV/XCHTQ6pwwN6aivXPZ43omTooZiX06Ew==}
+  cacheable@2.3.5:
+    resolution: {integrity: sha512-EQfaKe09tl615iNvq/TBRWTFf1AKJNXYQSsMx0Z3EI0nA+pVsVPS8wJhnRlkbdacKPh1d0qVIhwTc2zsQNFEEg==}
 
   call-bind-apply-helpers@1.0.2:
     resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
     engines: {node: '>= 0.4'}
 
-  call-bind@1.0.8:
-    resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==}
+  call-bind@1.0.9:
+    resolution: {integrity: sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==}
     engines: {node: '>= 0.4'}
 
   call-bound@1.0.4:
@@ -2778,11 +3081,8 @@ packages:
     resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
     engines: {node: '>=10'}
 
-  caniuse-lite@1.0.30001751:
-    resolution: {integrity: sha512-A0QJhug0Ly64Ii3eIqHu5X51ebln3k4yTUkY1j8drqpWHVreg/VLijN48cZ1bYPiqOQuqpkIKnzr/Ul8V+p6Cw==}
-
-  caniuse-lite@1.0.30001787:
-    resolution: {integrity: sha512-mNcrMN9KeI68u7muanUpEejSLghOKlVhRqS/Za2IeyGllJ9I9otGpR9g3nsw7n4W378TE/LyIteA0+/FOZm4Kg==}
+  caniuse-lite@1.0.30001793:
+    resolution: {integrity: sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==}
 
   capital-case@1.0.4:
     resolution: {integrity: sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A==}
@@ -2791,10 +3091,6 @@ packages:
     resolution: {integrity: sha512-38ixH/mqpY6IwnZkz6xPqx8aB5/KVR+j6VPugcir3EGOsphnWXrPH/mUt8Jp+ninL6ghY0AaJDQ10hSfCPGy/g==}
     engines: {node: '>= 12.0.0'}
 
-  chai@5.3.3:
-    resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==}
-    engines: {node: '>=18'}
-
   chai@6.2.2:
     resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
     engines: {node: '>=18'}
@@ -2827,10 +3123,6 @@ packages:
   check-error@1.0.2:
     resolution: {integrity: sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==}
 
-  check-error@2.1.3:
-    resolution: {integrity: sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==}
-    engines: {node: '>= 16'}
-
   cheerio-select@2.1.0:
     resolution: {integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==}
 
@@ -2851,13 +3143,8 @@ packages:
     engines: {node: '>=12.13.0'}
     hasBin: true
 
-  chromedriver@147.0.1:
-    resolution: {integrity: sha512-bGmw/dtwI5VX5BwbK4Vlotl9Yfm+np/FV54GG6IAXJDZUdGVCa5ABM8NjHpPzRzoum6bAvGTpPOdDtMpxSvalg==}
-    engines: {node: '>=20'}
-    hasBin: true
-
-  chromedriver@148.0.3:
-    resolution: {integrity: sha512-efk4NIkjjRr3Zy0C8Trj8jpMGgDY+ZA6kVpYFerH3M4tM4fguKCi81PguWwmHVx8FZdMmhFYczb1PaPvJqUkZQ==}
+  chromedriver@148.0.4:
+    resolution: {integrity: sha512-3UyptFDG4YF1Pyv3fzn95s1CN4K3zCpHSmE6g+6J4f2u9KxxOYzrwN2GApVyM2z02hlbSqzo9Ajn2hMi7LnvCw==}
     engines: {node: '>=22'}
     hasBin: true
 
@@ -2873,8 +3160,8 @@ packages:
     resolution: {integrity: sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==}
     engines: {node: '>=8'}
 
-  cjs-module-lexer@1.4.3:
-    resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==}
+  cjs-module-lexer@2.2.0:
+    resolution: {integrity: sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ==}
 
   class-transformer@0.5.1:
     resolution: {integrity: sha512-SQa1Ws6hUbfC98vKGxZH3KFY0Y1lm5Zm0SY8XX9zbK7FJCyVEac3ATW0RIpwzW+oOfmHE5PMPufDG9hCfoEOMw==}
@@ -2956,14 +3243,26 @@ packages:
     resolution: {integrity: sha512-MwVNWlYjDTtOjX5PiD7o5pK0UrFU/OYgcJfjjK4RaHZETNtjJqrZa9Y9ds88+A+f+d5lv+561eZ+yCKoS3gbAA==}
     engines: {node: '>=18'}
 
-  commander@13.1.0:
-    resolution: {integrity: sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==}
-    engines: {node: '>=18'}
+  commander@14.0.0:
+    resolution: {integrity: sha512-2uM9rYjPvyq39NwLRqaiLtWHyDC1FvryJDa2ATTVims5YAS4PupsEQsDvP14FqhFr0P49CYDugi59xaxJlTXRA==}
+    engines: {node: '>=20'}
+
+  commander@14.0.2:
+    resolution: {integrity: sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ==}
+    engines: {node: '>=20'}
 
   commander@14.0.3:
     resolution: {integrity: sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==}
     engines: {node: '>=20'}
 
+  commander@15.0.0:
+    resolution: {integrity: sha512-z67u4ZhzCL/Tydu1lJARtEZYWbWaN7oYLHbsuzocr6y4N6WZAagG3RQ4FW61V1/0+jImpj293XfrcYnd1qxtPg==}
+    engines: {node: '>=22.12.0'}
+
+  commander@4.1.1:
+    resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
+    engines: {node: '>= 6'}
+
   commander@9.1.0:
     resolution: {integrity: sha512-i0/MaqBtdbnJ4XQs4Pmyb+oFQl+q0lsAmokVUH92SlSw4fkeAcG3bVon+Qt7hmtF+u3Het6o4VgrcY3qAoEB6w==}
     engines: {node: ^12.20.0 || >=14}
@@ -2989,8 +3288,12 @@ packages:
   confbox@0.1.8:
     resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}
 
-  confbox@0.2.2:
-    resolution: {integrity: sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ==}
+  confbox@0.2.4:
+    resolution: {integrity: sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==}
+
+  consola@3.4.2:
+    resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==}
+    engines: {node: ^14.18.0 || >=16.10.0}
 
   content-disposition@1.1.0:
     resolution: {integrity: sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==}
@@ -3031,16 +3334,11 @@ packages:
     resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==}
     engines: {node: '>= 14'}
 
-  create-jest@29.7.0:
-    resolution: {integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-    hasBin: true
-
   create-require@1.1.1:
     resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
 
-  create-wdio@9.27.0:
-    resolution: {integrity: sha512-6ot1WVks07Otj+5jDsi/NU0L3avsIA9C1mh0MtlXsR6kSvZNxwc56NH6sX3M1p+5e8Ysl777Vs4PqmgHh7LrNg==}
+  create-wdio@9.27.2:
+    resolution: {integrity: sha512-zhulPsBa+NkPbLtRFlZFzijCmvS5n7gkWB/90JwahfebfzB0k6/ZwWue7PwyVgzzD/JUGzX1M4HlaWo6265ESQ==}
     engines: {node: '>=12.0.0'}
     hasBin: true
 
@@ -3116,9 +3414,6 @@ packages:
     resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==}
     engines: {node: '>= 0.4'}
 
-  de-indent@1.0.2:
-    resolution: {integrity: sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==}
-
   debug@3.2.7:
     resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
     peerDependencies:
@@ -3258,14 +3553,6 @@ packages:
   didyoumean@1.2.2:
     resolution: {integrity: sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==}
 
-  diff-sequences@29.6.3:
-    resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  diff@4.0.2:
-    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
-    engines: {node: '>=0.3.1'}
-
   diff@4.0.4:
     resolution: {integrity: sha512-X07nttJQkwkfKfvTPG/KSnE2OMdcUCao6+eXF3wmnIQRn2aPAHH3VxDbDOdegkd6JbPsXqShpvEOHfAT+nCNwQ==}
     engines: {node: '>=0.3.1'}
@@ -3274,6 +3561,10 @@ packages:
     resolution: {integrity: sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==}
     engines: {node: '>=0.3.1'}
 
+  diff@7.0.0:
+    resolution: {integrity: sha512-PJWHUb1RFevKCwaFA9RlG5tCd+FO5iRh9A8HEtkmBH2Li03iJriB6m6JIN4rGz3K3JLawI7/veA1xzRKP6ISBw==}
+    engines: {node: '>=0.3.1'}
+
   diff@8.0.4:
     resolution: {integrity: sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==}
     engines: {node: '>=0.3.1'}
@@ -3299,8 +3590,8 @@ packages:
     resolution: {integrity: sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==}
     engines: {node: '>=12'}
 
-  dotenv@17.4.1:
-    resolution: {integrity: sha512-k8DaKGP6r1G30Lx8V4+pCsLzKr8vLmV2paqEj1Y55GdAgJuIqpRp5FfajGF8KtwMxCz9qJc6wUIJnm053d/WCw==}
+  dotenv@17.4.2:
+    resolution: {integrity: sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==}
     engines: {node: '>=12'}
 
   dunder-proto@1.0.1:
@@ -3337,11 +3628,8 @@ packages:
     engines: {node: '>=0.10.0'}
     hasBin: true
 
-  electron-to-chromium@1.5.240:
-    resolution: {integrity: sha512-OBwbZjWgrCOH+g6uJsA2/7Twpas2OlepS9uvByJjR2datRDuKGYeD+nP8lBBks2qnB7bGJNHDUx7c/YLaT3QMQ==}
-
-  electron-to-chromium@1.5.333:
-    resolution: {integrity: sha512-skNh4FsE+IpCJV7xAQGbQ4eyOGvcEctVBAk7a5KPzxC3alES9rLrT+2IsPRPgeQr8LVxdJr8BHQ9481+TOr0xg==}
+  electron-to-chromium@1.5.365:
+    resolution: {integrity: sha512-xfip4u1QF1s+URFqpA6N+OeFpDGpN7VJz1f3MO3bVL0QYBjpGiZ5/Of7kugvM+o8TTqmanUlviHN3c8M9vYWCw==}
 
   emittery@0.13.1:
     resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==}
@@ -3359,8 +3647,8 @@ packages:
   end-of-stream@1.4.5:
     resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
 
-  enhanced-resolve@5.20.1:
-    resolution: {integrity: sha512-Qohcme7V1inbAfvjItgw0EaxVX5q2rdVEZHRBrEQdRZTssLDGsL8Lwrznl8oQ/6kuTJONLaDcGjkNP247XEhcA==}
+  enhanced-resolve@5.22.1:
+    resolution: {integrity: sha512-6QEuw3zoX1SJQc7b87aBXke/no+mG2bTBgw29gWMQonLmpEkWoCAVkl+M49e48AZlWzxiDzDZzYdp6kobcyLww==}
     engines: {node: '>=10.13.0'}
 
   entities@2.2.0:
@@ -3378,6 +3666,10 @@ packages:
     resolution: {integrity: sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==}
     engines: {node: '>=0.12'}
 
+  entities@8.0.0:
+    resolution: {integrity: sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==}
+    engines: {node: '>=20.19.0'}
+
   env-paths@2.2.1:
     resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
     engines: {node: '>=6'}
@@ -3393,8 +3685,8 @@ packages:
   error-stack-parser@2.1.4:
     resolution: {integrity: sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==}
 
-  es-abstract@1.24.0:
-    resolution: {integrity: sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==}
+  es-abstract@1.24.2:
+    resolution: {integrity: sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==}
     engines: {node: '>= 0.4'}
 
   es-define-property@1.0.1:
@@ -3408,14 +3700,11 @@ packages:
   es-get-iterator@1.1.3:
     resolution: {integrity: sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==}
 
-  es-module-lexer@1.7.0:
-    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
-
-  es-module-lexer@2.0.0:
-    resolution: {integrity: sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==}
+  es-module-lexer@2.1.0:
+    resolution: {integrity: sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==}
 
-  es-object-atoms@1.1.1:
-    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+  es-object-atoms@1.1.2:
+    resolution: {integrity: sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==}
     engines: {node: '>= 0.4'}
 
   es-set-tostringtag@2.1.0:
@@ -3435,6 +3724,11 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
+  esbuild@0.28.0:
+    resolution: {integrity: sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   escalade@3.2.0:
     resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
     engines: {node: '>=6'}
@@ -3465,11 +3759,11 @@ packages:
     peerDependencies:
       eslint: '>=7.0.0'
 
-  eslint-import-resolver-node@0.3.9:
-    resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==}
+  eslint-import-resolver-node@0.3.10:
+    resolution: {integrity: sha512-tRrKqFyCaKict5hOd244sL6EQFNycnMQnBe+j8uqGNXYzsImGbGUU4ibtoaBmv5FLwJwcFJNeg1GeVjQfbMrDQ==}
 
-  eslint-module-utils@2.12.1:
-    resolution: {integrity: sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==}
+  eslint-module-utils@2.13.0:
+    resolution: {integrity: sha512-bLohSkT6469rRs8czj0tLTD8vaeIS/whvPRJVjDr7IuoTT1k5DYDERlNycjDj/HkOlvQdYurmfZ/g3fG5bgeLQ==}
     engines: {node: '>=4'}
     peerDependencies:
       '@typescript-eslint/parser': '*'
@@ -3499,8 +3793,8 @@ packages:
       '@typescript-eslint/parser':
         optional: true
 
-  eslint-plugin-prettier@5.5.5:
-    resolution: {integrity: sha512-hscXkbqUZ2sPithAuLm5MXL+Wph+U7wHngPBv9OMWwlP8iaflyxpjTYZkmdgB4/vPIhemRlBEoLrH7UC1n7aUw==}
+  eslint-plugin-prettier@5.5.6:
+    resolution: {integrity: sha512-ifetmTcxWfz+4qRW3pH/ujdTq2jQIj59AxJMIN26K5avYgU8dxycUETQonWiW+wPrYXA0j3Try0l1CnwVQtDqQ==}
     engines: {node: ^14.18.0 || >=16.0.0}
     peerDependencies:
       '@types/eslint': '>=8.0.0'
@@ -3513,6 +3807,10 @@ packages:
       eslint-config-prettier:
         optional: true
 
+  eslint-plugin-security@4.0.0:
+    resolution: {integrity: sha512-tfuQT8K/Li1ZxhFzyD8wPIKtlzZxqBcPr9q0jFMQ77wWAbKBVEhaMPVQRTMTvCMUDhwBe5vPVqQPwAGk/ASfxQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
   eslint-plugin-unicorn@64.0.0:
     resolution: {integrity: sha512-rNZwalHh8i0UfPlhNwg5BTUO1CMdKNmjqe+TgzOTZnpKoi8VBgsW7u9qCHIdpxEzZ1uwrJrPF0uRb7l//K38gA==}
     engines: {node: ^20.10.0 || >=21.0.0}
@@ -3531,8 +3829,8 @@ packages:
     resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
-  eslint@10.2.0:
-    resolution: {integrity: sha512-+L0vBFYGIpSNIt/KWTpFonPrqYvgKw1eUI5Vn7mEogrQcWtWYtNQ7dNqC+px/J0idT3BAkiWrhfS7k+Tum8TUA==}
+  eslint@10.4.1:
+    resolution: {integrity: sha512-AyIKhnOBuOAdueD7RB3xB+YeAWScb9jHsJBgH2Hcde8InP5JYhqrRR6iTMHyTEwgENK54Cp44e4v8BwNhsuHuw==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
     hasBin: true
     peerDependencies:
@@ -3595,32 +3893,28 @@ packages:
     resolution: {integrity: sha512-Fqs7ChZm72y40wKjOFXBKg7nJZvQJmewP5/7LtePDdnah/+FH9Hp5sgMujSCMPXlxOAW2//1jrW9pnsY7o20vQ==}
     engines: {node: '>=18'}
 
-  exit@0.1.2:
-    resolution: {integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==}
+  exit-x@0.2.2:
+    resolution: {integrity: sha512-+I6B/IkJc1o/2tiURyz/ivu/O0nKNEArIUB5O7zBrlDVJr22SCLH3xTeEry428LvFhRzIA1g8izguxJ/gbNcVQ==}
     engines: {node: '>= 0.8.0'}
 
   expect-type@1.3.0:
     resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
     engines: {node: '>=12.0.0'}
 
-  expect-webdriverio@5.6.5:
-    resolution: {integrity: sha512-5ot+Apo0bEvMD/nqzWymQpgyWnOdu0kVpmahLx5T7NzUc6RyifucZ24Gsfr6F6C8yRGBhmoFh7ZeY+W9kteEBQ==}
+  expect-webdriverio@5.6.7:
+    resolution: {integrity: sha512-xuqXfkOCfkWImXyFq54FrKaSdm1CMRQ2OqNeldggQuhbuFaD0hvoUP65deZo2v+FsrHC3R4Q2V7R9nH3LKNoCQ==}
     engines: {node: '>=20'}
     peerDependencies:
       '@wdio/globals': ^9.0.0
       '@wdio/logger': ^9.0.0
       webdriverio: ^9.0.0
 
-  expect@29.7.0:
-    resolution: {integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  expect@30.3.0:
-    resolution: {integrity: sha512-1zQrciTiQfRdo7qJM1uG4navm8DayFa2TgCSRlzUyNkhcJ6XUZF3hjnpkyr3VhAqPH7i/9GkG7Tv5abz6fqz0Q==}
+  expect@30.4.1:
+    resolution: {integrity: sha512-PMARsyh/JtqC20HoGqlFcIlQAyqUtW4PlI1rup1uhYJtKuwAjbvWi3GQMAn+STdHum/dk8xrKfUM1+5SAwpolA==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  exsolve@1.0.7:
-    resolution: {integrity: sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==}
+  exsolve@1.0.8:
+    resolution: {integrity: sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA==}
 
   extract-zip@2.0.1:
     resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
@@ -3649,8 +3943,8 @@ packages:
   fast-json-stable-stringify@2.1.0:
     resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
 
-  fast-json-stringify@6.3.0:
-    resolution: {integrity: sha512-oRCntNDY/329HJPlmdNLIdogNtt6Vyjb1WuT01Soss3slIdyUp8kAcDU3saQTOquEK8KFVfwIIF7FebxUAu+yA==}
+  fast-json-stringify@6.4.0:
+    resolution: {integrity: sha512-ibRCQ0GZKJIQ+P3Et1h0LhPgp3PMTYk0MH8O+kW3lNYsvmaQww5Nn3f1jf73Q0jR1Yz3a1CDP4/NZD3vOajWJQ==}
 
   fast-levenshtein@2.0.6:
     resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
@@ -3658,18 +3952,18 @@ packages:
   fast-querystring@1.1.2:
     resolution: {integrity: sha512-g6KuKWmFXc0fID8WWH0jit4g0AGBoJhCkJMb1RmbsSEUNvQ+ZC8D6CUZ+GtF8nMzSPXnhiePyyqqipzNNEnHjg==}
 
-  fast-uri@3.1.0:
-    resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==}
+  fast-uri@3.1.2:
+    resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==}
 
-  fast-xml-builder@1.1.4:
-    resolution: {integrity: sha512-f2jhpN4Eccy0/Uz9csxh3Nu6q4ErKxf0XIsasomfOihuSUa3/xw6w8dnOtCDgEItQFJG8KyXPzQXzcODDrrbOg==}
+  fast-xml-builder@1.2.0:
+    resolution: {integrity: sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==}
 
-  fast-xml-parser@4.5.3:
-    resolution: {integrity: sha512-RKihhV+SHsIUGXObeVy9AXiBbFwkVk7Syp8XgwN5U3JV416+Gwp/GO9i0JYKmikykgz/UHRrrV4ROuZEo/T0ig==}
+  fast-xml-parser@4.5.6:
+    resolution: {integrity: sha512-Yd4vkROfJf8AuJrDIVMVmYfULKmIJszVsMv7Vo71aocsKgFxpdlpSHXSaInvyYfgw2PRuObQSW2GFpVMUjxu9A==}
     hasBin: true
 
-  fast-xml-parser@5.5.10:
-    resolution: {integrity: sha512-go2J2xODMc32hT+4Xr/bBGXMaIoiCwrwp2mMtAvKyvEFW6S/v5Gn2pBmE4nvbwNjGhpcAiOwEv7R6/GZ6XRa9w==}
+  fast-xml-parser@5.8.0:
+    resolution: {integrity: sha512-6bIM7fsJxeo3uXv7OncQYsBAMPJ7V16Slahl/6M98C/i2q+vB1+4a0MtrvYwDFEUrwDSbAmeLDRXsOBwrL7yAg==}
     hasBin: true
 
   fastest-levenshtein@1.0.16:
@@ -3679,8 +3973,8 @@ packages:
   fastify-plugin@5.1.0:
     resolution: {integrity: sha512-FAIDA8eovSt5qcDgcBvDuX/v0Cjz0ohGhENZ/wpc3y+oZCY2afZ9Baqql3g/lC+OHRnciQol4ww7tuthOb9idw==}
 
-  fastify@5.8.4:
-    resolution: {integrity: sha512-sa42J1xylbBAYUWALSBoyXKPDUvM3OoNOibIefA+Oha57FryXKKCZarA1iDntOCWp3O35voZLuDg2mdODXtPzQ==}
+  fastify@5.8.5:
+    resolution: {integrity: sha512-Yqptv59pQzPgQUSIm87hMqHJmdkb1+GPxdE6vW6FRyVE9G86mt7rOghitiU4JHRaTyDUk9pfeKmDeu70lAwM4Q==}
 
   fastq@1.20.1:
     resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
@@ -3712,22 +4006,22 @@ packages:
     resolution: {integrity: sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==}
     engines: {node: '>=18'}
 
-  file-entry-cache@11.1.2:
-    resolution: {integrity: sha512-N2WFfK12gmrK1c1GXOqiAJ1tc5YE+R53zvQ+t5P8S5XhnmKYVB5eZEiLNZKDSmoG8wqqbF9EXYBBW/nef19log==}
+  file-entry-cache@11.1.3:
+    resolution: {integrity: sha512-oMbq0PD6VIiIwMF6LIa7MEwd/l9huKwmqRKXqmrkqIZv8CvRbfowL+L0ryAl8h//HfAS0zS+4SbYoRyAoA6BJA==}
 
   file-entry-cache@8.0.0:
     resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
     engines: {node: '>=16.0.0'}
 
-  filelist@1.0.4:
-    resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==}
+  filelist@1.0.6:
+    resolution: {integrity: sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==}
 
   fill-range@7.1.1:
     resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
     engines: {node: '>=8'}
 
-  find-my-way@9.5.0:
-    resolution: {integrity: sha512-VW2RfnmscZO5KgBY5XVyKREMW5nMZcxDy+buTOsL+zIPnBlbKm+00sgzoQzq1EVh4aALZLfKdwv6atBGcjvjrQ==}
+  find-my-way@9.6.0:
+    resolution: {integrity: sha512-Zf4Xve4RymLl7NgaavNebZ01joJ8MfVerOG43wy7SHLO+r+K0C6d/SE0BiR7AV5V1VOCFlOP7ecdo+I4qmiHrQ==}
     engines: {node: '>=20'}
 
   find-up-simple@1.0.1:
@@ -3746,6 +4040,9 @@ packages:
     resolution: {integrity: sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
+  fix-dts-default-cjs-exports@1.0.1:
+    resolution: {integrity: sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg==}
+
   flat-cache@4.0.1:
     resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
     engines: {node: '>=16'}
@@ -3757,9 +4054,6 @@ packages:
     resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==}
     hasBin: true
 
-  flatted@3.3.3:
-    resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
-
   flatted@3.4.2:
     resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
 
@@ -3768,15 +4062,6 @@ packages:
     engines: {node: '>=18'}
     deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
 
-  follow-redirects@1.15.11:
-    resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==}
-    engines: {node: '>=4.0'}
-    peerDependencies:
-      debug: '*'
-    peerDependenciesMeta:
-      debug:
-        optional: true
-
   follow-redirects@1.16.0:
     resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==}
     engines: {node: '>=4.0'}
@@ -3802,17 +4087,14 @@ packages:
     resolution: {integrity: sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==}
     engines: {node: '>=12.20.0'}
 
-  fraction.js@4.3.7:
-    resolution: {integrity: sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==}
-
   fraction.js@5.3.4:
     resolution: {integrity: sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==}
 
   fs-constants@1.0.0:
     resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
 
-  fs-extra@11.3.2:
-    resolution: {integrity: sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==}
+  fs-extra@11.3.5:
+    resolution: {integrity: sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==}
     engines: {node: '>=14.14'}
 
   fs.realpath@1.0.0:
@@ -3860,8 +4142,8 @@ packages:
     resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
     engines: {node: 6.* || 8.* || >= 10.*}
 
-  get-east-asian-width@1.5.0:
-    resolution: {integrity: sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==}
+  get-east-asian-width@1.6.0:
+    resolution: {integrity: sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==}
     engines: {node: '>=18'}
 
   get-func-name@2.0.2:
@@ -3899,9 +4181,6 @@ packages:
     resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==}
     engines: {node: '>= 0.4'}
 
-  get-tsconfig@4.13.7:
-    resolution: {integrity: sha512-7tN6rFgBlMgpBML5j8typ92BKFi2sFQvIdpAqLA2beia5avZDrMs0FLZiM5etShWq5irVyGcGMEA1jcDaK7A/Q==}
-
   get-uri@6.0.5:
     resolution: {integrity: sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==}
     engines: {node: '>= 14'}
@@ -3936,6 +4215,10 @@ packages:
     engines: {node: '>=12'}
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
+  global-directory@4.0.1:
+    resolution: {integrity: sha512-wHTUcDUoZ1H5/0iVqEudYW4/kAlN5cZ3j/bXn0Dpbizl9iaUVeWSHqiOjsgk6OW2bkLclbBjzewBz6weQ1zA2Q==}
+    engines: {node: '>=18'}
+
   global-dirs@3.0.1:
     resolution: {integrity: sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==}
     engines: {node: '>=10'}
@@ -3948,8 +4231,8 @@ packages:
     resolution: {integrity: sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==}
     engines: {node: '>=6'}
 
-  globals@17.4.0:
-    resolution: {integrity: sha512-hjrNztw/VajQwOLsMNT1cbJiH2muO3OROCHnbehc8eY5JyD2gqz4AcMHPqgaOR59DjgUjYAYLeH699g/eWi2jw==}
+  globals@17.6.0:
+    resolution: {integrity: sha512-sepffkT8stwnIYbsMBpoCHJuJM5l98FUF2AnE07hfvE0m/qp3R586hw4jF4uadbhvg1ooIdzuu7CsfD2jzCaNA==}
     engines: {node: '>=18'}
 
   globalthis@1.0.4:
@@ -3973,14 +4256,18 @@ packages:
   grapheme-splitter@1.0.4:
     resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==}
 
-  happy-dom@20.8.9:
-    resolution: {integrity: sha512-Tz23LR9T9jOGVZm2x1EPdXqwA37G/owYMxRwU0E4miurAtFsPMQ1d2Jc2okUaSjZqAFz2oEn3FLXC5a0a+siyA==}
+  happy-dom@20.9.0:
+    resolution: {integrity: sha512-GZZ9mKe8r646NUAf/zemnGbjYh4Bt8/MqASJY+pSm5ZDtc3YQox+4gsLI7yi1hba6o+eCsGxpHn5+iEVn31/FQ==}
     engines: {node: '>=20.0.0'}
 
   has-ansi@4.0.1:
     resolution: {integrity: sha512-Qr4RtTm30xvEdqUXbSBVWDu+PrTokJOwe/FU+VdfJPk+MXAPoeOzKpRyrDTnZIJwAkQ4oBLTU53nu0HrkF/Z2A==}
     engines: {node: '>=8'}
 
+  has-ansi@6.0.2:
+    resolution: {integrity: sha512-vAyM+6+jAYwSwz0/M0jYKfU9AvAMCz0kH791RsUhvMKGUHXled/3FjcQB3YiQ4Astj5srHdb6B2FHGIfZkOQNg==}
+    engines: {node: '>=18'}
+
   has-bigints@1.1.0:
     resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==}
     engines: {node: '>= 0.4'}
@@ -4016,8 +4303,8 @@ packages:
     resolution: {integrity: sha512-iZyKG96/JwPz1N55vj2Ie2vXbhu440zfUfJvSwEqEbeLluk7NnapfGqa7LH0mOsnDxTF85Mx8/dyR6HfqcbmbQ==}
     engines: {node: '>=20'}
 
-  hasown@2.0.2:
-    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+  hasown@2.0.4:
+    resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
     engines: {node: '>= 0.4'}
 
   he@1.2.0:
@@ -4027,8 +4314,8 @@ packages:
   hookified@1.15.1:
     resolution: {integrity: sha512-MvG/clsADq1GPM2KGo2nyfaWVyn9naPiXrqIe4jYjXNZQt238kWyOGrsyc/DmRAQ+Re6yeo6yX/yoNCG5KAEVg==}
 
-  hookified@2.1.1:
-    resolution: {integrity: sha512-AHb76R16GB5EsPBE2J7Ko5kiEyXwviB9P5SMrAKcuAu4vJPZttViAbj9+tZeaQE5zjDme+1vcHP78Yj/WoAveA==}
+  hookified@2.2.0:
+    resolution: {integrity: sha512-p/LgFzRN5FeoD3DLS6bkUapeye6E4SI6yJs6KetENd18S+FBthqYq2amJUWpt5z0EQwwHemidjY5OqJGEKm5uA==}
 
   hosted-git-info@2.8.9:
     resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==}
@@ -4041,6 +4328,10 @@ packages:
     resolution: {integrity: sha512-Rw/B2DNQaPBICNXEm8balFz9a6WpZrkCGpcWFpy7nCj+NyhSdqXipmfvtmWt9xGfp0wZnBxB+iVpLmQMYt47Tw==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  hosted-git-info@9.0.3:
+    resolution: {integrity: sha512-Hc+ghLoSt6QaYZUv0WBiIvmMDZuZZ7oaDvdH8MbfOO4lOsxdXLEvuC6ePoGs9H1X9oCLyq6+NVN0MKqD+ydxyg==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
   htm@3.1.1:
     resolution: {integrity: sha512-983Vyg8NwUE7JkZ6NmOqpCZ+sh1bKv2iYTlUkzlWmA5JD2acKoxd4KVxbMmxX/85mtfdnDmTFoNKcg5DGAvxNQ==}
 
@@ -4164,11 +4455,15 @@ packages:
     resolution: {integrity: sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==}
     engines: {node: '>=10'}
 
+  ini@4.1.1:
+    resolution: {integrity: sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
+
   inquirer@12.11.1:
     resolution: {integrity: sha512-9VF7mrY+3OmsAfjH3yKz/pLbJ5z22E23hENKw3/LNSaA/sAt3v49bDRY+Ygct1xwuKT+U+cBfTzjCPySna69Qw==}
     engines: {node: '>=18'}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     peerDependenciesMeta:
       '@types/node':
         optional: true
@@ -4177,16 +4472,16 @@ packages:
     resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==}
     engines: {node: '>= 0.4'}
 
-  ip-address@10.0.1:
-    resolution: {integrity: sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==}
+  ip-address@10.2.0:
+    resolution: {integrity: sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==}
     engines: {node: '>= 12'}
 
   ip-regex@4.3.0:
     resolution: {integrity: sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==}
     engines: {node: '>=8'}
 
-  ipaddr.js@2.3.0:
-    resolution: {integrity: sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg==}
+  ipaddr.js@2.4.0:
+    resolution: {integrity: sha512-9VGk3HGanVE6JoZXHiCpnGy5X0jYDnN4EA4lntFPj+1vIWlFhIylq2CrrCOJH9EAhc5CYhq18F2Av2tgoAPsYQ==}
     engines: {node: '>= 10'}
 
   is-arguments@1.2.0:
@@ -4224,8 +4519,8 @@ packages:
     resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
     engines: {node: '>= 0.4'}
 
-  is-core-module@2.16.1:
-    resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
+  is-core-module@2.16.2:
+    resolution: {integrity: sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==}
     engines: {node: '>= 0.4'}
 
   is-data-view@1.0.2:
@@ -4269,6 +4564,10 @@ packages:
     resolution: {integrity: sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==}
     engines: {node: '>=10'}
 
+  is-installed-globally@1.0.0:
+    resolution: {integrity: sha512-K55T22lfpQ63N4KEN57jZUAaAYqYHEe8veb/TycJRk9DdSCLLcovXz/mL6mOnhQaZsQGwPhuFopdQIlqGSEjiQ==}
+    engines: {node: '>=18'}
+
   is-interactive@1.0.0:
     resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==}
     engines: {node: '>=8'}
@@ -4305,10 +4604,6 @@ packages:
     resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
     engines: {node: '>=12'}
 
-  is-plain-object@5.0.0:
-    resolution: {integrity: sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==}
-    engines: {node: '>=0.10.0'}
-
   is-potential-custom-element-name@1.0.1:
     resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
 
@@ -4384,9 +4679,9 @@ packages:
   isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
-  isexe@3.1.1:
-    resolution: {integrity: sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==}
-    engines: {node: '>=16'}
+  isexe@3.1.5:
+    resolution: {integrity: sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==}
+    engines: {node: '>=18'}
 
   isexe@4.0.0:
     resolution: {integrity: sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==}
@@ -4396,10 +4691,6 @@ packages:
     resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
     engines: {node: '>=8'}
 
-  istanbul-lib-instrument@5.2.1:
-    resolution: {integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==}
-    engines: {node: '>=8'}
-
   istanbul-lib-instrument@6.0.3:
     resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==}
     engines: {node: '>=10'}
@@ -4408,8 +4699,8 @@ packages:
     resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
     engines: {node: '>=10'}
 
-  istanbul-lib-source-maps@4.0.1:
-    resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==}
+  istanbul-lib-source-maps@5.0.6:
+    resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==}
     engines: {node: '>=10'}
 
   istanbul-reports@3.2.0:
@@ -4424,17 +4715,17 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
-  jest-changed-files@29.7.0:
-    resolution: {integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-changed-files@30.4.1:
+    resolution: {integrity: sha512-IuctmYrxi21iOSOaIXpJWalHyPAsVv0GeBHKDn8C1CA4W5htHn7INL+wdnL4Bo0+olEndvAFkmb++tIQJG+vvg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-circus@29.7.0:
-    resolution: {integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-circus@30.4.2:
+    resolution: {integrity: sha512-rvHH7VlY6LgbJXJTQ87GW62g1FntOtbhh0zT+v04kC+pgL6aBKyYINXxWukCpj3dcIBMw5/XUbtDS9dU9JTXeQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-cli@29.7.0:
-    resolution: {integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-cli@30.4.2:
+    resolution: {integrity: sha512-jfA2ocvVHMXS2QijrJ0d31ektP+d/W0T5RpcTX2Pq+3sVqHlsXVCM2+FmwpL+bdY8OfHpIg9xMxLF17Zg0U49Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
@@ -4442,72 +4733,55 @@ packages:
       node-notifier:
         optional: true
 
-  jest-config@29.7.0:
-    resolution: {integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-config@30.4.2:
+    resolution: {integrity: sha512-rNHAShJQqQwFNoL0hbf3BphSBOWnpOUAKvidLS/AjNVLPfoj5mSf4jQMfW3cYOs6hXeZC7nF7mDHaBnbxELOzg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
+      esbuild-register: '>=3.4.0'
       ts-node: '>=9.0.0'
     peerDependenciesMeta:
       '@types/node':
         optional: true
+      esbuild-register:
+        optional: true
       ts-node:
         optional: true
 
-  jest-diff@29.7.0:
-    resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  jest-diff@30.3.0:
-    resolution: {integrity: sha512-n3q4PDQjS4LrKxfWB3Z5KNk1XjXtZTBwQp71OP0Jo03Z6V60x++K5L8k6ZrW8MY8pOFylZvHM0zsjS1RqlHJZQ==}
+  jest-diff@30.4.1:
+    resolution: {integrity: sha512-CRpFK0RtLriVDGcPPAnR6HMVI8bSR2jnUIgralhauzYQZIb4RH9AtEInTuQr65LmmGggGcRT6HIASxwqsVsmlA==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-docblock@29.7.0:
-    resolution: {integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  jest-each@29.7.0:
-    resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  jest-environment-node@29.7.0:
-    resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  jest-get-type@29.6.3:
-    resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  jest-haste-map@29.7.0:
-    resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-docblock@30.4.0:
+    resolution: {integrity: sha512-ZPMabUZCx5MpbZ2eBYSvZ0J8fvo3dR9oM+eeUpb3aKNQFuS2tu3Duw1TNlMoP8k3WQgKGJuhcMFvwcVuq6T7oA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-leak-detector@29.7.0:
-    resolution: {integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-each@30.4.1:
+    resolution: {integrity: sha512-/8MJbH6fuj48TstjrMf+u/pd06Qezz5xOXvZA6442heNOWr8bdeoGZX2d9fCn028CoMgYmroH9//zky5GfyYmA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-matcher-utils@29.7.0:
-    resolution: {integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-environment-node@30.4.1:
+    resolution: {integrity: sha512-4FZYVOk85hz2AyT6BbarKy9u37g6DbrDyCdFhsnDdXqyrueYQvB+0zO4f/kqLCRD0BsPRXPMNJeQwihKZV8naw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-matcher-utils@30.3.0:
-    resolution: {integrity: sha512-HEtc9uFQgaUHkC7nLSlQL3Tph4Pjxt/yiPvkIrrDCt9jhoLIgxaubo1G+CFOnmHYMxHwwdaSN7mkIFs6ZK8OhA==}
+  jest-haste-map@30.4.1:
+    resolution: {integrity: sha512-rFrcONd8jeFsyw+Z9CrScJgglRf2+NFmNam8dKu7n+SoHqNYT47mn0DdEcVUZJpvh7Iz6/si7f7yUH7GJHVgnw==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-message-util@29.7.0:
-    resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-leak-detector@30.4.1:
+    resolution: {integrity: sha512-IpmyiioeHxiWDhesHnUFmOxcTzwCwKpgACgWajtAP+nYQXiY7DakTxB6Bx9JFiRMljr0AX1PvnQdaU1KFoz6NQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-message-util@30.3.0:
-    resolution: {integrity: sha512-Z/j4Bo+4ySJ+JPJN3b2Qbl9hDq3VrXmnjjGEWD/x0BCXeOXPTV1iZYYzl2X8c1MaCOL+ewMyNBcm88sboE6YWw==}
+  jest-matcher-utils@30.4.1:
+    resolution: {integrity: sha512-zvYfX5CaeEkFrrLS9suWe9rvJrm9J1Iv3ua8kIBv9GEPzcnsfBf0bob37la7s67fs0nlBC3EuvkOLnXQKxtx4A==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-mock@29.7.0:
-    resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-message-util@30.4.1:
+    resolution: {integrity: sha512-kwCKIvq0MCW1HzLoGola9Te6JUdzgV0loyKJ3Qghrkz9i5/RRIHsL95BMQc2HBBhlBKC4j22K9p11TGHH8RBpQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-mock@30.3.0:
-    resolution: {integrity: sha512-OTzICK8CpE+t4ndhKrwlIdbM6Pn8j00lvmSmq5ejiO+KxukbLjgOflKWMn3KE34EZdQm5RqTuKj+5RIEniYhog==}
+  jest-mock@30.4.1:
+    resolution: {integrity: sha512-/i8SVb8/NSB7RfNi8gfqu8gxLV23KaL5EpAttyb9iz8qWRIqXRLflycz/32wXsYkOnaUlx8NAKnJYtpsmXUmfw==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-pnp-resolver@1.2.3:
@@ -4519,57 +4793,49 @@ packages:
       jest-resolve:
         optional: true
 
-  jest-regex-util@29.6.3:
-    resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  jest-regex-util@30.0.1:
-    resolution: {integrity: sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==}
+  jest-regex-util@30.4.0:
+    resolution: {integrity: sha512-mWlvLviKIgIQ8VCuM1xRdD0TWp3zlzionlmDBjuXVBs+VkmXq6FgW9T4Emr7oGz/Rk6feDCGyiugolcQEyp3mg==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-resolve-dependencies@29.7.0:
-    resolution: {integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  jest-resolve@29.7.0:
-    resolution: {integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-resolve-dependencies@30.4.2:
+    resolution: {integrity: sha512-gDiVh1I+GxYzz9oXlyw+1wv6VOYX1WYxMOfjsA3iGKePV2oxmbHhwxfkALxNxYy1ciw6APWwkW2zZONwP97aEQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-runner@29.7.0:
-    resolution: {integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-resolve@30.4.1:
+    resolution: {integrity: sha512-Zry8Yq/yJcNAZ7dJ5F2heic8AheXvbFZ7XI5V+h28nrYZ7Qoyy4dItq8OodjnYD270mvX+ZudmrNV9cysqhW5Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-runtime@29.7.0:
-    resolution: {integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-runner@30.4.2:
+    resolution: {integrity: sha512-2dw0PslVYXxffXGpLo+Ejad+KcI1Qkjn7f4X4619gf21oCUmL+SPfjqIa/losUem3yEOvfNZe/F1HWUcNpODcg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-snapshot@29.7.0:
-    resolution: {integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-runtime@30.4.2:
+    resolution: {integrity: sha512-3/5e8iPz2k/VLqlr8DgTftYyLUv8Su3FkCAO2/Od81UsUTpSxOrS6O5x5KkoQwyUjmpYyDJKeyAvg2T2nvpNkQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-util@29.7.0:
-    resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-snapshot@30.4.1:
+    resolution: {integrity: sha512-tEOkkfOMppUyeiHwjZswOQ3lcnoTnws/q5FnGIaeIh/jmoU0ZlgMYRR8sTlTj+nNGCoJ0RDq6SfxGxCsyMTPmw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-util@30.3.0:
-    resolution: {integrity: sha512-/jZDa00a3Sz7rdyu55NLrQCIrbyIkbBxareejQI315f/i8HjYN+ZWsDLLpoQSiUIEIyZF/R8fDg3BmB8AtHttg==}
+  jest-util@30.4.1:
+    resolution: {integrity: sha512-vjQb1sACEiv13DKJMDToJpzVW0joCsIQrmbg0fi7CyOOt+g9jTuQl2A216pWRBYhOVt53XbL/2LbMKg1BECWOw==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-validate@29.7.0:
-    resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-validate@30.4.1:
+    resolution: {integrity: sha512-PDWi4SOwLnwqNDfHZjOcsEFyZ4fc/2W2gVL3DEoyqnB6jCQMLRtfBong8s6omIw3lI0HWOus12xfnFmQtjW3fw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-watcher@29.7.0:
-    resolution: {integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-watcher@30.4.1:
+    resolution: {integrity: sha512-/l9UonmvCwjHH7d2h3iAwIloLc1H0S8mJZ/LNK3i86hqwPAz8otUJjP9MfYtz9Tt77Su5FD2xGjZn8d31IZHlw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest-worker@29.7.0:
-    resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest-worker@30.4.1:
+    resolution: {integrity: sha512-SHynN/q/QD++iNyvMdy+WMmbCGk8jIsNcRxycXbWubSOhvo6T+j2afcfUSl+3hYsiBebOTo0cT7c2H7CXugu1g==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
-  jest@29.7.0:
-    resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  jest@30.4.2:
+    resolution: {integrity: sha512-Yi1jqNC/Oq0N4hBgNH/YvBpP1P57QqundgytzYqy3yqAa7NZPNjSoi4SGbRAXDMdBzNE6xBCi5U7RgfrvMEUVQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
@@ -4577,13 +4843,20 @@ packages:
       node-notifier:
         optional: true
 
-  jiti@2.6.1:
-    resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
+  jiti@2.7.0:
+    resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==}
     hasBin: true
 
   jju@1.4.0:
     resolution: {integrity: sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==}
 
+  joycon@3.1.1:
+    resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==}
+    engines: {node: '>=10'}
+
+  js-tokens@10.0.0:
+    resolution: {integrity: sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==}
+
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
@@ -4591,8 +4864,8 @@ packages:
     resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
     hasBin: true
 
-  js-yaml@4.1.0:
-    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+  js-yaml@4.2.0:
+    resolution: {integrity: sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==}
     hasBin: true
 
   jsdom@24.1.3:
@@ -4643,8 +4916,8 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
-  jsonfile@6.2.0:
-    resolution: {integrity: sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==}
+  jsonfile@6.2.1:
+    resolution: {integrity: sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==}
 
   jszip@3.10.1:
     resolution: {integrity: sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==}
@@ -4659,10 +4932,6 @@ packages:
     resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
     engines: {node: '>=0.10.0'}
 
-  kleur@3.0.3:
-    resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==}
-    engines: {node: '>=6'}
-
   knuth-shuffle-seeded@1.0.6:
     resolution: {integrity: sha512-9pFH0SplrfyKyojCLxZfMcvkhf5hH0d+UwR9nTVJ/DDQJGuzcXjTwB7TP7sDfehSudlGGaOLblmEWqv04ERVWg==}
 
@@ -4774,21 +5043,25 @@ packages:
   listenercount@1.0.1:
     resolution: {integrity: sha512-3mk/Zag0+IJxeDrxSgaDPy4zZ3w05PRZeJNnlWhzFz5OkX49J4krc+A8X2d2M69vGMBEX0uyl8M+W+8gH+kBqQ==}
 
-  lit-element@4.2.1:
-    resolution: {integrity: sha512-WGAWRGzirAgyphK2urmYOV72tlvnxw7YfyLDgQ+OZnM9vQQBQnumQ7jUJe6unEzwGU3ahFOjuz1iz1jjrpCPuw==}
+  lit-element@4.2.2:
+    resolution: {integrity: sha512-aFKhNToWxoyhkNDmWZwEva2SlQia+jfG0fjIWV//YeTaWrVnOxD89dPKfigCUspXFmjzOEUQpOkejH5Ly6sG0w==}
 
-  lit-html@3.3.1:
-    resolution: {integrity: sha512-S9hbyDu/vs1qNrithiNyeyv64c9yqiW9l+DBgI18fL+MTvOtWoFR0FWiyq1TxaYef5wNlpEmzlXoBlZEO+WjoA==}
+  lit-html@3.3.3:
+    resolution: {integrity: sha512-el8M6jK2o3RXBnrSHX3ZKrsN8zEV63pSExTO1wYJz7QndGYZ8353e2a5PPX+qHe2aGayfnchQmkAojaWAREOIA==}
 
-  lit@3.3.2:
-    resolution: {integrity: sha512-NF9zbsP79l4ao2SNrH3NkfmFgN/hBYSQo90saIVI1o5GpjAdCPVstVzO1MrLOakHoEhYkrtRjPK6Ob521aoYWQ==}
+  lit@3.3.3:
+    resolution: {integrity: sha512-fycuvZg/hkpozL00lm1pEJH5nN/lr9ZXd6mJI2HSN4+Bzc+LDNdEApJ6HFbPkdFNHLvOplIIuJvxkS4XUxqirw==}
 
   load-json-file@4.0.0:
     resolution: {integrity: sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==}
     engines: {node: '>=4'}
 
-  local-pkg@1.1.2:
-    resolution: {integrity: sha512-arhlxbFRmoQHl33a0Zkle/YWlmNwoyt6QNZEIJcqNbdrsix5Lvc4HyyI3EnwxTYlZYc32EbYrQ8SzEZ7dqgg9A==}
+  load-tsconfig@0.2.5:
+    resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  local-pkg@1.2.1:
+    resolution: {integrity: sha512-++gUqRDEvcnN6Zhqrr+y/CkVEHhlrR96vZn3nZZPYzMcBUyBtTKzB9NadClFIsIVSsu+3i9tfk/erqy9kAmt7Q==}
     engines: {node: '>=14'}
 
   locate-app@2.5.0:
@@ -4845,9 +5118,6 @@ packages:
   lodash.zip@4.2.0:
     resolution: {integrity: sha512-C7IOaBBK/0gMORRBd8OETNx3kmOkgIWIPvyDpZSCTwUrpYmgZwJkjZeOD8ww4xbOUOs4/attY+pciKvadNfFbg==}
 
-  lodash@4.17.21:
-    resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
-
   lodash@4.18.1:
     resolution: {integrity: sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==}
 
@@ -4865,17 +5135,14 @@ packages:
   loupe@2.3.7:
     resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==}
 
-  loupe@3.2.1:
-    resolution: {integrity: sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==}
-
   lower-case@2.0.2:
     resolution: {integrity: sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==}
 
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
-  lru-cache@11.3.2:
-    resolution: {integrity: sha512-wgWa6FWQ3QRRJbIjbsldRJZxdxYngT/dO0I5Ynmlnin8qy7tC6xYzbcJjtN4wHLXtkbVwHzk0C+OejVw1XM+DQ==}
+  lru-cache@11.5.1:
+    resolution: {integrity: sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==}
     engines: {node: 20 || >=22}
 
   lru-cache@5.1.1:
@@ -4893,13 +5160,16 @@ packages:
     resolution: {integrity: sha512-QrwPArQCNLAKGO/C+ZIilgIuDnEnKx5QYODdDtbFaxzsbZcc/a7WFq7MhsVYgRlwawLtvOUESTlfJ+hc/USqPg==}
     engines: {node: '>=12'}
 
-  luxon@3.6.1:
-    resolution: {integrity: sha512-tJLxrKJhO2ukZ5z0gyjY1zPh3Rh88Ej9P7jNrZiHMUXHae1yvI2imgOZtL1TO8TW6biMMKfTtAOoEJANgtWBMQ==}
+  luxon@3.7.2:
+    resolution: {integrity: sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==}
     engines: {node: '>=12'}
 
   magic-string@0.30.21:
     resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
 
+  magicast@0.5.3:
+    resolution: {integrity: sha512-pVKE4UdSQ7DvHzivsCIFx2BJn1mHG6KsyrFcaxFx6tONdneEuThrDx0Cj3AMg58KyN4pzYT+LHOotxDQDjNvkw==}
+
   make-dir@4.0.0:
     resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
     engines: {node: '>=10'}
@@ -4959,17 +5229,14 @@ packages:
     resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
     engines: {node: '>=6'}
 
-  minimatch@10.0.3:
-    resolution: {integrity: sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw==}
-    engines: {node: 20 || >=22}
+  minimatch@10.2.3:
+    resolution: {integrity: sha512-Rwi3pnapEqirPSbWbrZaa6N3nmqq4Xer/2XooiOKyV3q12ML06f7MOuc5DVH8ONZIFhwIYQ3yzPH4nt7iWHaTg==}
+    engines: {node: 18 || 20 || >=22}
 
   minimatch@10.2.5:
     resolution: {integrity: sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==}
     engines: {node: 18 || 20 || >=22}
 
-  minimatch@3.1.2:
-    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
-
   minimatch@3.1.5:
     resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
 
@@ -5006,14 +5273,24 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
-  mlly@1.8.0:
-    resolution: {integrity: sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==}
+  mkdirp@3.0.1:
+    resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  mlly@1.8.2:
+    resolution: {integrity: sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA==}
 
   mocha@10.8.2:
     resolution: {integrity: sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==}
     engines: {node: '>= 14.0.0'}
     hasBin: true
 
+  mocha@11.7.6:
+    resolution: {integrity: sha512-nS9xOGbw2I3cjCpxwZAEJ9xK9lmJ08vEkQvLtz4du9ZrF9UrjRpeJGiIgl2Z+Qs++pmB4ecDe48Fwsh+j+j7xA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    hasBin: true
+
   modern-tar@0.7.6:
     resolution: {integrity: sha512-sweCIVXzx1aIGTCdzcMlSZt1h8k5Tmk08VNAuRk3IU28XamGiOH5ypi11g6De2CH7PhYqSSnGy2A/EFhbWnVKg==}
     engines: {node: '>=18.0.0'}
@@ -5028,9 +5305,6 @@ packages:
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
-  muggle-string@0.4.1:
-    resolution: {integrity: sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==}
-
   mute-stream@2.0.0:
     resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -5038,27 +5312,32 @@ packages:
   mz@2.7.0:
     resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
 
-  nanoid@3.3.11:
-    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+  nanoid@3.3.12:
+    resolution: {integrity: sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
+  napi-postinstall@0.3.4:
+    resolution: {integrity: sha512-PHI5f1O0EP5xJ9gQmFGMS6IZcrVvTjpXjz7Na41gTE7eE2hK11lg04CECCYEEjdc17EV4DO+fkGEtt7TpTaTiQ==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
+    hasBin: true
+
   natural-compare@1.4.0:
     resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
 
-  netmask@2.0.2:
-    resolution: {integrity: sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==}
+  netmask@2.1.1:
+    resolution: {integrity: sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA==}
     engines: {node: '>= 0.4.0'}
 
   nice-try@1.0.5:
     resolution: {integrity: sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==}
 
-  nightwatch-axe-verbose@2.4.0:
-    resolution: {integrity: sha512-ZWSygayLjyDNvkrL4LjfeBhCXCA5yRQ7Gf9ZkNVPba8VzBe/pa4yYuWgpMV+59uZpa+hMcGz7drTpRzT0RI/gw==}
+  nightwatch-axe-verbose@2.5.1:
+    resolution: {integrity: sha512-vvLUMyIbGHB8CA5XEGfliPstNCplcHeMn/CWi4cyg0CWMqWypGrV2IgP+WmiWpUgs0qvPmqVHeRHf0BTT7Ez2Q==}
 
-  nightwatch@3.15.0:
-    resolution: {integrity: sha512-Vvh7TsDyEN1YzOsDNoafEUPJDQ6jfnmJPAsWo/EmygljZiRk1Ja/pEqNAhE5UdYJzF38SNO46gJS8IRk9mUNfA==}
-    engines: {node: '>= 16'}
+  nightwatch@3.16.0:
+    resolution: {integrity: sha512-B0/zFPY5ujEwIWIPqo2ClgITZ3chB3Nfq86YNWCyE3/P8BrCSvv2Y6BNUA+9mgu8WM/XF6GNlV3LONzZ1S+JSQ==}
+    engines: {node: '>= 18.20.5'}
     hasBin: true
     peerDependencies:
       '@cucumber/cucumber': '*'
@@ -5080,6 +5359,10 @@ packages:
     engines: {node: '>=10.5.0'}
     deprecated: Use your platform's native DOMException instead
 
+  node-exports-info@1.6.0:
+    resolution: {integrity: sha512-pyFS63ptit/P5WqUkt+UUfe+4oevH+bFeIiPPdfb0pFeYEu/1ELnJu5l+5EcTKYL5M7zaAa7S8ddywgXypqKCw==}
+    engines: {node: '>= 0.4'}
+
   node-fetch@2.7.0:
     resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
     engines: {node: 4.x || >=6.0.0}
@@ -5096,11 +5379,9 @@ packages:
   node-int64@0.4.0:
     resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
 
-  node-releases@2.0.26:
-    resolution: {integrity: sha512-S2M9YimhSjBSvYnlr5/+umAnPHE++ODwt5e2Ij6FoX45HA/s4vHdkDx1eax2pAPeAOqu4s9b7ppahsyEFdVqQA==}
-
-  node-releases@2.0.37:
-    resolution: {integrity: sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==}
+  node-releases@2.0.47:
+    resolution: {integrity: sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==}
+    engines: {node: '>=18'}
 
   nodemon@3.1.14:
     resolution: {integrity: sha512-jakjZi93UtB3jHMWsXL68FXSAosbLfY0In5gtKq3niLSkrWznrVBzXFNOEMJUfc9+Ke7SHWoAZsiMkNP3vq6Jw==}
@@ -5118,14 +5399,14 @@ packages:
     resolution: {integrity: sha512-linxNAT6M0ebEYZOx2tO6vBEFsVgnPpv+AVjk0wJHfaUIbq31Jm3T6vvZaarnOeWDh8ShnwXuaAyM7WT3RzErA==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  normalize-package-data@8.0.0:
+    resolution: {integrity: sha512-RWk+PI433eESQ7ounYxIp67CYuVsS1uYSonX3kA6ps/3LWfjVQa/ptEg6Y3T6uAMq1mWpX9PQ+qx+QaHpsc7gQ==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
   normalize-path@3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
 
-  normalize-range@0.1.2:
-    resolution: {integrity: sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==}
-    engines: {node: '>=0.10.0'}
-
   npm-run-all@4.1.5:
     resolution: {integrity: sha512-Oo82gJDAVcaMdi3nuoKFavkIHBRVqQ1qvMb+9LHk/cF4P6B2m8aP04hGf7oL6wZ9BuGwX1onlLhpuoofSyoQDQ==}
     engines: {node: '>= 4'}
@@ -5165,6 +5446,10 @@ packages:
     resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==}
     engines: {node: '>= 0.4'}
 
+  object.entries@1.1.9:
+    resolution: {integrity: sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==}
+    engines: {node: '>= 0.4'}
+
   object.fromentries@2.0.8:
     resolution: {integrity: sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==}
     engines: {node: '>= 0.4'}
@@ -5256,8 +5541,8 @@ packages:
   package-json-from-dist@1.0.1:
     resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
 
-  package-manager-detector@1.5.0:
-    resolution: {integrity: sha512-uBj69dVlYe/+wxj8JOpr97XfsxH/eumMt6HqjNTmJDf/6NO9s+0uxeOneIz3AsPt2m6y9PqzDzd3ATcU17MNfw==}
+  package-manager-detector@1.6.0:
+    resolution: {integrity: sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==}
 
   pad-right@0.2.2:
     resolution: {integrity: sha512-4cy8M95ioIGolCoMmm2cMntGR1lPLEbOMzOKu8bzjuJP6JpzEMQcDHmh7hHLYGgob+nKe1YHFMaG4V59HQa89g==}
@@ -5299,8 +5584,8 @@ packages:
   parse5@7.3.0:
     resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
 
-  parse5@8.0.0:
-    resolution: {integrity: sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==}
+  parse5@8.0.1:
+    resolution: {integrity: sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==}
 
   path-browserify@1.0.1:
     resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==}
@@ -5313,8 +5598,8 @@ packages:
     resolution: {integrity: sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
-  path-expression-matcher@1.4.0:
-    resolution: {integrity: sha512-s4DQMxIdhj3jLFWd9LxHOplj4p9yQ4ffMGowFf3cpEgrrJjEhN0V5nxw4Ye1EViAGDoL4/1AeO6qHpqYPOzE4Q==}
+  path-expression-matcher@1.5.0:
+    resolution: {integrity: sha512-cbrerZV+6rvdQrrD+iGMcZFEiiSrbv9Tfdkvnusy6y0x0GKBXREFg/Y65GhIfm0tnLntThhzCnfKwp1WRjeCyQ==}
     engines: {node: '>=14.0.0'}
 
   path-is-absolute@1.0.1:
@@ -5357,10 +5642,6 @@ packages:
   pathval@1.1.1:
     resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}
 
-  pathval@2.0.1:
-    resolution: {integrity: sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==}
-    engines: {node: '>= 14.16'}
-
   pend@1.2.0:
     resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
 
@@ -5412,8 +5693,8 @@ packages:
   pkg-types@1.3.1:
     resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}
 
-  pkg-types@2.3.0:
-    resolution: {integrity: sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==}
+  pkg-types@2.3.1:
+    resolution: {integrity: sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==}
 
   placeholder-loading@0.7.0:
     resolution: {integrity: sha512-C9M9dra5nZF/qfFF0trA3dZTQ2j6qxxoAnqWcyF+bKWhoTQIiCYIptj9BTTuihdQjm9M/vIbbYtTEvvT+8etEg==}
@@ -5475,16 +5756,12 @@ packages:
   postcss-value-parser@4.2.0:
     resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
 
-  postcss@8.5.6:
-    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+  postcss@8.5.15:
+    resolution: {integrity: sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==}
     engines: {node: ^10 || ^12 || >=14}
 
-  postcss@8.5.9:
-    resolution: {integrity: sha512-7a70Nsot+EMX9fFU3064K/kdHWZqGVY+BADLyXc8Dfv+mTLLVl6JzJpPaCZ2kQL9gIJvKXSLMHhqdRRjwQeFtw==}
-    engines: {node: ^10 || ^12 || >=14}
-
-  preact@10.29.1:
-    resolution: {integrity: sha512-gQCLc/vWroE8lIpleXtdJhTFDogTdZG9AjMUpVkDf2iTCNwYNWA+u16dL41TqUDJO4gm2IgrcMv3uTpjd4Pwmg==}
+  preact@10.29.2:
+    resolution: {integrity: sha512-7tNmwg/7mzzAoB/8kSg6Hl37JraAZw3Z3A0JSY7VXlZwo82Xn0G7wKbNNs2qoF4ZEEsQGTwDAroNdqKs1ofJxQ==}
 
   prelude-ls@1.2.1:
     resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
@@ -5494,17 +5771,13 @@ packages:
     resolution: {integrity: sha512-SxToR7P8Y2lWmv/kTzVLC1t/GDI2WGjMwNhLLE9qtH8Q13C+aEmuRlzDst4Up4s0Wc8sF2M+J57iB3cMLqftfg==}
     engines: {node: '>=6.0.0'}
 
-  prettier@3.8.1:
-    resolution: {integrity: sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==}
+  prettier@3.8.3:
+    resolution: {integrity: sha512-7igPTM53cGHMW8xWuVTydi2KO233VFiTNyF5hLJqpilHfmn8C8gPf+PS7dUT64YcXFbiMGZxS9pCSxL/Dxm/Jw==}
     engines: {node: '>=14'}
     hasBin: true
 
-  pretty-format@29.7.0:
-    resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
-  pretty-format@30.3.0:
-    resolution: {integrity: sha512-oG4T3wCbfeuvljnyAzhBvpN45E8iOTXCU/TD3zXW80HA3dQ4ahdqMkWGiPWZvjpQwlbyHrPTWUAqUzGzv4l1JQ==}
+  pretty-format@30.4.1:
+    resolution: {integrity: sha512-K6KiKMHTL4jjX4u3Kir2EW07nRfcqVTXIImx50wbjHQTcZPgg+gjVeNTIT3l3L1Rd4UefxfogquC9J37SoFyyw==}
     engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   pretty-ms@9.3.0:
@@ -5528,10 +5801,6 @@ packages:
     resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
     engines: {node: '>=0.4.0'}
 
-  prompts@2.4.2:
-    resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
-    engines: {node: '>= 6'}
-
   property-expr@2.0.6:
     resolution: {integrity: sha512-SVtmxhRE/CGkn3eZY1T6pC8Nln6Fr/lu1mKSgRud0eC73whjGfoAogbn78LkD8aFL0zz3bAFerKSnOl7NlErBA==}
 
@@ -5571,11 +5840,11 @@ packages:
     resolution: {integrity: sha512-ArbnyA3U5SGHokEvkfWjW+O8hOxV1RSJxOgriX/3A4xZRqixt9ZFHD0yPgZQF05Qj0oAqi8H/7stDorjoHY90Q==}
     engines: {node: '>=16.13.2'}
 
-  pure-rand@6.1.0:
-    resolution: {integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==}
+  pure-rand@7.0.1:
+    resolution: {integrity: sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==}
 
-  qified@0.9.1:
-    resolution: {integrity: sha512-n7mar4T0xQ+39dE2vGTAlbxUEpndwPANH0kDef1/MYsB8Bba9wshkybIRx74qgcvKQPEWErf9AqAdYjhzY2Ilg==}
+  qified@0.10.1:
+    resolution: {integrity: sha512-+Owyggi9IxT1ePKGafcI87ubSmxol6smwJ+RAHDQlx9+9cPwFWDiKFFCPuWhr9ignlGpZ9vDQLw67N4dcTVFEA==}
     engines: {node: '>=20'}
 
   quansync@0.2.11:
@@ -5602,12 +5871,15 @@ packages:
   react-is@18.3.1:
     resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
 
+  react-is@19.2.7:
+    resolution: {integrity: sha512-kZFnouyVv7eP/Phmrlo9FK+zcAdriZJvzxXHF1Sl1P377WSGe2G/JxVolhTrB/jeV47lKImhNUsijjHAAbcl/A==}
+
   read-cache@1.0.0:
     resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==}
 
-  read-package-up@11.0.0:
-    resolution: {integrity: sha512-MbgfoNPANMdb4oRBNg5eqLbB2t2r+o5Ua1pNt8BqGp4I0FJZhuVSOj3PaBPni4azWuSzEdNn2evevzVmEk1ohQ==}
-    engines: {node: '>=18'}
+  read-package-up@12.0.0:
+    resolution: {integrity: sha512-Q5hMVBYur/eQNWDdbF4/Wqqr9Bjvtrw2kjGxxBbKLbx8bVCL8gcArjTy8zDUuLGQicftpMuU0riQNcAsbtOVsw==}
+    engines: {node: '>=20'}
 
   read-pkg-up@10.1.0:
     resolution: {integrity: sha512-aNtBq4jR8NawpKJQldrQcSW9y/d+KWH4v24HWkHljOZ7H0av+YTGANBzRh9A5pw7v/bLVsLVPpOhJ7gHNVy8lA==}
@@ -5617,6 +5889,10 @@ packages:
     resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==}
     engines: {node: '>=8'}
 
+  read-pkg@10.1.0:
+    resolution: {integrity: sha512-I8g2lArQiP78ll51UeMZojewtYgIRCKCWqZEgOO8c/uefTI+XDXvCSXu3+YNUaTNvZzobrL5+SqHjBrByRRTdg==}
+    engines: {node: '>=20'}
+
   read-pkg@3.0.0:
     resolution: {integrity: sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==}
     engines: {node: '>=4'}
@@ -5629,10 +5905,6 @@ packages:
     resolution: {integrity: sha512-PORM8AgzXeskHO/WEv312k9U03B8K9JSiWF/8N9sUuFjBa+9SF2u6K7VClzXwDXab51jCd8Nd36CNM+zR97ScQ==}
     engines: {node: '>=16'}
 
-  read-pkg@9.0.1:
-    resolution: {integrity: sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==}
-    engines: {node: '>=18'}
-
   readable-stream@2.3.8:
     resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
 
@@ -5659,6 +5931,9 @@ packages:
     resolution: {integrity: sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==}
     engines: {node: '>= 12.13.0'}
 
+  real-require@1.0.0:
+    resolution: {integrity: sha512-P4nbQYQfePJxRSmY+v/KINxVucm4NF3p3s7pJveMTtom52FR4YGltUQLB8idDXwDDWW+eYrWDFbuzUnjoWHF7g==}
+
   recursive-readdir@2.2.3:
     resolution: {integrity: sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==}
     engines: {node: '>=6.0.0'}
@@ -5685,8 +5960,8 @@ packages:
     resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==}
     engines: {node: '>= 0.4'}
 
-  regjsparser@0.13.0:
-    resolution: {integrity: sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==}
+  regjsparser@0.13.1:
+    resolution: {integrity: sha512-dLsljMd9sqwRkby8zhO1gSg3PnJIBFid8f4CQj/sXx+7cKx+E7u0PKhZ+U4wmhx7EfmtvnA318oVaIkAB1lRJw==}
     hasBin: true
 
   repeat-string@1.6.1:
@@ -5716,19 +5991,17 @@ packages:
     resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
     engines: {node: '>=8'}
 
-  resolve-pkg-maps@1.0.0:
-    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
-
   resolve-pkg@2.0.0:
     resolution: {integrity: sha512-+1lzwXehGCXSeryaISr6WujZzowloigEofRB+dj75y9RRa/obVcYgbHJd53tdYw8pvZj8GojXaaENws8Ktw/hQ==}
     engines: {node: '>=8'}
 
-  resolve.exports@2.0.3:
-    resolution: {integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==}
-    engines: {node: '>=10'}
+  resolve@1.22.12:
+    resolution: {integrity: sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==}
+    engines: {node: '>= 0.4'}
+    hasBin: true
 
-  resolve@1.22.11:
-    resolution: {integrity: sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==}
+  resolve@2.0.0-next.7:
+    resolution: {integrity: sha512-tqt+NBWwyaMgw3zDsnygx4CByWjQEJHOPMdslYhppaQSJUtL/D4JO9CcBBlhPoI8lz9oJIDXkwXfhF4aWqP8xQ==}
     engines: {node: '>= 0.4'}
     hasBin: true
 
@@ -5758,13 +6031,13 @@ packages:
     deprecated: Rimraf versions prior to v4 are no longer supported
     hasBin: true
 
-  rolldown@1.0.0-rc.13:
-    resolution: {integrity: sha512-bvVj8YJmf0rq4pSFmH7laLa6pYrhghv3PRzrCdRAr23g66zOKVJ4wkvFtgohtPLWmthgg8/rkaqRHrpUEh0Zbw==}
+  rolldown@1.0.3:
+    resolution: {integrity: sha512-i00lAJ2ks1BYr7rjNjKC7BcqAS7nVfiT3QX1SI5aY+AFHblCmaUf9OE9dbdzDvW6dJxbi2ZCZiy9v3CcwOiX3g==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
 
-  rollup@4.60.1:
-    resolution: {integrity: sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==}
+  rollup@4.61.0:
+    resolution: {integrity: sha512-T9mWdbWfQtp0B5lv/HX+wrhYsmXRlcWnXXmJbXqKJhlRaoS6KMhq0gpyzW4UJfclcxrEdLnTgjT2NjruLONu0g==}
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
     hasBin: true
 
@@ -5791,8 +6064,8 @@ packages:
     resolution: {integrity: sha512-jkg4434cYgtrIF2AeY/X0Wmd2W73cK5qIEFE3hDrrQenJH/2SDJIXGvPAigfvQTcE9+H31zkiNHbUqcihEiMRA==}
     engines: {node: '>=18.0.0'}
 
-  safe-array-concat@1.1.3:
-    resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==}
+  safe-array-concat@1.1.4:
+    resolution: {integrity: sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg==}
     engines: {node: '>=0.4'}
 
   safe-buffer@5.1.2:
@@ -5809,13 +6082,13 @@ packages:
     resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
     engines: {node: '>= 0.4'}
 
-  safe-regex2@5.0.0:
-    resolution: {integrity: sha512-YwJwe5a51WlK7KbOJREPdjNrpViQBI3p4T50lfwPuDhZnE3XGVTlGvi+aolc5+RvxDD6bnUmjVsU9n1eboLUYw==}
-
-  safe-regex2@5.1.0:
-    resolution: {integrity: sha512-pNHAuBW7TrcleFHsxBr5QMi/Iyp0ENjUKz7GCcX1UO7cMh+NmVK6HxQckNL1tJp1XAJVjG6B8OKIPqodqj9rtw==}
+  safe-regex2@5.1.1:
+    resolution: {integrity: sha512-mOSBvHGDZMuIEZMdOz/aCEYDCv0E7nfcNsIhUF+/P+xC7Hyf3FkvymqgPbg9D1EdSGu+uKbJgy09K/RKKc7kJA==}
     hasBin: true
 
+  safe-regex@2.1.1:
+    resolution: {integrity: sha512-rx+x8AMzKb5Q5lQ95Zoi6ZbJqwCLkqi3XuJXp5P3rT8OEc6sZCJG5AE5dU3lsgRr/F4Bs31jSlVN+j5KrsGu9A==}
+
   safe-stable-stringify@2.5.0:
     resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
     engines: {node: '>=10'}
@@ -5837,6 +6110,10 @@ packages:
     resolution: {integrity: sha512-LkTJrNz5socxpPnWPODQ2bQ65eYx9JK+DQMYNihpTjMCqHwgWGYQnQTCAAche2W3ZP87alA+1zYPvgS8tHNzMQ==}
     engines: {node: '>= 14.21.0'}
 
+  selenium-webdriver@4.44.0:
+    resolution: {integrity: sha512-7RbYoKK0zET+KMVak11UDCtKvNulOU6gFZp8HI5GN9K8+BhqrliIJU/FP6QADrvRAXFMr3wHxfE3JHOcAxO3GQ==}
+    engines: {node: '>= 20.0.0'}
+
   semver@5.7.2:
     resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
     hasBin: true
@@ -5855,18 +6132,13 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
-  semver@7.7.1:
-    resolution: {integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==}
-    engines: {node: '>=10'}
-    hasBin: true
-
-  semver@7.7.3:
-    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
+  semver@7.7.4:
+    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
     engines: {node: '>=10'}
     hasBin: true
 
-  semver@7.7.4:
-    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
+  semver@7.8.1:
+    resolution: {integrity: sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -5914,12 +6186,12 @@ packages:
     resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
     engines: {node: '>=8'}
 
-  shell-quote@1.8.3:
-    resolution: {integrity: sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==}
+  shell-quote@1.8.4:
+    resolution: {integrity: sha512-VsC6n6vz1ihYYyZZwX7YZSF5l5x36ca17OC+a69h94YqB7X6XLwf+5MOgynYir2SLFUbl8gIYvBo8K8RoNQ6bQ==}
     engines: {node: '>= 0.4'}
 
-  side-channel-list@1.0.0:
-    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+  side-channel-list@1.0.1:
+    resolution: {integrity: sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==}
     engines: {node: '>= 0.4'}
 
   side-channel-map@1.0.1:
@@ -5952,9 +6224,6 @@ packages:
     resolution: {integrity: sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==}
     engines: {node: '>=18'}
 
-  sisteransi@1.0.5:
-    resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
-
   slash@3.0.0:
     resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
     engines: {node: '>=8'}
@@ -5979,8 +6248,8 @@ packages:
     resolution: {integrity: sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==}
     engines: {node: '>= 14'}
 
-  socks@2.8.7:
-    resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
+  socks@2.8.9:
+    resolution: {integrity: sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw==}
     engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
 
   sonic-boom@4.2.1:
@@ -6000,6 +6269,10 @@ packages:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
+  source-map@0.7.6:
+    resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
+    engines: {node: '>= 12'}
+
   spacetrim@0.11.59:
     resolution: {integrity: sha512-lLYsktklSRKprreOm7NXReW8YiX2VBjbgmXYEziOoGf/qsJqAEACaDvoTtUOycwjpaSh+bT8eu0KrJn7UNxiCg==}
 
@@ -6022,9 +6295,9 @@ packages:
   sprintf-js@1.0.3:
     resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
 
-  stack-trace@1.0.0-pre2:
-    resolution: {integrity: sha512-2ztBJRek8IVofG9DBJqdy2N5kulaacX30Nz7xmkYF6ale9WBVmIy6mFBchvGX7Vx/MyjBhx+Rcxqrj+dbOnQ6A==}
-    engines: {node: '>=16'}
+  stack-trace@1.0.0:
+    resolution: {integrity: sha512-H6D7134xi6qONvh7ZHKgviXf+rd3vhGBSvebPZCaUkd8zvQ+7PtDw6CljPTe4cXWNf2IKZGNqw6VJXSb9IgBpA==}
+    engines: {node: '>=20.0.0'}
 
   stack-utils@2.0.6:
     resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
@@ -6048,11 +6321,8 @@ packages:
     resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
     engines: {node: '>= 0.8'}
 
-  std-env@3.10.0:
-    resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
-
-  std-env@4.0.0:
-    resolution: {integrity: sha512-zUMPtQ/HBY3/50VbpkupYHbRroTRZJPRLvreamgErJVys0ceuzMkD44J/QjqhHjOzK42GQ3QZIeFG1OYfOtKqQ==}
+  std-env@4.1.0:
+    resolution: {integrity: sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==}
 
   stop-iteration-iterator@1.1.0:
     resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==}
@@ -6065,8 +6335,8 @@ packages:
   stream-shift@1.0.3:
     resolution: {integrity: sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ==}
 
-  streamx@2.25.0:
-    resolution: {integrity: sha512-0nQuG6jf1w+wddNEEXCF4nTg3LtufWINB5eFEN+5TNZW7KWJp6x87+JFL43vaAUPyCfH1wID+mNVyW6OHtFamg==}
+  streamx@2.26.0:
+    resolution: {integrity: sha512-VvNG1K72Po/xwJzxZFnZ++Tbrv4lwSptsbkFuzXCJAYZvCK5nnxsvXU6ajqkv7chyiI1Y0YXq2Jh8Iy8Y7NF/A==}
 
   string-argv@0.3.1:
     resolution: {integrity: sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==}
@@ -6088,8 +6358,8 @@ packages:
     resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
     engines: {node: '>=12'}
 
-  string-width@8.2.0:
-    resolution: {integrity: sha512-6hJPQ8N0V0P3SNmP6h2J99RLuzrWz2gvT7VnK5tKvrNqJoyS9W4/Fb8mo31UiPvy00z7DQXkP2hnKBVav76thw==}
+  string-width@8.2.1:
+    resolution: {integrity: sha512-IIaP0g3iy9Cyy18w3M9YcaDudujEAVHKt3a3QJg1+sr/oX96TbaGUubG0hJyCjCBThFH+tFpcIyoUHUn1ogaLA==}
     engines: {node: '>=20'}
 
   string.prototype.padend@3.1.6:
@@ -6118,10 +6388,6 @@ packages:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
 
-  strip-ansi@7.1.2:
-    resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==}
-    engines: {node: '>=12'}
-
   strip-ansi@7.2.0:
     resolution: {integrity: sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==}
     engines: {node: '>=12'}
@@ -6153,8 +6419,8 @@ packages:
   strnum@1.1.2:
     resolution: {integrity: sha512-vrN+B7DBIoTTZjnPNewwhx6cBA/H+IS7rfW68n7XxC1y7uoiGQBxaKzqucGUgavX15dJgiGztLJ8vxuEzwqBdA==}
 
-  strnum@2.2.3:
-    resolution: {integrity: sha512-oKx6RUCuHfT3oyVjtnrmn19H1SiCqgJSg+54XqURKp5aCMbrXrhLjRN9TjuwMjiYstZ0MzDrHqkGZ5dFTKd+zg==}
+  strnum@2.3.0:
+    resolution: {integrity: sha512-ums3KNd42PGyx5xaoVTO1mjU1bH3NpY4vsrVlnv9PNGqQj8wd7rJ6nEypLrJ7z5vxK5RP0yMLo6J/Gsm62DI5Q==}
 
   style-mod@4.1.3:
     resolution: {integrity: sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==}
@@ -6171,11 +6437,16 @@ packages:
       stylelint: '>=13.13.1'
       tailwindcss: '>=2.2.16'
 
-  stylelint@17.6.0:
-    resolution: {integrity: sha512-tokrsMIVAR9vAQ/q3UVEr7S0dGXCi7zkCezPRnS2kqPUulvUh5Vgfwngrk4EoAoW7wnrThqTdnTFN5Ra7CaxIg==}
+  stylelint@17.12.0:
+    resolution: {integrity: sha512-KIlzWXMHUvgfPUR0R7TK3H80yCIi0uoivUwf+6Az4yrHJD1Q3c1qIkh/H5Z0i/K3QXgtq/UMEkWyBUSUwnpnOg==}
     engines: {node: '>=20.19.0'}
     hasBin: true
 
+  sucrase@3.35.1:
+    resolution: {integrity: sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    hasBin: true
+
   supports-color@10.2.2:
     resolution: {integrity: sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g==}
     engines: {node: '>=18'}
@@ -6206,19 +6477,23 @@ packages:
   symbol-tree@3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
-  synckit@0.11.12:
-    resolution: {integrity: sha512-Bh7QjT8/SuKUIfObSXNHNSK6WHo6J1tHCqJsuaFDP7gP0fkzSfTxI8y85JrppZ0h8l0maIgc2tfuZQ6/t3GtnQ==}
+  synckit@0.11.13:
+    resolution: {integrity: sha512-eNRKgb3z66Yp3D2CixVujOUvXLFUTij/zVnV8KRyvFdQwpz7I5DS8UfRkTeLzb64u+dkzDSdelE24izu+zSSUg==}
     engines: {node: ^14.18.0 || >=16.0.0}
 
   table@6.9.0:
     resolution: {integrity: sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==}
     engines: {node: '>=10.0.0'}
 
-  tailwindcss@4.2.2:
-    resolution: {integrity: sha512-KWBIxs1Xb6NoLdMVqhbhgwZf2PGBpPEiwOqgI4pFIYbNTfBXiKYyWoTsXgBQ9WFg/OlhnvHaY+AEpW7wSmFo2Q==}
+  tagged-tag@1.0.0:
+    resolution: {integrity: sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==}
+    engines: {node: '>=20'}
+
+  tailwindcss@4.3.0:
+    resolution: {integrity: sha512-y6nxMGB1nMW9R6k96e5gdIFzcfL/gTJRNaqGes1YvkLnPVXzWgbqFF2yLC0T8G774n24cx3Pe8XrKoniCOAH+Q==}
 
-  tapable@2.3.2:
-    resolution: {integrity: sha512-1MOpMXuhGzGL5TTCZFItxCc0AARf1EZFQkGqMm7ERKj8+Hgr5oLvJOVFcC+lRmR8hCe2S3jC4T5D7Vg/d7/fhA==}
+  tapable@2.3.3:
+    resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==}
     engines: {node: '>=6'}
 
   tar-fs@3.0.4:
@@ -6231,8 +6506,8 @@ packages:
     resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
     engines: {node: '>=6'}
 
-  tar-stream@3.1.8:
-    resolution: {integrity: sha512-U6QpVRyCGHva435KoNWy9PRoi2IFYCgtEhq9nmrPPpbRacPs9IH4aJ3gbrFC8dPcXvdSZ4XXfXT5Fshbp2MtlQ==}
+  tar-stream@3.2.0:
+    resolution: {integrity: sha512-ojzvCvVaNp6aOTFmG7jaRD0meowIAuPc3cMMhSgKiVWws1GyHbGd/xvnyuRKcKlMpt3qvxx6r0hreCNITP9hIg==}
 
   tcp-port-used@1.0.2:
     resolution: {integrity: sha512-l7ar8lLUD3XS1V2lfoJlCBaeoaWo/2xfYt81hM7VlvR4RrMVFqfmzfhLVk40hAb368uitje5gPtBRL1m/DGvLA==}
@@ -6254,8 +6529,8 @@ packages:
   thenify@3.3.1:
     resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
 
-  thread-stream@4.0.0:
-    resolution: {integrity: sha512-4iMVL6HAINXWf1ZKZjIPcz5wYaOdPhtO8ATvZ+Xqp3BTdaqtAwQkNmKORqcIo5YkQqGXq5cwfswDwMqqQNrpJA==}
+  thread-stream@4.2.0:
+    resolution: {integrity: sha512-e2zZ96wSChazBsbENf/Pcm/4swHt2cEKQ92rhUjkL9GCKiTDJIaTBenjE/m9DXi0QBmTMDkFDdOomUy20A1tDQ==}
     engines: {node: '>=20'}
 
   through@2.3.8:
@@ -6270,18 +6545,14 @@ packages:
   tinyexec@0.3.2:
     resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
 
-  tinyexec@1.1.1:
-    resolution: {integrity: sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==}
+  tinyexec@1.2.4:
+    resolution: {integrity: sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==}
     engines: {node: '>=18'}
 
-  tinyglobby@0.2.16:
-    resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
+  tinyglobby@0.2.17:
+    resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
     engines: {node: '>=12.0.0'}
 
-  tinypool@1.1.1:
-    resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==}
-    engines: {node: ^18.0.0 || >=20.0.0}
-
   tinyrainbow@1.2.0:
     resolution: {integrity: sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==}
     engines: {node: '>=14.0.0'}
@@ -6290,14 +6561,14 @@ packages:
     resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
     engines: {node: '>=14.0.0'}
 
-  tinyspy@3.0.2:
-    resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==}
-    engines: {node: '>=14.0.0'}
-
   tmp@0.2.3:
     resolution: {integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==}
     engines: {node: '>=14.14'}
 
+  tmp@0.2.7:
+    resolution: {integrity: sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw==}
+    engines: {node: '>=14.14'}
+
   tmpl@1.0.5:
     resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==}
 
@@ -6305,9 +6576,9 @@ packages:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
 
-  toad-cache@3.7.0:
-    resolution: {integrity: sha512-/m8M+2BJUpoJdgAHoG+baCwBT+tf2VraSfkBgl0Y00qIWt41DJ8R5B8nsEw0I58YwF5IZH6z24/2TobDKnqSWw==}
-    engines: {node: '>=12'}
+  toad-cache@3.7.1:
+    resolution: {integrity: sha512-5DXWzE4Vz7xNHsv+xQ+MGfJYyC78Aok3tEr0MNwHoRf7vZnga1mQXZ4/Nsodld4VR6Wd+VhfmqnNrsRJyYPfrQ==}
+    engines: {node: '>=20'}
 
   toidentifier@1.0.1:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
@@ -6348,13 +6619,16 @@ packages:
     peerDependencies:
       typescript: '>=4.8.4'
 
+  ts-interface-checker@0.1.13:
+    resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
+
   ts-node@10.9.2:
     resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==}
     hasBin: true
     peerDependencies:
       '@swc/core': '>=1.2.50'
       '@swc/wasm': '>=1.2.50'
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       typescript: '>=2.7'
     peerDependenciesMeta:
       '@swc/core':
@@ -6372,8 +6646,27 @@ packages:
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
-  tsx@4.21.0:
-    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
+  tsup@8.5.1:
+    resolution: {integrity: sha512-xtgkqwdhpKWr3tKPmCkvYmS9xnQK3m3XgxZHwSUjvfTjp7YfXe5tT3GgWi0F2N+ZSMsOeWeZFh7ZZFg5iPhing==}
+    engines: {node: '>=18'}
+    hasBin: true
+    peerDependencies:
+      '@microsoft/api-extractor': ^7.36.0
+      '@swc/core': ^1
+      postcss: ^8.4.12
+      typescript: '>=4.5.0'
+    peerDependenciesMeta:
+      '@microsoft/api-extractor':
+        optional: true
+      '@swc/core':
+        optional: true
+      postcss:
+        optional: true
+      typescript:
+        optional: true
+
+  tsx@4.22.4:
+    resolution: {integrity: sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg==}
     engines: {node: '>=18.0.0'}
     hasBin: true
 
@@ -6421,6 +6714,10 @@ packages:
     resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
     engines: {node: '>=16'}
 
+  type-fest@5.7.0:
+    resolution: {integrity: sha512-1URUxUqfHFM1c+zfSPsa3gnkO7Aq21qyH75SIduNYz4SzY964rn1X2vCMQaHSHhktiw+0kPa2iyb6PUpXqB6Vg==}
+    engines: {node: '>=20'}
+
   typed-array-buffer@1.0.3:
     resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
     engines: {node: '>= 0.4'}
@@ -6433,17 +6730,17 @@ packages:
     resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==}
     engines: {node: '>= 0.4'}
 
-  typed-array-length@1.0.7:
-    resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==}
+  typed-array-length@1.0.8:
+    resolution: {integrity: sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g==}
     engines: {node: '>= 0.4'}
 
-  typescript@5.8.2:
-    resolution: {integrity: sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==}
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
     engines: {node: '>=14.17'}
     hasBin: true
 
-  typescript@6.0.2:
-    resolution: {integrity: sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==}
+  typescript@6.0.3:
+    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
     engines: {node: '>=14.17'}
     hasBin: true
 
@@ -6451,8 +6748,8 @@ packages:
     resolution: {integrity: sha512-LbBDqdIC5s8iROCUjMbW1f5dJQTEFB1+KO9ogbvlb3nm9n4YHa5p4KTvFPWvh2Hs8gZMBuiB1/8+pdfe/tDPug==}
     hasBin: true
 
-  ufo@1.6.1:
-    resolution: {integrity: sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==}
+  ufo@1.6.4:
+    resolution: {integrity: sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==}
 
   unbox-primitive@1.1.0:
     resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==}
@@ -6464,21 +6761,17 @@ packages:
   undefsafe@2.0.5:
     resolution: {integrity: sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==}
 
-  undici-types@7.18.2:
-    resolution: {integrity: sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==}
+  undici-types@7.24.6:
+    resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==}
 
-  undici@6.24.1:
-    resolution: {integrity: sha512-sC+b0tB1whOCzbtlx20fx3WgCXwkW627p4EA9uM+/tNNPkSS+eSEld6pAs9nDv7WbY1UUljBMYPtu9BCOrCWKA==}
+  undici@6.26.0:
+    resolution: {integrity: sha512-4yqz8a3n5HmGTlsbADNtr/dJlhkh/55Rq798G6ibiULcXbDtaLpTl1pvdqcbFfeoj3iSi52lePFM7h9H21cw/A==}
     engines: {node: '>=18.17'}
 
-  undici@7.24.7:
-    resolution: {integrity: sha512-H/nlJ/h0ggGC+uRL3ovD+G0i4bqhvsDOpbDv7At5eFLlj2b41L8QliGbnl2H7SnDiYhENphh1tQFJZf+MyfLsQ==}
+  undici@7.27.0:
+    resolution: {integrity: sha512-+t2Z/GwkZQDtu00813aP66ygViGtPHKhhoFZpQKpKrE+9jIgES+Zw+mFNaDWOVRKiuJjuqKHzD3B1sfGg8+ZOQ==}
     engines: {node: '>=20.18.1'}
 
-  unicorn-magic@0.1.0:
-    resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==}
-    engines: {node: '>=18'}
-
   unicorn-magic@0.3.0:
     resolution: {integrity: sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==}
     engines: {node: '>=18'}
@@ -6495,6 +6788,36 @@ packages:
     resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
     engines: {node: '>= 10.0.0'}
 
+  unplugin-dts@1.0.2:
+    resolution: {integrity: sha512-VbNiMD0LMl/t6nJueGtrCp79N7ZO1nquxj/FUybJDnKwZGsnW2wjdwBSzA3QEHujoxmxZIptsG43hL7LzXE96w==}
+    peerDependencies:
+      '@microsoft/api-extractor': '>=7'
+      '@rspack/core': ^1
+      '@vue/language-core': ~3.1.5
+      esbuild: '*'
+      rolldown: '*'
+      rollup: '>=3'
+      typescript: '>=4'
+      vite: ^8.0.7
+      webpack: ^4 || ^5
+    peerDependenciesMeta:
+      '@microsoft/api-extractor':
+        optional: true
+      '@rspack/core':
+        optional: true
+      '@vue/language-core':
+        optional: true
+      esbuild:
+        optional: true
+      rolldown:
+        optional: true
+      rollup:
+        optional: true
+      vite:
+        optional: true
+      webpack:
+        optional: true
+
   unplugin-icons@23.0.1:
     resolution: {integrity: sha512-rv0XEJepajKzDLvRUWASM8K+8+/CCfZn2jtogXqg6RIp7kpatRc/aFrVJn8ANQA09e++lPEEv9yX8cC9enc+QQ==}
     peerDependencies:
@@ -6516,6 +6839,9 @@ packages:
     resolution: {integrity: sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww==}
     engines: {node: '>=18.12.0'}
 
+  unrs-resolver@1.12.2:
+    resolution: {integrity: sha512-dmlRxBJJayXjqTwC+JtF1HhJmgf3ftQ3YejFcZrf4+KKtJv0qDsK1pjqaaVjG7wJ5NJ6UVP1OqRMQ71Z4C3rxQ==}
+
   untildify@4.0.0:
     resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==}
     engines: {node: '>=8'}
@@ -6523,12 +6849,6 @@ packages:
   unzipper@0.10.14:
     resolution: {integrity: sha512-ti4wZj+0bQTiX2KmKWuwj7lhV+2n//uXEotUmGuQqrbVZSEGFMbI68+c6JCQ8aAmUWYvtHEz2A8K6wXvueR/6g==}
 
-  update-browserslist-db@1.1.4:
-    resolution: {integrity: sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==}
-    hasBin: true
-    peerDependencies:
-      browserslist: '>= 4.21.0'
-
   update-browserslist-db@1.2.3:
     resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
     hasBin: true
@@ -6565,10 +6885,6 @@ packages:
     deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
-  uuid@11.0.5:
-    resolution: {integrity: sha512-508e6IcKLrhxKdBbcA2b4KQZlLVp2+J5UwQ6F7Drckkc5N9ZJwFa4TgWtsww9UG8fGHbm6gbV19TdM5pQ4GaIA==}
-    hasBin: true
-
   uuid@8.3.2:
     resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==}
     deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
@@ -6589,34 +6905,37 @@ packages:
   validate-npm-package-license@3.0.4:
     resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
 
-  vite-node@2.1.9:
-    resolution: {integrity: sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==}
-    engines: {node: ^18.0.0 || >=20.0.0}
-    hasBin: true
-
-  vite-plugin-dts@4.5.4:
-    resolution: {integrity: sha512-d4sOM8M/8z7vRXHHq/ebbblfaxENjogAAekcfcDCCwAyvGqnPrc7f4NZbvItS+g4WTgerW0xDwSz5qz11JT3vg==}
+  vite-plugin-dts@5.0.2:
+    resolution: {integrity: sha512-lNeHS+dwGju6eRmNvZQt8Shwv9j3m98hbHse/lIbLq9q3yE2DcIOBBYQEVUF6tS0kOmv+VA9Z5FqmzFnGe4U8g==}
     peerDependencies:
-      typescript: '*'
+      '@microsoft/api-extractor': '>=7'
+      rollup: '>=3'
       vite: ^8.0.7
     peerDependenciesMeta:
+      '@microsoft/api-extractor':
+        optional: true
+      rollup:
+        optional: true
       vite:
         optional: true
 
-  vite-plugin-singlefile@2.3.2:
-    resolution: {integrity: sha512-b8SxCi/gG7K298oJDcKOuZeU6gf6wIcCJAaEqUmmZXdjfuONlkyNyWZC3tEbN6QockRCNUd3it9eGTtpHGoYmg==}
+  vite-plugin-singlefile@2.3.3:
+    resolution: {integrity: sha512-XVnGH0QzbOa8fxRSsHdCarVN1BSBXNi7uLMQYlrGRN5apdHkk62XQWRJhVever0lnfuyBkwn+kvVChdm/OoOUg==}
     engines: {node: '>18.0.0'}
     peerDependencies:
       rollup: ^4.59.0
       vite: ^8.0.7
+    peerDependenciesMeta:
+      rollup:
+        optional: true
 
-  vite@8.0.7:
-    resolution: {integrity: sha512-P1PbweD+2/udplnThz3btF4cf6AgPky7kk23RtHUkJIU5BIxwPprhRGmOAHs6FTI7UiGbTNrgNP6jSYD6JaRnw==}
+  vite@8.0.16:
+    resolution: {integrity: sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
     peerDependencies:
-      '@types/node': 25.5.2
-      '@vitejs/devtools': ^0.1.0
+      '@types/node': 25.9.1
+      '@vitejs/devtools': ^0.1.18
       esbuild: ^0.27.0 || ^0.28.0
       jiti: '>=1.21.0'
       less: ^4.0.0
@@ -6653,45 +6972,20 @@ packages:
       yaml:
         optional: true
 
-  vitest@2.1.9:
-    resolution: {integrity: sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==}
-    engines: {node: ^18.0.0 || >=20.0.0}
-    hasBin: true
-    peerDependencies:
-      '@edge-runtime/vm': '*'
-      '@types/node': 25.5.2
-      '@vitest/browser': 2.1.9
-      '@vitest/ui': 2.1.9
-      happy-dom: '*'
-      jsdom: '*'
-    peerDependenciesMeta:
-      '@edge-runtime/vm':
-        optional: true
-      '@types/node':
-        optional: true
-      '@vitest/browser':
-        optional: true
-      '@vitest/ui':
-        optional: true
-      happy-dom:
-        optional: true
-      jsdom:
-        optional: true
-
-  vitest@4.1.3:
-    resolution: {integrity: sha512-DBc4Tx0MPNsqb9isoyOq00lHftVx/KIU44QOm2q59npZyLUkENn8TMFsuzuO+4U2FUa9rgbbPt3udrP25GcjXw==}
+  vitest@4.1.8:
+    resolution: {integrity: sha512-flY6ScbCIt9HThs+C5HS7jvGOB560DJtk/Z15IQROTA6zEy49Nh8T/dofWTQL+n3vswqn87sbJNiuqw1SDp5Ig==}
     engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
       '@edge-runtime/vm': '*'
       '@opentelemetry/api': ^1.9.0
-      '@types/node': 25.5.2
-      '@vitest/browser-playwright': 4.1.3
-      '@vitest/browser-preview': 4.1.3
-      '@vitest/browser-webdriverio': 4.1.3
-      '@vitest/coverage-istanbul': 4.1.3
-      '@vitest/coverage-v8': 4.1.3
-      '@vitest/ui': 4.1.3
+      '@types/node': 25.9.1
+      '@vitest/browser-playwright': 4.1.8
+      '@vitest/browser-preview': 4.1.8
+      '@vitest/browser-webdriverio': 4.1.8
+      '@vitest/coverage-istanbul': 4.1.8
+      '@vitest/coverage-v8': 4.1.8
+      '@vitest/ui': 4.1.8
       happy-dom: '*'
       jsdom: '*'
       vite: ^8.0.7
@@ -6744,12 +7038,12 @@ packages:
     resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==}
     engines: {node: '>= 8'}
 
-  webdriver@9.27.0:
-    resolution: {integrity: sha512-w07ThZND48SIr0b4S7eFougYUyclmoUwdmju8yXvEJiXYjDjeYUpl8wZrYPEYRBylxpSx+sBHfEUBrPQkcTTRQ==}
+  webdriver@9.27.2:
+    resolution: {integrity: sha512-m7JrZucyOa+VMojsKrZSIE7lsl2RtLk2VqqOe7aWtlmRnBQs33/AaaHIY8FJNe2NKfM1rRSEv87GP2zjLUzyog==}
     engines: {node: '>=18.20.0'}
 
-  webdriverio@9.27.0:
-    resolution: {integrity: sha512-Y4FbMf4bKBXpPB0lYpglzQ2GfDDe6uojmMZl85uPyrDx18NW7mqN84ZawGoIg/FRvcLaVhcOzc98WOPo725Rag==}
+  webdriverio@9.27.2:
+    resolution: {integrity: sha512-kNRTYomUY8ujhPn+eIxru9eQJP1BMmb4JfIdFt8m9mAPxkdNKJScRHSj77/x8yV2a4wKP0lefYfFtK77B+qzfA==}
     engines: {node: '>=18.20.0'}
     peerDependencies:
       puppeteer-core: '>=22.x || <=24.x'
@@ -6799,8 +7093,8 @@ packages:
     resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==}
     engines: {node: '>= 0.4'}
 
-  which-typed-array@1.1.19:
-    resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
+  which-typed-array@1.1.21:
+    resolution: {integrity: sha512-zbRA8cVm6io/d5W8uIe2hblzN76/Wm3v/yiythQvr+dpBWeqhPSWIDNj4zOyHi4zKbMK6DN34Xsr9jPHJERAEw==}
     engines: {node: '>= 0.4'}
 
   which@1.3.1:
@@ -6838,6 +7132,9 @@ packages:
   workerpool@6.5.1:
     resolution: {integrity: sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==}
 
+  workerpool@9.3.4:
+    resolution: {integrity: sha512-TmPRQYYSAnnDiEB0P/Ytip7bFGvqnSU6I2BcuSw7Hx+JSg/DsUi5ebYfc8GYaSdpuvOcEs6dXxPurOYpe9QFwg==}
+
   wrap-ansi@6.2.0:
     resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
     engines: {node: '>=8'}
@@ -6853,9 +7150,9 @@ packages:
   wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
-  write-file-atomic@4.0.2:
-    resolution: {integrity: sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==}
-    engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
+  write-file-atomic@5.0.1:
+    resolution: {integrity: sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   write-file-atomic@7.0.1:
     resolution: {integrity: sha512-OTIk8iR8/aCRWBqvxrzxR0hgxWpnYBblY1S5hDWBQfk/VFmJwzmJgQFN3WsoUKHISv2eAwe+PpbUzyL1CKTLXg==}
@@ -6873,8 +7170,8 @@ packages:
       utf-8-validate:
         optional: true
 
-  ws@8.20.0:
-    resolution: {integrity: sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==}
+  ws@8.21.0:
+    resolution: {integrity: sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==}
     engines: {node: '>=10.0.0'}
     peerDependencies:
       bufferutil: ^4.0.1
@@ -6889,6 +7186,10 @@ packages:
     resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
     engines: {node: '>=18'}
 
+  xml-naming@0.1.0:
+    resolution: {integrity: sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw==}
+    engines: {node: '>=16.0.0'}
+
   xmlbuilder@15.1.1:
     resolution: {integrity: sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==}
     engines: {node: '>=8.0'}
@@ -6906,8 +7207,8 @@ packages:
   yallist@4.0.0:
     resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
 
-  yaml@2.8.3:
-    resolution: {integrity: sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg==}
+  yaml@2.9.0:
+    resolution: {integrity: sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==}
     engines: {node: '>= 14.6'}
     hasBin: true
 
@@ -6957,8 +7258,8 @@ packages:
   yup@1.2.0:
     resolution: {integrity: sha512-PPqYKSAXjpRCgLgLKVGPA33v5c/WgEx3wi6NFjIiegz90zSwyMpvTFp/uGcVnnbx6to28pgnzp/q8ih3QRjLMQ==}
 
-  yup@1.6.1:
-    resolution: {integrity: sha512-JED8pB50qbA4FOkDol0bYF/p60qSEDQqBD0/qeIrUCG1KbPBIQ776fCUNb9ldbPcSTxA69g/47XTo4TqWiuXOA==}
+  yup@1.7.1:
+    resolution: {integrity: sha512-GKHFX2nXul2/4Dtfxhozv701jLQHdf6J34YDh2cEkpqoo8le5Mg6/LrdseVLrFarmFygZTlfIhHx/QKfb/QWXw==}
 
   zip-stream@4.1.1:
     resolution: {integrity: sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==}
@@ -6974,8 +7275,8 @@ snapshots:
 
   '@antfu/install-pkg@1.1.0':
     dependencies:
-      package-manager-detector: 1.5.0
-      tinyexec: 1.1.1
+      package-manager-detector: 1.6.0
+      tinyexec: 1.2.4
 
   '@asamuzakjp/css-color@3.2.0':
     dependencies:
@@ -6985,200 +7286,202 @@ snapshots:
       '@csstools/css-tokenizer': 3.0.4
       lru-cache: 10.4.3
 
-  '@babel/code-frame@7.29.0':
+  '@babel/code-frame@7.29.7':
     dependencies:
-      '@babel/helper-validator-identifier': 7.28.5
+      '@babel/helper-validator-identifier': 7.29.7
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/compat-data@7.29.0': {}
+  '@babel/compat-data@7.29.7': {}
 
-  '@babel/core@7.29.0':
+  '@babel/core@7.29.7':
     dependencies:
-      '@babel/code-frame': 7.29.0
-      '@babel/generator': 7.29.1
-      '@babel/helper-compilation-targets': 7.28.6
-      '@babel/helper-module-transforms': 7.28.6(@babel/core@7.29.0)
-      '@babel/helpers': 7.29.2
-      '@babel/parser': 7.29.2
-      '@babel/template': 7.28.6
-      '@babel/traverse': 7.29.0
-      '@babel/types': 7.29.0
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-compilation-targets': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helpers': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
       '@jridgewell/remapping': 2.3.5
       convert-source-map: 2.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/generator@7.29.1':
+  '@babel/generator@7.29.7':
     dependencies:
-      '@babel/parser': 7.29.2
-      '@babel/types': 7.29.0
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
       jsesc: 3.1.0
 
-  '@babel/helper-compilation-targets@7.28.6':
+  '@babel/helper-compilation-targets@7.29.7':
     dependencies:
-      '@babel/compat-data': 7.29.0
-      '@babel/helper-validator-option': 7.27.1
+      '@babel/compat-data': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
       browserslist: 4.28.2
       lru-cache: 5.1.1
       semver: 6.3.1
 
-  '@babel/helper-globals@7.28.0': {}
+  '@babel/helper-globals@7.29.7': {}
 
-  '@babel/helper-module-imports@7.28.6':
+  '@babel/helper-module-imports@7.29.7':
     dependencies:
-      '@babel/traverse': 7.29.0
-      '@babel/types': 7.29.0
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-module-transforms@7.28.6(@babel/core@7.29.0)':
+  '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-module-imports': 7.28.6
-      '@babel/helper-validator-identifier': 7.28.5
-      '@babel/traverse': 7.29.0
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+      '@babel/traverse': 7.29.7
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-plugin-utils@7.28.6': {}
+  '@babel/helper-plugin-utils@7.29.7': {}
 
-  '@babel/helper-string-parser@7.27.1': {}
+  '@babel/helper-string-parser@7.29.7': {}
 
-  '@babel/helper-validator-identifier@7.28.5': {}
+  '@babel/helper-validator-identifier@7.29.7': {}
 
-  '@babel/helper-validator-option@7.27.1': {}
+  '@babel/helper-validator-option@7.29.7': {}
 
-  '@babel/helpers@7.29.2':
+  '@babel/helpers@7.29.7':
     dependencies:
-      '@babel/template': 7.28.6
-      '@babel/types': 7.29.0
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
 
-  '@babel/parser@7.29.2':
+  '@babel/parser@7.29.7':
     dependencies:
-      '@babel/types': 7.29.0
+      '@babel/types': 7.29.7
 
-  '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-import-attributes@7.28.6(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-import-attributes@7.29.7(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-jsx@7.28.6(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/plugin-syntax-typescript@7.28.6(@babel/core@7.29.0)':
+  '@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7)':
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
 
-  '@babel/template@7.28.6':
+  '@babel/template@7.29.7':
     dependencies:
-      '@babel/code-frame': 7.29.0
-      '@babel/parser': 7.29.2
-      '@babel/types': 7.29.0
+      '@babel/code-frame': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
 
-  '@babel/traverse@7.29.0':
+  '@babel/traverse@7.29.7':
     dependencies:
-      '@babel/code-frame': 7.29.0
-      '@babel/generator': 7.29.1
-      '@babel/helper-globals': 7.28.0
-      '@babel/parser': 7.29.2
-      '@babel/template': 7.28.6
-      '@babel/types': 7.29.0
-      debug: 4.4.3
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/types@7.29.0':
+  '@babel/types@7.29.7':
     dependencies:
-      '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.28.5
+      '@babel/helper-string-parser': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
 
   '@bazel/runfiles@6.5.0': {}
 
   '@bcoe/v8-coverage@0.2.3': {}
 
+  '@bcoe/v8-coverage@1.0.2': {}
+
   '@blazediff/core@1.9.1': {}
 
-  '@cacheable/memory@2.0.8':
+  '@cacheable/memory@2.0.9':
     dependencies:
       '@cacheable/utils': 2.4.1
       '@keyv/bigmap': 1.3.1(keyv@5.6.0)
@@ -7190,49 +7493,49 @@ snapshots:
       hashery: 1.5.1
       keyv: 5.6.0
 
-  '@codemirror/autocomplete@6.19.1':
+  '@codemirror/autocomplete@6.20.2':
     dependencies:
-      '@codemirror/language': 6.11.3
+      '@codemirror/language': 6.12.3
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
-      '@lezer/common': 1.3.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
 
-  '@codemirror/commands@6.10.0':
+  '@codemirror/commands@6.10.3':
     dependencies:
-      '@codemirror/language': 6.11.3
+      '@codemirror/language': 6.12.3
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
-      '@lezer/common': 1.3.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
 
   '@codemirror/lang-javascript@6.2.5':
     dependencies:
-      '@codemirror/autocomplete': 6.19.1
-      '@codemirror/language': 6.11.3
-      '@codemirror/lint': 6.9.1
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/language': 6.12.3
+      '@codemirror/lint': 6.9.6
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
-      '@lezer/common': 1.3.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
       '@lezer/javascript': 1.5.4
 
-  '@codemirror/language@6.11.3':
+  '@codemirror/language@6.12.3':
     dependencies:
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
-      '@lezer/common': 1.3.0
-      '@lezer/highlight': 1.2.2
-      '@lezer/lr': 1.4.2
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
       style-mod: 4.1.3
 
-  '@codemirror/lint@6.9.1':
+  '@codemirror/lint@6.9.6':
     dependencies:
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
+      '@codemirror/view': 6.43.0
       crelt: 1.0.6
 
-  '@codemirror/search@6.5.11':
+  '@codemirror/search@6.7.0':
     dependencies:
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
+      '@codemirror/view': 6.43.0
       crelt: 1.0.6
 
   '@codemirror/state@6.5.4':
@@ -7241,12 +7544,12 @@ snapshots:
 
   '@codemirror/theme-one-dark@6.1.3':
     dependencies:
-      '@codemirror/language': 6.11.3
+      '@codemirror/language': 6.12.3
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
-      '@lezer/highlight': 1.2.2
+      '@codemirror/view': 6.43.0
+      '@lezer/highlight': 1.2.3
 
-  '@codemirror/view@6.41.0':
+  '@codemirror/view@6.43.0':
     dependencies:
       '@codemirror/state': 6.5.4
       crelt: 1.0.6
@@ -7267,7 +7570,7 @@ snapshots:
       '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
       '@csstools/css-tokenizer': 3.0.4
 
-  '@csstools/css-calc@3.1.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+  '@csstools/css-calc@3.2.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
     dependencies:
       '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
       '@csstools/css-tokenizer': 4.0.0
@@ -7287,7 +7590,7 @@ snapshots:
     dependencies:
       '@csstools/css-tokenizer': 4.0.0
 
-  '@csstools/css-syntax-patches-for-csstree@1.1.2(css-tree@3.2.1)':
+  '@csstools/css-syntax-patches-for-csstree@1.1.4(css-tree@3.2.1)':
     optionalDependencies:
       css-tree: 3.2.1
 
@@ -7310,11 +7613,13 @@ snapshots:
 
   '@cucumber/ci-environment@10.0.1': {}
 
+  '@cucumber/ci-environment@13.0.0': {}
+
   '@cucumber/cucumber-expressions@17.1.0':
     dependencies:
       regexp-match-indices: 1.0.2
 
-  '@cucumber/cucumber-expressions@18.0.1':
+  '@cucumber/cucumber-expressions@19.0.1':
     dependencies:
       regexp-match-indices: 1.0.2
 
@@ -7360,50 +7665,45 @@ snapshots:
       type-fest: 4.41.0
       util-arity: 1.1.0
       xmlbuilder: 15.1.1
-      yaml: 2.8.3
+      yaml: 2.9.0
       yup: 1.2.0
 
-  '@cucumber/cucumber@11.3.0':
-    dependencies:
-      '@cucumber/ci-environment': 10.0.1
-      '@cucumber/cucumber-expressions': 18.0.1
-      '@cucumber/gherkin': 30.0.4
-      '@cucumber/gherkin-streams': 5.0.1(@cucumber/gherkin@30.0.4)(@cucumber/message-streams@4.0.1(@cucumber/messages@27.2.0))(@cucumber/messages@27.2.0)
-      '@cucumber/gherkin-utils': 9.2.0
-      '@cucumber/html-formatter': 21.10.1(@cucumber/messages@27.2.0)
-      '@cucumber/junit-xml-formatter': 0.7.1(@cucumber/messages@27.2.0)
-      '@cucumber/message-streams': 4.0.1(@cucumber/messages@27.2.0)
-      '@cucumber/messages': 27.2.0
-      '@cucumber/tag-expressions': 6.1.2
+  '@cucumber/cucumber@13.0.0':
+    dependencies:
+      '@cucumber/ci-environment': 13.0.0
+      '@cucumber/cucumber-expressions': 19.0.1
+      '@cucumber/gherkin': 39.1.0
+      '@cucumber/gherkin-streams': 6.0.0(@cucumber/gherkin@39.1.0)(@cucumber/message-streams@4.1.1(@cucumber/messages@32.3.1))(@cucumber/messages@32.3.1)
+      '@cucumber/gherkin-utils': 11.0.0
+      '@cucumber/html-formatter': 23.1.0(@cucumber/messages@32.3.1)
+      '@cucumber/junit-xml-formatter': 0.13.3(@cucumber/messages@32.3.1)
+      '@cucumber/message-streams': 4.1.1(@cucumber/messages@32.3.1)
+      '@cucumber/messages': 32.3.1
+      '@cucumber/pretty-formatter': 3.3.1(@cucumber/messages@32.3.1)
+      '@cucumber/tag-expressions': 9.1.0
       assertion-error-formatter: 3.0.0
-      capital-case: 1.0.4
-      chalk: 4.1.2
       cli-table3: 0.6.5
-      commander: 10.0.1
-      debug: 4.4.3(supports-color@8.1.1)
+      commander: 15.0.0
+      debug: 4.4.3(supports-color@10.2.2)
       error-stack-parser: 2.1.4
-      figures: 3.2.0
-      glob: 10.5.0
-      has-ansi: 4.0.1
-      indent-string: 4.0.0
-      is-installed-globally: 0.4.0
-      is-stream: 2.0.1
+      figures: 6.1.0
+      has-ansi: 6.0.2
+      indent-string: 5.0.0
+      is-installed-globally: 1.0.0
+      is-stream: 4.0.1
       knuth-shuffle-seeded: 1.0.6
       lodash.merge: 4.6.2
       lodash.mergewith: 4.6.2
-      luxon: 3.6.1
-      mime: 3.0.0
-      mkdirp: 2.1.6
-      mz: 2.7.0
-      progress: 2.0.3
-      read-package-up: 11.0.0
-      semver: 7.7.1
-      string-argv: 0.3.1
-      supports-color: 8.1.1
-      type-fest: 4.41.0
+      luxon: 3.7.2
+      mkdirp: 3.0.1
+      read-package-up: 12.0.0
+      semver: 7.8.1
+      string-argv: 0.3.2
+      supports-color: 10.2.2
+      type-fest: 5.7.0
       util-arity: 1.1.0
-      yaml: 2.8.3
-      yup: 1.6.1
+      yaml: 2.9.0
+      yup: 1.7.1
 
   '@cucumber/gherkin-streams@5.0.1(@cucumber/gherkin@28.0.0)(@cucumber/message-streams@4.0.1(@cucumber/messages@24.1.0))(@cucumber/messages@24.1.0)':
     dependencies:
@@ -7413,28 +7713,28 @@ snapshots:
       commander: 9.1.0
       source-map-support: 0.5.21
 
-  '@cucumber/gherkin-streams@5.0.1(@cucumber/gherkin@30.0.4)(@cucumber/message-streams@4.0.1(@cucumber/messages@27.2.0))(@cucumber/messages@27.2.0)':
+  '@cucumber/gherkin-streams@6.0.0(@cucumber/gherkin@39.1.0)(@cucumber/message-streams@4.1.1(@cucumber/messages@32.3.1))(@cucumber/messages@32.3.1)':
     dependencies:
-      '@cucumber/gherkin': 30.0.4
-      '@cucumber/message-streams': 4.0.1(@cucumber/messages@27.2.0)
-      '@cucumber/messages': 27.2.0
-      commander: 9.1.0
+      '@cucumber/gherkin': 39.1.0
+      '@cucumber/message-streams': 4.1.1(@cucumber/messages@32.3.1)
+      '@cucumber/messages': 32.3.1
+      commander: 14.0.0
       source-map-support: 0.5.21
 
-  '@cucumber/gherkin-utils@9.0.0':
+  '@cucumber/gherkin-utils@11.0.0':
     dependencies:
-      '@cucumber/gherkin': 28.0.0
-      '@cucumber/messages': 24.1.0
+      '@cucumber/gherkin': 38.0.0
+      '@cucumber/messages': 32.3.1
       '@teppeis/multimaps': 3.0.0
-      commander: 12.0.0
+      commander: 14.0.2
       source-map-support: 0.5.21
 
-  '@cucumber/gherkin-utils@9.2.0':
+  '@cucumber/gherkin-utils@9.0.0':
     dependencies:
-      '@cucumber/gherkin': 31.0.0
-      '@cucumber/messages': 27.2.0
+      '@cucumber/gherkin': 28.0.0
+      '@cucumber/messages': 24.1.0
       '@teppeis/multimaps': 3.0.0
-      commander: 13.1.0
+      commander: 12.0.0
       source-map-support: 0.5.21
 
   '@cucumber/gherkin@28.0.0':
@@ -7445,37 +7745,38 @@ snapshots:
     dependencies:
       '@cucumber/messages': 25.0.1
 
-  '@cucumber/gherkin@30.0.4':
-    dependencies:
-      '@cucumber/messages': 26.0.1
-
-  '@cucumber/gherkin@31.0.0':
+  '@cucumber/gherkin@38.0.0':
     dependencies:
-      '@cucumber/messages': 26.0.1
+      '@cucumber/messages': 32.3.1
 
-  '@cucumber/html-formatter@21.10.1(@cucumber/messages@27.2.0)':
+  '@cucumber/gherkin@39.1.0':
     dependencies:
-      '@cucumber/messages': 27.2.0
+      '@cucumber/messages': 32.3.1
 
   '@cucumber/html-formatter@21.6.0(@cucumber/messages@24.1.0)':
     dependencies:
       '@cucumber/messages': 24.1.0
 
-  '@cucumber/junit-xml-formatter@0.7.1(@cucumber/messages@27.2.0)':
+  '@cucumber/html-formatter@23.1.0(@cucumber/messages@32.3.1)':
+    dependencies:
+      '@cucumber/messages': 32.3.1
+
+  '@cucumber/junit-xml-formatter@0.13.3(@cucumber/messages@32.3.1)':
     dependencies:
-      '@cucumber/messages': 27.2.0
-      '@cucumber/query': 13.6.0(@cucumber/messages@27.2.0)
+      '@cucumber/messages': 32.3.1
+      '@cucumber/query': 15.0.1(@cucumber/messages@32.3.1)
       '@teppeis/multimaps': 3.0.0
-      luxon: 3.6.1
+      luxon: 3.7.2
       xmlbuilder: 15.1.1
 
   '@cucumber/message-streams@4.0.1(@cucumber/messages@24.1.0)':
     dependencies:
       '@cucumber/messages': 24.1.0
 
-  '@cucumber/message-streams@4.0.1(@cucumber/messages@27.2.0)':
+  '@cucumber/message-streams@4.1.1(@cucumber/messages@32.3.1)':
     dependencies:
-      '@cucumber/messages': 27.2.0
+      '@cucumber/messages': 32.3.1
+      mime: 3.0.0
 
   '@cucumber/messages@24.1.0':
     dependencies:
@@ -7498,35 +7799,39 @@ snapshots:
       reflect-metadata: 0.2.2
       uuid: 10.0.0
 
-  '@cucumber/messages@27.2.0':
+  '@cucumber/messages@32.3.1':
     dependencies:
-      '@types/uuid': 10.0.0
       class-transformer: 0.5.1
       reflect-metadata: 0.2.2
-      uuid: 11.0.5
 
-  '@cucumber/query@13.6.0(@cucumber/messages@27.2.0)':
+  '@cucumber/pretty-formatter@3.3.1(@cucumber/messages@32.3.1)':
+    dependencies:
+      '@cucumber/messages': 32.3.1
+      '@cucumber/query': 15.0.1(@cucumber/messages@32.3.1)
+      luxon: 3.7.2
+
+  '@cucumber/query@15.0.1(@cucumber/messages@32.3.1)':
     dependencies:
-      '@cucumber/messages': 27.2.0
+      '@cucumber/messages': 32.3.1
       '@teppeis/multimaps': 3.0.0
       lodash.sortby: 4.7.0
 
   '@cucumber/tag-expressions@6.1.0': {}
 
-  '@cucumber/tag-expressions@6.1.2': {}
+  '@cucumber/tag-expressions@9.1.0': {}
 
-  '@emnapi/core@1.9.1':
+  '@emnapi/core@1.10.0':
     dependencies:
-      '@emnapi/wasi-threads': 1.2.0
+      '@emnapi/wasi-threads': 1.2.1
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/runtime@1.9.1':
+  '@emnapi/runtime@1.10.0':
     dependencies:
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/wasi-threads@1.2.0':
+  '@emnapi/wasi-threads@1.2.1':
     dependencies:
       tslib: 2.8.1
     optional: true
@@ -7534,84 +7839,162 @@ snapshots:
   '@esbuild/aix-ppc64@0.27.7':
     optional: true
 
+  '@esbuild/aix-ppc64@0.28.0':
+    optional: true
+
   '@esbuild/android-arm64@0.27.7':
     optional: true
 
+  '@esbuild/android-arm64@0.28.0':
+    optional: true
+
   '@esbuild/android-arm@0.27.7':
     optional: true
 
+  '@esbuild/android-arm@0.28.0':
+    optional: true
+
   '@esbuild/android-x64@0.27.7':
     optional: true
 
+  '@esbuild/android-x64@0.28.0':
+    optional: true
+
   '@esbuild/darwin-arm64@0.27.7':
     optional: true
 
+  '@esbuild/darwin-arm64@0.28.0':
+    optional: true
+
   '@esbuild/darwin-x64@0.27.7':
     optional: true
 
+  '@esbuild/darwin-x64@0.28.0':
+    optional: true
+
   '@esbuild/freebsd-arm64@0.27.7':
     optional: true
 
+  '@esbuild/freebsd-arm64@0.28.0':
+    optional: true
+
   '@esbuild/freebsd-x64@0.27.7':
     optional: true
 
+  '@esbuild/freebsd-x64@0.28.0':
+    optional: true
+
   '@esbuild/linux-arm64@0.27.7':
     optional: true
 
+  '@esbuild/linux-arm64@0.28.0':
+    optional: true
+
   '@esbuild/linux-arm@0.27.7':
     optional: true
 
+  '@esbuild/linux-arm@0.28.0':
+    optional: true
+
   '@esbuild/linux-ia32@0.27.7':
     optional: true
 
+  '@esbuild/linux-ia32@0.28.0':
+    optional: true
+
   '@esbuild/linux-loong64@0.27.7':
     optional: true
 
+  '@esbuild/linux-loong64@0.28.0':
+    optional: true
+
   '@esbuild/linux-mips64el@0.27.7':
     optional: true
 
+  '@esbuild/linux-mips64el@0.28.0':
+    optional: true
+
   '@esbuild/linux-ppc64@0.27.7':
     optional: true
 
+  '@esbuild/linux-ppc64@0.28.0':
+    optional: true
+
   '@esbuild/linux-riscv64@0.27.7':
     optional: true
 
+  '@esbuild/linux-riscv64@0.28.0':
+    optional: true
+
   '@esbuild/linux-s390x@0.27.7':
     optional: true
 
+  '@esbuild/linux-s390x@0.28.0':
+    optional: true
+
   '@esbuild/linux-x64@0.27.7':
     optional: true
 
+  '@esbuild/linux-x64@0.28.0':
+    optional: true
+
   '@esbuild/netbsd-arm64@0.27.7':
     optional: true
 
+  '@esbuild/netbsd-arm64@0.28.0':
+    optional: true
+
   '@esbuild/netbsd-x64@0.27.7':
     optional: true
 
+  '@esbuild/netbsd-x64@0.28.0':
+    optional: true
+
   '@esbuild/openbsd-arm64@0.27.7':
     optional: true
 
+  '@esbuild/openbsd-arm64@0.28.0':
+    optional: true
+
   '@esbuild/openbsd-x64@0.27.7':
     optional: true
 
+  '@esbuild/openbsd-x64@0.28.0':
+    optional: true
+
   '@esbuild/openharmony-arm64@0.27.7':
     optional: true
 
+  '@esbuild/openharmony-arm64@0.28.0':
+    optional: true
+
   '@esbuild/sunos-x64@0.27.7':
     optional: true
 
+  '@esbuild/sunos-x64@0.28.0':
+    optional: true
+
   '@esbuild/win32-arm64@0.27.7':
     optional: true
 
+  '@esbuild/win32-arm64@0.28.0':
+    optional: true
+
   '@esbuild/win32-ia32@0.27.7':
     optional: true
 
+  '@esbuild/win32-ia32@0.28.0':
+    optional: true
+
   '@esbuild/win32-x64@0.27.7':
     optional: true
 
-  '@eslint-community/eslint-utils@4.9.1(eslint@10.2.0(jiti@2.6.1))':
+  '@esbuild/win32-x64@0.28.0':
+    optional: true
+
+  '@eslint-community/eslint-utils@4.9.1(eslint@10.4.1(jiti@2.7.0))':
     dependencies:
-      eslint: 10.2.0(jiti@2.6.1)
+      eslint: 10.4.1(jiti@2.7.0)
       eslint-visitor-keys: 3.4.3
 
   '@eslint-community/regexpp@4.12.2': {}
@@ -7619,12 +8002,12 @@ snapshots:
   '@eslint/config-array@0.23.5':
     dependencies:
       '@eslint/object-schema': 3.0.5
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       minimatch: 10.2.5
     transitivePeerDependencies:
       - supports-color
 
-  '@eslint/config-helpers@0.5.5':
+  '@eslint/config-helpers@0.6.0':
     dependencies:
       '@eslint/core': 1.2.1
 
@@ -7632,13 +8015,13 @@ snapshots:
     dependencies:
       '@types/json-schema': 7.0.15
 
-  '@eslint/js@10.0.1(eslint@10.2.0(jiti@2.6.1))':
+  '@eslint/js@10.0.1(eslint@10.4.1(jiti@2.7.0))':
     optionalDependencies:
-      eslint: 10.2.0(jiti@2.6.1)
+      eslint: 10.4.1(jiti@2.7.0)
 
   '@eslint/object-schema@3.0.5': {}
 
-  '@eslint/plugin-kit@0.7.1':
+  '@eslint/plugin-kit@0.7.2':
     dependencies:
       '@eslint/core': 1.2.1
       levn: 0.4.1
@@ -7647,15 +8030,15 @@ snapshots:
 
   '@fastify/ajv-compiler@4.0.5':
     dependencies:
-      ajv: 8.18.0
-      ajv-formats: 3.0.1(ajv@8.18.0)
-      fast-uri: 3.1.0
+      ajv: 8.20.0
+      ajv-formats: 3.0.1(ajv@8.20.0)
+      fast-uri: 3.1.2
 
   '@fastify/error@4.2.0': {}
 
   '@fastify/fast-json-stringify-compiler@5.0.3':
     dependencies:
-      fast-json-stringify: 6.3.0
+      fast-json-stringify: 6.4.0
 
   '@fastify/forwarded@3.0.1': {}
 
@@ -7666,13 +8049,13 @@ snapshots:
   '@fastify/proxy-addr@5.1.0':
     dependencies:
       '@fastify/forwarded': 3.0.1
-      ipaddr.js: 2.3.0
+      ipaddr.js: 2.4.0
 
   '@fastify/rate-limit@10.3.0':
     dependencies:
       '@lukeed/ms': 2.0.2
       fastify-plugin: 5.1.0
-      toad-cache: 3.7.0
+      toad-cache: 3.7.1
 
   '@fastify/send@4.1.0':
     dependencies:
@@ -7682,7 +8065,7 @@ snapshots:
       http-errors: 2.0.1
       mime: 3.0.0
 
-  '@fastify/static@9.1.0':
+  '@fastify/static@9.1.3':
     dependencies:
       '@fastify/accept-negotiator': 2.0.1
       '@fastify/send': 4.1.0
@@ -7695,18 +8078,23 @@ snapshots:
     dependencies:
       duplexify: 4.1.3
       fastify-plugin: 5.1.0
-      ws: 8.20.0
+      ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
 
-  '@humanfs/core@0.19.1': {}
+  '@humanfs/core@0.19.2':
+    dependencies:
+      '@humanfs/types': 0.15.0
 
-  '@humanfs/node@0.16.7':
+  '@humanfs/node@0.16.8':
     dependencies:
-      '@humanfs/core': 0.19.1
+      '@humanfs/core': 0.19.2
+      '@humanfs/types': 0.15.0
       '@humanwhocodes/retry': 0.4.3
 
+  '@humanfs/types@0.15.0': {}
+
   '@humanwhocodes/module-importer@1.0.1': {}
 
   '@humanwhocodes/retry@0.4.3': {}
@@ -7717,142 +8105,136 @@ snapshots:
 
   '@iconify/types@2.0.0': {}
 
-  '@iconify/utils@3.1.0':
+  '@iconify/utils@3.1.3':
     dependencies:
       '@antfu/install-pkg': 1.1.0
       '@iconify/types': 2.0.0
-      mlly: 1.8.0
+      import-meta-resolve: 4.2.0
 
   '@inquirer/ansi@1.0.2': {}
 
-  '@inquirer/checkbox@4.3.2(@types/node@25.5.2)':
+  '@inquirer/checkbox@4.3.2(@types/node@25.9.1)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/confirm@5.1.21(@types/node@25.5.2)':
+  '@inquirer/confirm@5.1.21(@types/node@25.9.1)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/core@10.3.2(@types/node@25.5.2)':
+  '@inquirer/core@10.3.2(@types/node@25.9.1)':
     dependencies:
       '@inquirer/ansi': 1.0.2
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
       cli-width: 4.1.0
       mute-stream: 2.0.0
       signal-exit: 4.1.0
       wrap-ansi: 6.2.0
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/editor@4.2.23(@types/node@25.5.2)':
+  '@inquirer/editor@4.2.23(@types/node@25.9.1)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/external-editor': 1.0.3(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/external-editor': 1.0.3(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/expand@4.0.23(@types/node@25.5.2)':
+  '@inquirer/expand@4.0.23(@types/node@25.9.1)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/external-editor@1.0.3(@types/node@25.5.2)':
+  '@inquirer/external-editor@1.0.3(@types/node@25.9.1)':
     dependencies:
       chardet: 2.1.1
       iconv-lite: 0.7.2
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
   '@inquirer/figures@1.0.15': {}
 
-  '@inquirer/input@4.3.1(@types/node@25.5.2)':
+  '@inquirer/input@4.3.1(@types/node@25.9.1)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/number@3.0.23(@types/node@25.5.2)':
+  '@inquirer/number@3.0.23(@types/node@25.9.1)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/password@4.0.23(@types/node@25.5.2)':
+  '@inquirer/password@4.0.23(@types/node@25.9.1)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
     optionalDependencies:
-      '@types/node': 25.5.2
-
-  '@inquirer/prompts@7.10.1(@types/node@25.5.2)':
-    dependencies:
-      '@inquirer/checkbox': 4.3.2(@types/node@25.5.2)
-      '@inquirer/confirm': 5.1.21(@types/node@25.5.2)
-      '@inquirer/editor': 4.2.23(@types/node@25.5.2)
-      '@inquirer/expand': 4.0.23(@types/node@25.5.2)
-      '@inquirer/input': 4.3.1(@types/node@25.5.2)
-      '@inquirer/number': 3.0.23(@types/node@25.5.2)
-      '@inquirer/password': 4.0.23(@types/node@25.5.2)
-      '@inquirer/rawlist': 4.1.11(@types/node@25.5.2)
-      '@inquirer/search': 3.2.2(@types/node@25.5.2)
-      '@inquirer/select': 4.4.2(@types/node@25.5.2)
+      '@types/node': 25.9.1
+
+  '@inquirer/prompts@7.10.1(@types/node@25.9.1)':
+    dependencies:
+      '@inquirer/checkbox': 4.3.2(@types/node@25.9.1)
+      '@inquirer/confirm': 5.1.21(@types/node@25.9.1)
+      '@inquirer/editor': 4.2.23(@types/node@25.9.1)
+      '@inquirer/expand': 4.0.23(@types/node@25.9.1)
+      '@inquirer/input': 4.3.1(@types/node@25.9.1)
+      '@inquirer/number': 3.0.23(@types/node@25.9.1)
+      '@inquirer/password': 4.0.23(@types/node@25.9.1)
+      '@inquirer/rawlist': 4.1.11(@types/node@25.9.1)
+      '@inquirer/search': 3.2.2(@types/node@25.9.1)
+      '@inquirer/select': 4.4.2(@types/node@25.9.1)
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/rawlist@4.1.11(@types/node@25.5.2)':
+  '@inquirer/rawlist@4.1.11(@types/node@25.9.1)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/search@3.2.2(@types/node@25.5.2)':
+  '@inquirer/search@3.2.2(@types/node@25.9.1)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/select@4.4.2(@types/node@25.5.2)':
+  '@inquirer/select@4.4.2(@types/node@25.9.1)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@inquirer/type@3.0.10(@types/node@25.5.2)':
+  '@inquirer/type@3.0.10(@types/node@25.9.1)':
     optionalDependencies:
-      '@types/node': 25.5.2
-
-  '@isaacs/balanced-match@4.0.1': {}
-
-  '@isaacs/brace-expansion@5.0.0':
-    dependencies:
-      '@isaacs/balanced-match': 4.0.1
+      '@types/node': 25.9.1
 
   '@isaacs/cliui@8.0.2':
     dependencies:
@@ -7873,192 +8255,181 @@ snapshots:
 
   '@istanbuljs/schema@0.1.6': {}
 
-  '@jest/console@29.7.0':
+  '@jest/console@30.4.1':
     dependencies:
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       chalk: 4.1.2
-      jest-message-util: 29.7.0
-      jest-util: 29.7.0
+      jest-message-util: 30.4.1
+      jest-util: 30.4.1
       slash: 3.0.0
 
-  '@jest/core@29.7.0(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))':
+  '@jest/core@30.4.2(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3))':
     dependencies:
-      '@jest/console': 29.7.0
-      '@jest/reporters': 29.7.0
-      '@jest/test-result': 29.7.0
-      '@jest/transform': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
+      '@jest/console': 30.4.1
+      '@jest/pattern': 30.4.0
+      '@jest/reporters': 30.4.1
+      '@jest/test-result': 30.4.1
+      '@jest/transform': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       ansi-escapes: 4.3.2
       chalk: 4.1.2
-      ci-info: 3.3.0
-      exit: 0.1.2
+      ci-info: 4.4.0
+      exit-x: 0.2.2
+      fast-json-stable-stringify: 2.1.0
       graceful-fs: 4.2.11
-      jest-changed-files: 29.7.0
-      jest-config: 29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
-      jest-haste-map: 29.7.0
-      jest-message-util: 29.7.0
-      jest-regex-util: 29.6.3
-      jest-resolve: 29.7.0
-      jest-resolve-dependencies: 29.7.0
-      jest-runner: 29.7.0
-      jest-runtime: 29.7.0
-      jest-snapshot: 29.7.0
-      jest-util: 29.7.0
-      jest-validate: 29.7.0
-      jest-watcher: 29.7.0
-      micromatch: 4.0.8
-      pretty-format: 29.7.0
+      jest-changed-files: 30.4.1
+      jest-config: 30.4.2(@types/node@25.9.1)(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3))
+      jest-haste-map: 30.4.1
+      jest-message-util: 30.4.1
+      jest-regex-util: 30.4.0
+      jest-resolve: 30.4.1
+      jest-resolve-dependencies: 30.4.2
+      jest-runner: 30.4.2
+      jest-runtime: 30.4.2
+      jest-snapshot: 30.4.1
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
+      jest-watcher: 30.4.1
+      pretty-format: 30.4.1
       slash: 3.0.0
-      strip-ansi: 6.0.1
     transitivePeerDependencies:
       - babel-plugin-macros
+      - esbuild-register
       - supports-color
       - ts-node
 
-  '@jest/diff-sequences@30.3.0': {}
-
-  '@jest/environment@29.7.0':
-    dependencies:
-      '@jest/fake-timers': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
-      jest-mock: 29.7.0
+  '@jest/diff-sequences@30.4.0': {}
 
-  '@jest/expect-utils@29.7.0':
+  '@jest/environment@30.4.1':
     dependencies:
-      jest-get-type: 29.6.3
+      '@jest/fake-timers': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
+      jest-mock: 30.4.1
 
-  '@jest/expect-utils@30.3.0':
+  '@jest/expect-utils@30.4.1':
     dependencies:
       '@jest/get-type': 30.1.0
 
-  '@jest/expect@29.7.0':
+  '@jest/expect@30.4.1':
     dependencies:
-      expect: 29.7.0
-      jest-snapshot: 29.7.0
+      expect: 30.4.1
+      jest-snapshot: 30.4.1
     transitivePeerDependencies:
       - supports-color
 
-  '@jest/fake-timers@29.7.0':
+  '@jest/fake-timers@30.4.1':
     dependencies:
-      '@jest/types': 29.6.3
-      '@sinonjs/fake-timers': 10.3.0
-      '@types/node': 25.5.2
-      jest-message-util: 29.7.0
-      jest-mock: 29.7.0
-      jest-util: 29.7.0
+      '@jest/types': 30.4.1
+      '@sinonjs/fake-timers': 15.4.0
+      '@types/node': 25.9.1
+      jest-message-util: 30.4.1
+      jest-mock: 30.4.1
+      jest-util: 30.4.1
 
   '@jest/get-type@30.1.0': {}
 
-  '@jest/globals@29.7.0':
+  '@jest/globals@30.4.1':
     dependencies:
-      '@jest/environment': 29.7.0
-      '@jest/expect': 29.7.0
-      '@jest/types': 29.6.3
-      jest-mock: 29.7.0
+      '@jest/environment': 30.4.1
+      '@jest/expect': 30.4.1
+      '@jest/types': 30.4.1
+      jest-mock: 30.4.1
     transitivePeerDependencies:
       - supports-color
 
-  '@jest/pattern@30.0.1':
+  '@jest/pattern@30.4.0':
     dependencies:
-      '@types/node': 25.5.2
-      jest-regex-util: 30.0.1
+      '@types/node': 25.9.1
+      jest-regex-util: 30.4.0
 
-  '@jest/reporters@29.7.0':
+  '@jest/reporters@30.4.1':
     dependencies:
       '@bcoe/v8-coverage': 0.2.3
-      '@jest/console': 29.7.0
-      '@jest/test-result': 29.7.0
-      '@jest/transform': 29.7.0
-      '@jest/types': 29.6.3
+      '@jest/console': 30.4.1
+      '@jest/test-result': 30.4.1
+      '@jest/transform': 30.4.1
+      '@jest/types': 30.4.1
       '@jridgewell/trace-mapping': 0.3.31
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       chalk: 4.1.2
       collect-v8-coverage: 1.0.3
-      exit: 0.1.2
-      glob: 7.2.3
+      exit-x: 0.2.2
+      glob: 10.5.0
       graceful-fs: 4.2.11
       istanbul-lib-coverage: 3.2.2
       istanbul-lib-instrument: 6.0.3
       istanbul-lib-report: 3.0.1
-      istanbul-lib-source-maps: 4.0.1
+      istanbul-lib-source-maps: 5.0.6
       istanbul-reports: 3.2.0
-      jest-message-util: 29.7.0
-      jest-util: 29.7.0
-      jest-worker: 29.7.0
+      jest-message-util: 30.4.1
+      jest-util: 30.4.1
+      jest-worker: 30.4.1
       slash: 3.0.0
       string-length: 4.0.2
-      strip-ansi: 6.0.1
       v8-to-istanbul: 9.3.0
     transitivePeerDependencies:
       - supports-color
 
-  '@jest/schemas@29.6.3':
+  '@jest/schemas@30.4.1':
     dependencies:
-      '@sinclair/typebox': 0.27.10
+      '@sinclair/typebox': 0.34.49
 
-  '@jest/schemas@30.0.5':
+  '@jest/snapshot-utils@30.4.1':
     dependencies:
-      '@sinclair/typebox': 0.34.49
+      '@jest/types': 30.4.1
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      natural-compare: 1.4.0
 
-  '@jest/source-map@29.6.3':
+  '@jest/source-map@30.0.1':
     dependencies:
       '@jridgewell/trace-mapping': 0.3.31
       callsites: 3.1.0
       graceful-fs: 4.2.11
 
-  '@jest/test-result@29.7.0':
+  '@jest/test-result@30.4.1':
     dependencies:
-      '@jest/console': 29.7.0
-      '@jest/types': 29.6.3
+      '@jest/console': 30.4.1
+      '@jest/types': 30.4.1
       '@types/istanbul-lib-coverage': 2.0.6
       collect-v8-coverage: 1.0.3
 
-  '@jest/test-sequencer@29.7.0':
+  '@jest/test-sequencer@30.4.1':
     dependencies:
-      '@jest/test-result': 29.7.0
+      '@jest/test-result': 30.4.1
       graceful-fs: 4.2.11
-      jest-haste-map: 29.7.0
+      jest-haste-map: 30.4.1
       slash: 3.0.0
 
-  '@jest/transform@29.7.0':
+  '@jest/transform@30.4.1':
     dependencies:
-      '@babel/core': 7.29.0
-      '@jest/types': 29.6.3
+      '@babel/core': 7.29.7
+      '@jest/types': 30.4.1
       '@jridgewell/trace-mapping': 0.3.31
-      babel-plugin-istanbul: 6.1.1
+      babel-plugin-istanbul: 7.0.1
       chalk: 4.1.2
       convert-source-map: 2.0.0
       fast-json-stable-stringify: 2.1.0
       graceful-fs: 4.2.11
-      jest-haste-map: 29.7.0
-      jest-regex-util: 29.6.3
-      jest-util: 29.7.0
-      micromatch: 4.0.8
+      jest-haste-map: 30.4.1
+      jest-regex-util: 30.4.0
+      jest-util: 30.4.1
       pirates: 4.0.7
       slash: 3.0.0
-      write-file-atomic: 4.0.2
+      write-file-atomic: 5.0.1
     transitivePeerDependencies:
       - supports-color
 
-  '@jest/types@29.6.3':
-    dependencies:
-      '@jest/schemas': 29.6.3
-      '@types/istanbul-lib-coverage': 2.0.6
-      '@types/istanbul-reports': 3.0.4
-      '@types/node': 25.5.2
-      '@types/yargs': 17.0.35
-      chalk: 4.1.2
-
-  '@jest/types@30.3.0':
+  '@jest/types@30.4.1':
     dependencies:
-      '@jest/pattern': 30.0.1
-      '@jest/schemas': 30.0.5
+      '@jest/pattern': 30.4.0
+      '@jest/schemas': 30.4.1
       '@types/istanbul-lib-coverage': 2.0.6
       '@types/istanbul-reports': 3.0.4
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@types/yargs': 17.0.35
       chalk: 4.1.2
 
@@ -8094,70 +8465,74 @@ snapshots:
 
   '@keyv/serialize@1.1.1': {}
 
-  '@lezer/common@1.3.0': {}
+  '@lezer/common@1.5.2': {}
 
-  '@lezer/highlight@1.2.2':
+  '@lezer/highlight@1.2.3':
     dependencies:
-      '@lezer/common': 1.3.0
+      '@lezer/common': 1.5.2
 
   '@lezer/javascript@1.5.4':
     dependencies:
-      '@lezer/common': 1.3.0
-      '@lezer/highlight': 1.2.2
-      '@lezer/lr': 1.4.2
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
 
-  '@lezer/lr@1.4.2':
+  '@lezer/lr@1.4.10':
     dependencies:
-      '@lezer/common': 1.3.0
+      '@lezer/common': 1.5.2
 
-  '@lit-labs/ssr-dom-shim@1.4.0': {}
+  '@lit-labs/ssr-dom-shim@1.6.0': {}
 
   '@lit/context@1.1.6':
     dependencies:
-      '@lit/reactive-element': 2.1.1
+      '@lit/reactive-element': 2.1.2
 
-  '@lit/reactive-element@2.1.1':
+  '@lit/reactive-element@2.1.2':
     dependencies:
-      '@lit-labs/ssr-dom-shim': 1.4.0
+      '@lit-labs/ssr-dom-shim': 1.6.0
 
   '@lukeed/ms@2.0.2': {}
 
   '@marijn/find-cluster-break@1.0.2': {}
 
-  '@microsoft/api-extractor-model@7.31.3(@types/node@25.5.2)':
+  '@microsoft/api-extractor-model@7.33.8(@types/node@25.9.1)':
     dependencies:
-      '@microsoft/tsdoc': 0.15.1
-      '@microsoft/tsdoc-config': 0.17.1
-      '@rushstack/node-core-library': 5.18.0(@types/node@25.5.2)
+      '@microsoft/tsdoc': 0.16.0
+      '@microsoft/tsdoc-config': 0.18.1
+      '@rushstack/node-core-library': 5.23.1(@types/node@25.9.1)
     transitivePeerDependencies:
       - '@types/node'
+    optional: true
 
-  '@microsoft/api-extractor@7.53.3(@types/node@25.5.2)':
-    dependencies:
-      '@microsoft/api-extractor-model': 7.31.3(@types/node@25.5.2)
-      '@microsoft/tsdoc': 0.15.1
-      '@microsoft/tsdoc-config': 0.17.1
-      '@rushstack/node-core-library': 5.18.0(@types/node@25.5.2)
-      '@rushstack/rig-package': 0.6.0
-      '@rushstack/terminal': 0.19.3(@types/node@25.5.2)
-      '@rushstack/ts-command-line': 5.1.3(@types/node@25.5.2)
-      lodash: 4.17.21
-      minimatch: 10.0.3
-      resolve: 1.22.11
-      semver: 7.5.4
+  '@microsoft/api-extractor@7.58.7(@types/node@25.9.1)':
+    dependencies:
+      '@microsoft/api-extractor-model': 7.33.8(@types/node@25.9.1)
+      '@microsoft/tsdoc': 0.16.0
+      '@microsoft/tsdoc-config': 0.18.1
+      '@rushstack/node-core-library': 5.23.1(@types/node@25.9.1)
+      '@rushstack/rig-package': 0.7.3
+      '@rushstack/terminal': 0.24.0(@types/node@25.9.1)
+      '@rushstack/ts-command-line': 5.3.9(@types/node@25.9.1)
+      diff: 8.0.4
+      minimatch: 10.2.3
+      resolve: 1.22.12
+      semver: 7.7.4
       source-map: 0.6.1
-      typescript: 5.8.2
+      typescript: 5.9.3
     transitivePeerDependencies:
       - '@types/node'
+    optional: true
 
-  '@microsoft/tsdoc-config@0.17.1':
+  '@microsoft/tsdoc-config@0.18.1':
     dependencies:
-      '@microsoft/tsdoc': 0.15.1
-      ajv: 8.12.0
+      '@microsoft/tsdoc': 0.16.0
+      ajv: 8.18.0
       jju: 1.4.0
-      resolve: 1.22.11
+      resolve: 1.22.12
+    optional: true
 
-  '@microsoft/tsdoc@0.15.1': {}
+  '@microsoft/tsdoc@0.16.0':
+    optional: true
 
   '@napi-rs/nice-android-arm-eabi@1.1.1':
     optional: true
@@ -8231,11 +8606,11 @@ snapshots:
       '@napi-rs/nice-win32-x64-msvc': 1.1.1
     optional: true
 
-  '@napi-rs/wasm-runtime@1.1.3(@emnapi/core@1.9.1)(@emnapi/runtime@1.9.1)':
+  '@napi-rs/wasm-runtime@1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)':
     dependencies:
-      '@emnapi/core': 1.9.1
-      '@emnapi/runtime': 1.9.1
-      '@tybys/wasm-util': 0.10.1
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@tybys/wasm-util': 0.10.2
     optional: true
 
   '@nightwatch/chai@5.0.3':
@@ -8253,6 +8628,8 @@ snapshots:
     dependencies:
       archiver: 5.3.2
 
+  '@nodable/entities@2.1.1': {}
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -8265,14 +8642,14 @@ snapshots:
       '@nodelib/fs.scandir': 2.1.5
       fastq: 1.20.1
 
-  '@oxc-project/types@0.123.0': {}
+  '@oxc-project/types@0.133.0': {}
 
   '@pinojs/redact@0.4.0': {}
 
   '@pkgjs/parseargs@0.11.0':
     optional: true
 
-  '@pkgr/core@0.2.9': {}
+  '@pkgr/core@0.3.6': {}
 
   '@polka/url@1.0.0-next.29': {}
 
@@ -8295,13 +8672,13 @@ snapshots:
       - react-native-b4a
       - supports-color
 
-  '@puppeteer/browsers@2.13.0':
+  '@puppeteer/browsers@2.13.2':
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       extract-zip: 2.0.1
       progress: 2.0.3
       proxy-agent: 6.5.0
-      semver: 7.7.4
+      semver: 7.8.1
       tar-fs: 3.1.2
       yargs: 17.7.2
     transitivePeerDependencies:
@@ -8310,185 +8687,188 @@ snapshots:
       - react-native-b4a
       - supports-color
 
-  '@rolldown/binding-android-arm64@1.0.0-rc.13':
+  '@rolldown/binding-android-arm64@1.0.3':
     optional: true
 
-  '@rolldown/binding-darwin-arm64@1.0.0-rc.13':
+  '@rolldown/binding-darwin-arm64@1.0.3':
     optional: true
 
-  '@rolldown/binding-darwin-x64@1.0.0-rc.13':
+  '@rolldown/binding-darwin-x64@1.0.3':
     optional: true
 
-  '@rolldown/binding-freebsd-x64@1.0.0-rc.13':
+  '@rolldown/binding-freebsd-x64@1.0.3':
     optional: true
 
-  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.13':
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.3':
     optional: true
 
-  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.13':
+  '@rolldown/binding-linux-arm64-gnu@1.0.3':
     optional: true
 
-  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.13':
+  '@rolldown/binding-linux-arm64-musl@1.0.3':
     optional: true
 
-  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.13':
+  '@rolldown/binding-linux-ppc64-gnu@1.0.3':
     optional: true
 
-  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.13':
+  '@rolldown/binding-linux-s390x-gnu@1.0.3':
     optional: true
 
-  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.13':
+  '@rolldown/binding-linux-x64-gnu@1.0.3':
     optional: true
 
-  '@rolldown/binding-linux-x64-musl@1.0.0-rc.13':
+  '@rolldown/binding-linux-x64-musl@1.0.3':
     optional: true
 
-  '@rolldown/binding-openharmony-arm64@1.0.0-rc.13':
+  '@rolldown/binding-openharmony-arm64@1.0.3':
     optional: true
 
-  '@rolldown/binding-wasm32-wasi@1.0.0-rc.13':
+  '@rolldown/binding-wasm32-wasi@1.0.3':
     dependencies:
-      '@emnapi/core': 1.9.1
-      '@emnapi/runtime': 1.9.1
-      '@napi-rs/wasm-runtime': 1.1.3(@emnapi/core@1.9.1)(@emnapi/runtime@1.9.1)
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@napi-rs/wasm-runtime': 1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
     optional: true
 
-  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.13':
+  '@rolldown/binding-win32-arm64-msvc@1.0.3':
     optional: true
 
-  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.13':
+  '@rolldown/binding-win32-x64-msvc@1.0.3':
     optional: true
 
-  '@rolldown/pluginutils@1.0.0-rc.13': {}
+  '@rolldown/pluginutils@1.0.1': {}
 
-  '@rollup/pluginutils@5.3.0(rollup@4.60.1)':
+  '@rollup/pluginutils@5.4.0(rollup@4.61.0)':
     dependencies:
-      '@types/estree': 1.0.8
+      '@types/estree': 1.0.9
       estree-walker: 2.0.2
       picomatch: 4.0.4
     optionalDependencies:
-      rollup: 4.60.1
+      rollup: 4.61.0
 
-  '@rollup/rollup-android-arm-eabi@4.60.1':
+  '@rollup/rollup-android-arm-eabi@4.61.0':
     optional: true
 
-  '@rollup/rollup-android-arm64@4.60.1':
+  '@rollup/rollup-android-arm64@4.61.0':
     optional: true
 
-  '@rollup/rollup-darwin-arm64@4.60.1':
+  '@rollup/rollup-darwin-arm64@4.61.0':
     optional: true
 
-  '@rollup/rollup-darwin-x64@4.60.1':
+  '@rollup/rollup-darwin-x64@4.61.0':
     optional: true
 
-  '@rollup/rollup-freebsd-arm64@4.60.1':
+  '@rollup/rollup-freebsd-arm64@4.61.0':
     optional: true
 
-  '@rollup/rollup-freebsd-x64@4.60.1':
+  '@rollup/rollup-freebsd-x64@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.60.1':
+  '@rollup/rollup-linux-arm-gnueabihf@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-arm-musleabihf@4.60.1':
+  '@rollup/rollup-linux-arm-musleabihf@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-arm64-gnu@4.60.1':
+  '@rollup/rollup-linux-arm64-gnu@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-arm64-musl@4.60.1':
+  '@rollup/rollup-linux-arm64-musl@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-loong64-gnu@4.60.1':
+  '@rollup/rollup-linux-loong64-gnu@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-loong64-musl@4.60.1':
+  '@rollup/rollup-linux-loong64-musl@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-ppc64-gnu@4.60.1':
+  '@rollup/rollup-linux-ppc64-gnu@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-ppc64-musl@4.60.1':
+  '@rollup/rollup-linux-ppc64-musl@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-gnu@4.60.1':
+  '@rollup/rollup-linux-riscv64-gnu@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-musl@4.60.1':
+  '@rollup/rollup-linux-riscv64-musl@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-s390x-gnu@4.60.1':
+  '@rollup/rollup-linux-s390x-gnu@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-x64-gnu@4.60.1':
+  '@rollup/rollup-linux-x64-gnu@4.61.0':
     optional: true
 
-  '@rollup/rollup-linux-x64-musl@4.60.1':
+  '@rollup/rollup-linux-x64-musl@4.61.0':
     optional: true
 
-  '@rollup/rollup-openbsd-x64@4.60.1':
+  '@rollup/rollup-openbsd-x64@4.61.0':
     optional: true
 
-  '@rollup/rollup-openharmony-arm64@4.60.1':
+  '@rollup/rollup-openharmony-arm64@4.61.0':
     optional: true
 
-  '@rollup/rollup-win32-arm64-msvc@4.60.1':
+  '@rollup/rollup-win32-arm64-msvc@4.61.0':
     optional: true
 
-  '@rollup/rollup-win32-ia32-msvc@4.60.1':
+  '@rollup/rollup-win32-ia32-msvc@4.61.0':
     optional: true
 
-  '@rollup/rollup-win32-x64-gnu@4.60.1':
+  '@rollup/rollup-win32-x64-gnu@4.61.0':
     optional: true
 
-  '@rollup/rollup-win32-x64-msvc@4.60.1':
+  '@rollup/rollup-win32-x64-msvc@4.61.0':
     optional: true
 
   '@rtsao/scc@1.1.0': {}
 
-  '@rushstack/node-core-library@5.18.0(@types/node@25.5.2)':
+  '@rushstack/node-core-library@5.23.1(@types/node@25.9.1)':
     dependencies:
-      ajv: 8.13.0
-      ajv-draft-04: 1.0.0(ajv@8.13.0)
-      ajv-formats: 3.0.1(ajv@8.13.0)
-      fs-extra: 11.3.2
+      ajv: 8.18.0
+      ajv-draft-04: 1.0.0(ajv@8.18.0)
+      ajv-formats: 3.0.1(ajv@8.18.0)
+      fs-extra: 11.3.5
       import-lazy: 4.0.0
       jju: 1.4.0
-      resolve: 1.22.11
-      semver: 7.5.4
+      resolve: 1.22.12
+      semver: 7.7.4
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
+    optional: true
 
-  '@rushstack/problem-matcher@0.1.1(@types/node@25.5.2)':
+  '@rushstack/problem-matcher@0.2.1(@types/node@25.9.1)':
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
+    optional: true
 
-  '@rushstack/rig-package@0.6.0':
+  '@rushstack/rig-package@0.7.3':
     dependencies:
-      resolve: 1.22.11
-      strip-json-comments: 3.1.1
+      jju: 1.4.0
+      resolve: 1.22.12
+    optional: true
 
-  '@rushstack/terminal@0.19.3(@types/node@25.5.2)':
+  '@rushstack/terminal@0.24.0(@types/node@25.9.1)':
     dependencies:
-      '@rushstack/node-core-library': 5.18.0(@types/node@25.5.2)
-      '@rushstack/problem-matcher': 0.1.1(@types/node@25.5.2)
+      '@rushstack/node-core-library': 5.23.1(@types/node@25.9.1)
+      '@rushstack/problem-matcher': 0.2.1(@types/node@25.9.1)
       supports-color: 8.1.1
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
+    optional: true
 
-  '@rushstack/ts-command-line@5.1.3(@types/node@25.5.2)':
+  '@rushstack/ts-command-line@5.3.9(@types/node@25.9.1)':
     dependencies:
-      '@rushstack/terminal': 0.19.3(@types/node@25.5.2)
+      '@rushstack/terminal': 0.24.0(@types/node@25.9.1)
       '@types/argparse': 1.0.38
       argparse: 1.0.10
       string-argv: 0.3.2
     transitivePeerDependencies:
       - '@types/node'
+    optional: true
 
   '@sec-ant/readable-stream@0.4.1': {}
 
-  '@sinclair/typebox@0.27.10': {}
-
   '@sinclair/typebox@0.34.49': {}
 
   '@sindresorhus/merge-streams@4.0.0': {}
@@ -8497,80 +8877,80 @@ snapshots:
     dependencies:
       type-detect: 4.0.8
 
-  '@sinonjs/fake-timers@10.3.0':
+  '@sinonjs/fake-timers@15.4.0':
     dependencies:
       '@sinonjs/commons': 3.0.1
 
   '@standard-schema/spec@1.1.0': {}
 
-  '@tailwindcss/node@4.2.2':
+  '@tailwindcss/node@4.3.0':
     dependencies:
       '@jridgewell/remapping': 2.3.5
-      enhanced-resolve: 5.20.1
-      jiti: 2.6.1
+      enhanced-resolve: 5.22.1
+      jiti: 2.7.0
       lightningcss: 1.32.0
       magic-string: 0.30.21
       source-map-js: 1.2.1
-      tailwindcss: 4.2.2
+      tailwindcss: 4.3.0
 
-  '@tailwindcss/oxide-android-arm64@4.2.2':
+  '@tailwindcss/oxide-android-arm64@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-darwin-arm64@4.2.2':
+  '@tailwindcss/oxide-darwin-arm64@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-darwin-x64@4.2.2':
+  '@tailwindcss/oxide-darwin-x64@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-freebsd-x64@4.2.2':
+  '@tailwindcss/oxide-freebsd-x64@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.2':
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-linux-arm64-gnu@4.2.2':
+  '@tailwindcss/oxide-linux-arm64-gnu@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-linux-arm64-musl@4.2.2':
+  '@tailwindcss/oxide-linux-arm64-musl@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-linux-x64-gnu@4.2.2':
+  '@tailwindcss/oxide-linux-x64-gnu@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-linux-x64-musl@4.2.2':
+  '@tailwindcss/oxide-linux-x64-musl@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-wasm32-wasi@4.2.2':
+  '@tailwindcss/oxide-wasm32-wasi@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-win32-arm64-msvc@4.2.2':
+  '@tailwindcss/oxide-win32-arm64-msvc@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide-win32-x64-msvc@4.2.2':
+  '@tailwindcss/oxide-win32-x64-msvc@4.3.0':
     optional: true
 
-  '@tailwindcss/oxide@4.2.2':
+  '@tailwindcss/oxide@4.3.0':
     optionalDependencies:
-      '@tailwindcss/oxide-android-arm64': 4.2.2
-      '@tailwindcss/oxide-darwin-arm64': 4.2.2
-      '@tailwindcss/oxide-darwin-x64': 4.2.2
-      '@tailwindcss/oxide-freebsd-x64': 4.2.2
-      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.2.2
-      '@tailwindcss/oxide-linux-arm64-gnu': 4.2.2
-      '@tailwindcss/oxide-linux-arm64-musl': 4.2.2
-      '@tailwindcss/oxide-linux-x64-gnu': 4.2.2
-      '@tailwindcss/oxide-linux-x64-musl': 4.2.2
-      '@tailwindcss/oxide-wasm32-wasi': 4.2.2
-      '@tailwindcss/oxide-win32-arm64-msvc': 4.2.2
-      '@tailwindcss/oxide-win32-x64-msvc': 4.2.2
-
-  '@tailwindcss/postcss@4.2.2':
+      '@tailwindcss/oxide-android-arm64': 4.3.0
+      '@tailwindcss/oxide-darwin-arm64': 4.3.0
+      '@tailwindcss/oxide-darwin-x64': 4.3.0
+      '@tailwindcss/oxide-freebsd-x64': 4.3.0
+      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.3.0
+      '@tailwindcss/oxide-linux-arm64-gnu': 4.3.0
+      '@tailwindcss/oxide-linux-arm64-musl': 4.3.0
+      '@tailwindcss/oxide-linux-x64-gnu': 4.3.0
+      '@tailwindcss/oxide-linux-x64-musl': 4.3.0
+      '@tailwindcss/oxide-wasm32-wasi': 4.3.0
+      '@tailwindcss/oxide-win32-arm64-msvc': 4.3.0
+      '@tailwindcss/oxide-win32-x64-msvc': 4.3.0
+
+  '@tailwindcss/postcss@4.3.0':
     dependencies:
       '@alloc/quick-lru': 5.2.0
-      '@tailwindcss/node': 4.2.2
-      '@tailwindcss/oxide': 4.2.2
-      postcss: 8.5.6
-      tailwindcss: 4.2.2
+      '@tailwindcss/node': 4.3.0
+      '@tailwindcss/oxide': 4.3.0
+      postcss: 8.5.15
+      tailwindcss: 4.3.0
 
   '@teppeis/multimaps@3.0.0': {}
 
@@ -8578,7 +8958,7 @@ snapshots:
 
   '@tootallnate/quickjs-emscripten@0.23.0': {}
 
-  '@tsconfig/node10@1.0.11': {}
+  '@tsconfig/node10@1.0.12': {}
 
   '@tsconfig/node12@1.0.11': {}
 
@@ -8586,33 +8966,34 @@ snapshots:
 
   '@tsconfig/node16@1.0.4': {}
 
-  '@tybys/wasm-util@0.10.1':
+  '@tybys/wasm-util@0.10.2':
     dependencies:
       tslib: 2.8.1
     optional: true
 
-  '@types/argparse@1.0.38': {}
+  '@types/argparse@1.0.38':
+    optional: true
 
   '@types/babel__core@7.20.5':
     dependencies:
-      '@babel/parser': 7.29.2
-      '@babel/types': 7.29.0
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
       '@types/babel__generator': 7.27.0
       '@types/babel__template': 7.4.4
       '@types/babel__traverse': 7.28.0
 
   '@types/babel__generator@7.27.0':
     dependencies:
-      '@babel/types': 7.29.0
+      '@babel/types': 7.29.7
 
   '@types/babel__template@7.4.4':
     dependencies:
-      '@babel/parser': 7.29.2
-      '@babel/types': 7.29.0
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
 
   '@types/babel__traverse@7.28.0':
     dependencies:
-      '@babel/types': 7.29.0
+      '@babel/types': 7.29.7
 
   '@types/chai@4.3.20': {}
 
@@ -8625,15 +9006,11 @@ snapshots:
 
   '@types/esrecurse@4.3.1': {}
 
-  '@types/estree@1.0.8': {}
+  '@types/estree@1.0.9': {}
 
   '@types/fluent-ffmpeg@2.1.28':
     dependencies:
-      '@types/node': 25.5.2
-
-  '@types/graceful-fs@4.1.9':
-    dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
   '@types/istanbul-lib-coverage@2.0.6': {}
 
@@ -8649,15 +9026,15 @@ snapshots:
 
   '@types/json5@0.0.29': {}
 
-  '@types/node@25.5.2':
+  '@types/node@25.9.1':
     dependencies:
-      undici-types: 7.18.2
+      undici-types: 7.24.6
 
   '@types/normalize-package-data@2.4.4': {}
 
-  '@types/selenium-webdriver@4.35.5':
+  '@types/selenium-webdriver@4.35.6':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@types/ws': 8.18.1
 
   '@types/shell-quote@1.7.5': {}
@@ -8680,7 +9057,7 @@ snapshots:
 
   '@types/ws@8.18.1':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
   '@types/yargs-parser@21.0.3': {}
 
@@ -8690,165 +9067,233 @@ snapshots:
 
   '@types/yauzl@2.10.3':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
     optional: true
 
-  '@typescript-eslint/eslint-plugin@8.58.1(@typescript-eslint/parser@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2))(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)':
+  '@typescript-eslint/eslint-plugin@8.60.1(@typescript-eslint/parser@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3))(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
-      '@typescript-eslint/scope-manager': 8.58.1
-      '@typescript-eslint/type-utils': 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
-      '@typescript-eslint/utils': 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
-      '@typescript-eslint/visitor-keys': 8.58.1
-      eslint: 10.2.0(jiti@2.6.1)
+      '@typescript-eslint/parser': 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
+      '@typescript-eslint/scope-manager': 8.60.1
+      '@typescript-eslint/type-utils': 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
+      '@typescript-eslint/utils': 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
+      '@typescript-eslint/visitor-keys': 8.60.1
+      eslint: 10.4.1(jiti@2.7.0)
       ignore: 7.0.5
       natural-compare: 1.4.0
-      ts-api-utils: 2.5.0(typescript@6.0.2)
-      typescript: 6.0.2
+      ts-api-utils: 2.5.0(typescript@6.0.3)
+      typescript: 6.0.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)':
+  '@typescript-eslint/parser@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)':
     dependencies:
-      '@typescript-eslint/scope-manager': 8.58.1
-      '@typescript-eslint/types': 8.58.1
-      '@typescript-eslint/typescript-estree': 8.58.1(typescript@6.0.2)
-      '@typescript-eslint/visitor-keys': 8.58.1
-      debug: 4.4.3
-      eslint: 10.2.0(jiti@2.6.1)
-      typescript: 6.0.2
+      '@typescript-eslint/scope-manager': 8.60.1
+      '@typescript-eslint/types': 8.60.1
+      '@typescript-eslint/typescript-estree': 8.60.1(typescript@6.0.3)
+      '@typescript-eslint/visitor-keys': 8.60.1
+      debug: 4.4.3(supports-color@5.5.0)
+      eslint: 10.4.1(jiti@2.7.0)
+      typescript: 6.0.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.58.1(typescript@6.0.2)':
+  '@typescript-eslint/project-service@8.60.1(typescript@6.0.3)':
     dependencies:
-      '@typescript-eslint/tsconfig-utils': 8.58.1(typescript@6.0.2)
-      '@typescript-eslint/types': 8.58.1
-      debug: 4.4.3
-      typescript: 6.0.2
+      '@typescript-eslint/tsconfig-utils': 8.60.1(typescript@6.0.3)
+      '@typescript-eslint/types': 8.60.1
+      debug: 4.4.3(supports-color@5.5.0)
+      typescript: 6.0.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/scope-manager@8.58.1':
+  '@typescript-eslint/scope-manager@8.60.1':
     dependencies:
-      '@typescript-eslint/types': 8.58.1
-      '@typescript-eslint/visitor-keys': 8.58.1
+      '@typescript-eslint/types': 8.60.1
+      '@typescript-eslint/visitor-keys': 8.60.1
 
-  '@typescript-eslint/tsconfig-utils@8.58.1(typescript@6.0.2)':
+  '@typescript-eslint/tsconfig-utils@8.60.1(typescript@6.0.3)':
     dependencies:
-      typescript: 6.0.2
+      typescript: 6.0.3
 
-  '@typescript-eslint/type-utils@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)':
+  '@typescript-eslint/type-utils@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)':
     dependencies:
-      '@typescript-eslint/types': 8.58.1
-      '@typescript-eslint/typescript-estree': 8.58.1(typescript@6.0.2)
-      '@typescript-eslint/utils': 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
-      debug: 4.4.3
-      eslint: 10.2.0(jiti@2.6.1)
-      ts-api-utils: 2.5.0(typescript@6.0.2)
-      typescript: 6.0.2
+      '@typescript-eslint/types': 8.60.1
+      '@typescript-eslint/typescript-estree': 8.60.1(typescript@6.0.3)
+      '@typescript-eslint/utils': 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
+      debug: 4.4.3(supports-color@5.5.0)
+      eslint: 10.4.1(jiti@2.7.0)
+      ts-api-utils: 2.5.0(typescript@6.0.3)
+      typescript: 6.0.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/types@8.58.1': {}
+  '@typescript-eslint/types@8.60.1': {}
 
-  '@typescript-eslint/typescript-estree@8.58.1(typescript@6.0.2)':
+  '@typescript-eslint/typescript-estree@8.60.1(typescript@6.0.3)':
     dependencies:
-      '@typescript-eslint/project-service': 8.58.1(typescript@6.0.2)
-      '@typescript-eslint/tsconfig-utils': 8.58.1(typescript@6.0.2)
-      '@typescript-eslint/types': 8.58.1
-      '@typescript-eslint/visitor-keys': 8.58.1
-      debug: 4.4.3
+      '@typescript-eslint/project-service': 8.60.1(typescript@6.0.3)
+      '@typescript-eslint/tsconfig-utils': 8.60.1(typescript@6.0.3)
+      '@typescript-eslint/types': 8.60.1
+      '@typescript-eslint/visitor-keys': 8.60.1
+      debug: 4.4.3(supports-color@5.5.0)
       minimatch: 10.2.5
-      semver: 7.7.4
-      tinyglobby: 0.2.16
-      ts-api-utils: 2.5.0(typescript@6.0.2)
-      typescript: 6.0.2
+      semver: 7.8.1
+      tinyglobby: 0.2.17
+      ts-api-utils: 2.5.0(typescript@6.0.3)
+      typescript: 6.0.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/utils@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)':
+  '@typescript-eslint/utils@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@10.2.0(jiti@2.6.1))
-      '@typescript-eslint/scope-manager': 8.58.1
-      '@typescript-eslint/types': 8.58.1
-      '@typescript-eslint/typescript-estree': 8.58.1(typescript@6.0.2)
-      eslint: 10.2.0(jiti@2.6.1)
-      typescript: 6.0.2
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.4.1(jiti@2.7.0))
+      '@typescript-eslint/scope-manager': 8.60.1
+      '@typescript-eslint/types': 8.60.1
+      '@typescript-eslint/typescript-estree': 8.60.1(typescript@6.0.3)
+      eslint: 10.4.1(jiti@2.7.0)
+      typescript: 6.0.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/visitor-keys@8.58.1':
+  '@typescript-eslint/visitor-keys@8.60.1':
     dependencies:
-      '@typescript-eslint/types': 8.58.1
+      '@typescript-eslint/types': 8.60.1
       eslint-visitor-keys: 5.0.1
 
-  '@vitest/browser@4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)))':
+  '@ungap/structured-clone@1.3.1': {}
+
+  '@unrs/resolver-binding-android-arm-eabi@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-android-arm64@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-darwin-arm64@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-darwin-x64@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-freebsd-x64@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-arm-gnueabihf@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-arm-musleabihf@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-arm64-gnu@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-arm64-musl@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-loong64-gnu@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-loong64-musl@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-ppc64-gnu@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-riscv64-gnu@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-riscv64-musl@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-s390x-gnu@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-x64-gnu@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-linux-x64-musl@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-openharmony-arm64@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-wasm32-wasi@1.12.2':
+    dependencies:
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@napi-rs/wasm-runtime': 1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
+    optional: true
+
+  '@unrs/resolver-binding-win32-arm64-msvc@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-win32-ia32-msvc@1.12.2':
+    optional: true
+
+  '@unrs/resolver-binding-win32-x64-msvc@1.12.2':
+    optional: true
+
+  '@vitest/browser@4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))(vitest@4.1.8)':
     dependencies:
       '@blazediff/core': 1.9.1
-      '@vitest/mocker': 4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
-      '@vitest/utils': 4.1.3
+      '@vitest/mocker': 4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+      '@vitest/utils': 4.1.8
       magic-string: 0.30.21
       pngjs: 7.0.0
       sirv: 3.0.2
       tinyrainbow: 3.1.0
-      vitest: 4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
-      ws: 8.20.0
+      vitest: 4.1.8(@types/node@25.9.1)(@vitest/coverage-v8@4.1.8)(happy-dom@20.9.0)(jsdom@24.1.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+      ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
       - msw
       - utf-8-validate
       - vite
 
-  '@vitest/expect@2.1.9':
+  '@vitest/coverage-v8@4.1.8(@vitest/browser@4.1.8)(vitest@4.1.8)':
     dependencies:
-      '@vitest/spy': 2.1.9
-      '@vitest/utils': 2.1.9
-      chai: 5.3.3
-      tinyrainbow: 1.2.0
+      '@bcoe/v8-coverage': 1.0.2
+      '@vitest/utils': 4.1.8
+      ast-v8-to-istanbul: 1.0.3
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-reports: 3.2.0
+      magicast: 0.5.3
+      obug: 2.1.1
+      std-env: 4.1.0
+      tinyrainbow: 3.1.0
+      vitest: 4.1.8(@types/node@25.9.1)(@vitest/coverage-v8@4.1.8)(happy-dom@20.9.0)(jsdom@24.1.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+    optionalDependencies:
+      '@vitest/browser': 4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))(vitest@4.1.8)
 
-  '@vitest/expect@4.1.3':
+  '@vitest/expect@4.1.8':
     dependencies:
       '@standard-schema/spec': 1.1.0
       '@types/chai': 5.2.3
-      '@vitest/spy': 4.1.3
-      '@vitest/utils': 4.1.3
+      '@vitest/spy': 4.1.8
+      '@vitest/utils': 4.1.8
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
-  '@vitest/mocker@2.1.9(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))':
-    dependencies:
-      '@vitest/spy': 2.1.9
-      estree-walker: 3.0.3
-      magic-string: 0.30.21
-    optionalDependencies:
-      vite: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
-
-  '@vitest/mocker@4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))':
+  '@vitest/mocker@4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))':
     dependencies:
-      '@vitest/spy': 4.1.3
+      '@vitest/spy': 4.1.8
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
 
   '@vitest/pretty-format@2.1.9':
     dependencies:
       tinyrainbow: 1.2.0
 
-  '@vitest/pretty-format@4.1.3':
+  '@vitest/pretty-format@4.1.8':
     dependencies:
       tinyrainbow: 3.1.0
 
-  '@vitest/runner@2.1.9':
-    dependencies:
-      '@vitest/utils': 2.1.9
-      pathe: 1.1.2
-
-  '@vitest/runner@4.1.3':
+  '@vitest/runner@4.1.8':
     dependencies:
-      '@vitest/utils': 4.1.3
+      '@vitest/utils': 4.1.8
       pathe: 2.0.3
 
   '@vitest/snapshot@2.1.9':
@@ -8857,97 +9302,54 @@ snapshots:
       magic-string: 0.30.21
       pathe: 1.1.2
 
-  '@vitest/snapshot@4.1.3':
+  '@vitest/snapshot@4.1.8':
     dependencies:
-      '@vitest/pretty-format': 4.1.3
-      '@vitest/utils': 4.1.3
+      '@vitest/pretty-format': 4.1.8
+      '@vitest/utils': 4.1.8
       magic-string: 0.30.21
       pathe: 2.0.3
 
-  '@vitest/spy@2.1.9':
-    dependencies:
-      tinyspy: 3.0.2
-
-  '@vitest/spy@4.1.3': {}
-
-  '@vitest/utils@2.1.9':
-    dependencies:
-      '@vitest/pretty-format': 2.1.9
-      loupe: 3.2.1
-      tinyrainbow: 1.2.0
+  '@vitest/spy@4.1.8': {}
 
-  '@vitest/utils@4.1.3':
+  '@vitest/utils@4.1.8':
     dependencies:
-      '@vitest/pretty-format': 4.1.3
+      '@vitest/pretty-format': 4.1.8
       convert-source-map: 2.0.0
       tinyrainbow: 3.1.0
 
-  '@volar/language-core@2.4.23':
+  '@volar/language-core@2.4.28':
     dependencies:
-      '@volar/source-map': 2.4.23
+      '@volar/source-map': 2.4.28
 
-  '@volar/source-map@2.4.23': {}
+  '@volar/source-map@2.4.28': {}
 
-  '@volar/typescript@2.4.23':
+  '@volar/typescript@2.4.28':
     dependencies:
-      '@volar/language-core': 2.4.23
+      '@volar/language-core': 2.4.28
       path-browserify: 1.0.1
       vscode-uri: 3.1.0
 
-  '@vue/compiler-core@3.5.22':
-    dependencies:
-      '@babel/parser': 7.29.2
-      '@vue/shared': 3.5.22
-      entities: 4.5.0
-      estree-walker: 2.0.2
-      source-map-js: 1.2.1
-
-  '@vue/compiler-dom@3.5.22':
-    dependencies:
-      '@vue/compiler-core': 3.5.22
-      '@vue/shared': 3.5.22
-
-  '@vue/compiler-vue2@2.7.16':
-    dependencies:
-      de-indent: 1.0.2
-      he: 1.2.0
-
-  '@vue/language-core@2.2.0(typescript@6.0.2)':
-    dependencies:
-      '@volar/language-core': 2.4.23
-      '@vue/compiler-dom': 3.5.22
-      '@vue/compiler-vue2': 2.7.16
-      '@vue/shared': 3.5.22
-      alien-signals: 0.4.14
-      minimatch: 9.0.9
-      muggle-string: 0.4.1
-      path-browserify: 1.0.1
-    optionalDependencies:
-      typescript: 6.0.2
-
-  '@vue/shared@3.5.22': {}
-
-  '@wdio/cli@9.27.0(@types/node@25.5.2)(expect-webdriverio@5.6.5)(puppeteer-core@21.11.0)':
+  '@wdio/cli@9.27.2(@types/node@25.9.1)(expect-webdriverio@5.6.7)(puppeteer-core@21.11.0)':
     dependencies:
       '@vitest/snapshot': 2.1.9
-      '@wdio/config': 9.27.0
-      '@wdio/globals': 9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+      '@wdio/config': 9.27.2
+      '@wdio/globals': 9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       '@wdio/logger': 9.18.0
-      '@wdio/protocols': 9.27.0
-      '@wdio/types': 9.27.0
-      '@wdio/utils': 9.27.0
+      '@wdio/protocols': 9.27.2
+      '@wdio/types': 9.27.2
+      '@wdio/utils': 9.27.2
       async-exit-hook: 2.0.1
       chalk: 5.6.2
       chokidar: 4.0.3
-      create-wdio: 9.27.0(@types/node@25.5.2)
-      dotenv: 17.4.1
+      create-wdio: 9.27.2(@types/node@25.9.1)
+      dotenv: 17.4.2
       import-meta-resolve: 4.2.0
       lodash.flattendeep: 4.4.0
       lodash.pickby: 4.6.0
       lodash.union: 4.6.0
       read-pkg-up: 10.1.0
-      tsx: 4.21.0
-      webdriverio: 9.27.0(puppeteer-core@21.11.0)
+      tsx: 4.22.4
+      webdriverio: 9.27.2(puppeteer-core@21.11.0)
       yargs: 17.7.2
     transitivePeerDependencies:
       - '@types/node'
@@ -8975,30 +9377,30 @@ snapshots:
       - react-native-b4a
       - supports-color
 
-  '@wdio/config@9.27.0':
+  '@wdio/config@9.27.2':
     dependencies:
       '@wdio/logger': 9.18.0
-      '@wdio/types': 9.27.0
-      '@wdio/utils': 9.27.0
+      '@wdio/types': 9.27.2
+      '@wdio/utils': 9.27.2
       deepmerge-ts: 7.1.5
       glob: 10.5.0
       import-meta-resolve: 4.2.0
-      jiti: 2.6.1
+      jiti: 2.7.0
     transitivePeerDependencies:
       - bare-abort-controller
       - bare-buffer
       - react-native-b4a
       - supports-color
 
-  '@wdio/cucumber-framework@9.27.0':
+  '@wdio/cucumber-framework@9.27.2':
     dependencies:
       '@cucumber/cucumber': 10.9.0
       '@cucumber/gherkin': 29.0.0
       '@cucumber/messages': 26.0.1
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@wdio/logger': 9.18.0
-      '@wdio/types': 9.27.0
-      '@wdio/utils': 9.27.0
+      '@wdio/types': 9.27.2
+      '@wdio/utils': 9.27.2
       glob: 10.5.0
       import-meta-resolve: 4.2.0
       is-glob: 4.0.3
@@ -9008,27 +9410,27 @@ snapshots:
       - react-native-b4a
       - supports-color
 
-  '@wdio/dot-reporter@9.27.0':
+  '@wdio/dot-reporter@9.27.2':
     dependencies:
-      '@wdio/reporter': 9.27.0
-      '@wdio/types': 9.27.0
+      '@wdio/reporter': 9.27.2
+      '@wdio/types': 9.27.2
       chalk: 5.6.2
 
-  '@wdio/globals@9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))':
+  '@wdio/globals@9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))':
     dependencies:
-      expect-webdriverio: 5.6.5(@wdio/globals@9.27.0)(@wdio/logger@9.18.0)(webdriverio@9.27.0(puppeteer-core@21.11.0))
-      webdriverio: 9.27.0(puppeteer-core@21.11.0)
+      expect-webdriverio: 5.6.7(@wdio/globals@9.27.2)(@wdio/logger@9.18.0)(webdriverio@9.27.2(puppeteer-core@21.11.0))
+      webdriverio: 9.27.2(puppeteer-core@21.11.0)
 
-  '@wdio/local-runner@9.27.0(@wdio/globals@9.27.0)(webdriverio@9.27.0(puppeteer-core@21.11.0))':
+  '@wdio/local-runner@9.27.2(@wdio/globals@9.27.2)(webdriverio@9.27.2(puppeteer-core@21.11.0))':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@wdio/logger': 9.18.0
       '@wdio/repl': 9.16.2
-      '@wdio/runner': 9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))
-      '@wdio/types': 9.27.0
-      '@wdio/xvfb': 9.27.0
+      '@wdio/runner': 9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))
+      '@wdio/types': 9.27.2
+      '@wdio/xvfb': 9.27.2
       exit-hook: 4.0.0
-      expect-webdriverio: 5.6.5(@wdio/globals@9.27.0)(@wdio/logger@9.18.0)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+      expect-webdriverio: 5.6.7(@wdio/globals@9.27.2)(@wdio/logger@9.18.0)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       split2: 4.2.0
       stream-buffers: 3.0.3
     transitivePeerDependencies:
@@ -9053,38 +9455,38 @@ snapshots:
       chalk: 5.6.2
       loglevel: 1.9.2
       loglevel-plugin-prefix: 0.8.4
-      safe-regex2: 5.0.0
-      strip-ansi: 7.1.2
+      safe-regex2: 5.1.1
+      strip-ansi: 7.2.0
 
   '@wdio/protocols@8.40.3': {}
 
-  '@wdio/protocols@9.27.0': {}
+  '@wdio/protocols@9.27.2': {}
 
   '@wdio/repl@9.16.2':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@wdio/reporter@9.27.0':
+  '@wdio/reporter@9.27.2':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@wdio/logger': 9.18.0
-      '@wdio/types': 9.27.0
+      '@wdio/types': 9.27.2
       diff: 8.0.4
       object-inspect: 1.13.4
 
-  '@wdio/runner@9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))':
+  '@wdio/runner@9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))':
     dependencies:
-      '@types/node': 25.5.2
-      '@wdio/config': 9.27.0
-      '@wdio/dot-reporter': 9.27.0
-      '@wdio/globals': 9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+      '@types/node': 25.9.1
+      '@wdio/config': 9.27.2
+      '@wdio/dot-reporter': 9.27.2
+      '@wdio/globals': 9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       '@wdio/logger': 9.18.0
-      '@wdio/types': 9.27.0
-      '@wdio/utils': 9.27.0
+      '@wdio/types': 9.27.2
+      '@wdio/utils': 9.27.2
       deepmerge-ts: 7.1.5
-      expect-webdriverio: 5.6.5(@wdio/globals@9.27.0)(@wdio/logger@9.18.0)(webdriverio@9.27.0(puppeteer-core@21.11.0))
-      webdriver: 9.27.0
-      webdriverio: 9.27.0(puppeteer-core@21.11.0)
+      expect-webdriverio: 5.6.7(@wdio/globals@9.27.2)(@wdio/logger@9.18.0)(webdriverio@9.27.2(puppeteer-core@21.11.0))
+      webdriver: 9.27.2
+      webdriverio: 9.27.2(puppeteer-core@21.11.0)
     transitivePeerDependencies:
       - bare-abort-controller
       - bare-buffer
@@ -9093,21 +9495,21 @@ snapshots:
       - supports-color
       - utf-8-validate
 
-  '@wdio/spec-reporter@9.27.0':
+  '@wdio/spec-reporter@9.27.2':
     dependencies:
-      '@wdio/reporter': 9.27.0
-      '@wdio/types': 9.27.0
+      '@wdio/reporter': 9.27.2
+      '@wdio/types': 9.27.2
       chalk: 5.6.2
       easy-table: 1.2.0
       pretty-ms: 9.3.0
 
   '@wdio/types@8.41.0':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
-  '@wdio/types@9.27.0':
+  '@wdio/types@9.27.2':
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
   '@wdio/utils@8.41.0':
     dependencies:
@@ -9130,11 +9532,11 @@ snapshots:
       - react-native-b4a
       - supports-color
 
-  '@wdio/utils@9.27.0':
+  '@wdio/utils@9.27.2':
     dependencies:
-      '@puppeteer/browsers': 2.13.0
+      '@puppeteer/browsers': 2.13.2
       '@wdio/logger': 9.18.0
-      '@wdio/types': 9.27.0
+      '@wdio/types': 9.27.2
       decamelize: 6.0.1
       deepmerge-ts: 7.1.5
       edgedriver: 6.3.0
@@ -9152,7 +9554,7 @@ snapshots:
       - react-native-b4a
       - supports-color
 
-  '@wdio/xvfb@9.27.0':
+  '@wdio/xvfb@9.27.2':
     dependencies:
       '@wdio/logger': 9.18.0
 
@@ -9168,11 +9570,9 @@ snapshots:
     dependencies:
       acorn: 8.16.0
 
-  acorn-walk@8.3.4:
+  acorn-walk@8.3.5:
     dependencies:
-      acorn: 8.15.0
-
-  acorn@8.15.0: {}
+      acorn: 8.16.0
 
   acorn@8.16.0: {}
 
@@ -9180,7 +9580,7 @@ snapshots:
 
   agent-base@6.0.2:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -9188,48 +9588,42 @@ snapshots:
 
   agent-base@9.0.0: {}
 
-  ajv-draft-04@1.0.0(ajv@8.13.0):
+  ajv-draft-04@1.0.0(ajv@8.18.0):
     optionalDependencies:
-      ajv: 8.13.0
-
-  ajv-formats@3.0.1(ajv@8.13.0):
-    optionalDependencies:
-      ajv: 8.13.0
+      ajv: 8.18.0
+    optional: true
 
   ajv-formats@3.0.1(ajv@8.18.0):
     optionalDependencies:
       ajv: 8.18.0
+    optional: true
+
+  ajv-formats@3.0.1(ajv@8.20.0):
+    optionalDependencies:
+      ajv: 8.20.0
 
-  ajv@6.14.0:
+  ajv@6.15.0:
     dependencies:
       fast-deep-equal: 3.1.3
       fast-json-stable-stringify: 2.1.0
       json-schema-traverse: 0.4.1
       uri-js: 4.4.1
 
-  ajv@8.12.0:
-    dependencies:
-      fast-deep-equal: 3.1.3
-      json-schema-traverse: 1.0.0
-      require-from-string: 2.0.2
-      uri-js: 4.4.1
-
-  ajv@8.13.0:
+  ajv@8.18.0:
     dependencies:
       fast-deep-equal: 3.1.3
+      fast-uri: 3.1.2
       json-schema-traverse: 1.0.0
       require-from-string: 2.0.2
-      uri-js: 4.4.1
+    optional: true
 
-  ajv@8.18.0:
+  ajv@8.20.0:
     dependencies:
       fast-deep-equal: 3.1.3
-      fast-uri: 3.1.0
+      fast-uri: 3.1.2
       json-schema-traverse: 1.0.0
       require-from-string: 2.0.2
 
-  alien-signals@0.4.14: {}
-
   ansi-align@3.0.1:
     dependencies:
       string-width: 4.2.3
@@ -9322,7 +9716,7 @@ snapshots:
       buffer-crc32: 1.0.0
       readable-stream: 4.7.0
       readdir-glob: 1.1.3
-      tar-stream: 3.1.8
+      tar-stream: 3.2.0
       zip-stream: 6.0.1
     transitivePeerDependencies:
       - bare-abort-controller
@@ -9350,45 +9744,45 @@ snapshots:
 
   array-includes@3.1.9:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-object-atoms: 1.1.1
+      es-abstract: 1.24.2
+      es-object-atoms: 1.1.2
       get-intrinsic: 1.3.0
       is-string: 1.1.1
       math-intrinsics: 1.1.0
 
   array.prototype.findlastindex@1.2.6:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-abstract: 1.24.0
+      es-abstract: 1.24.2
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       es-shim-unscopables: 1.1.0
 
   array.prototype.flat@1.3.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.0
+      es-abstract: 1.24.2
       es-shim-unscopables: 1.1.0
 
   array.prototype.flatmap@1.3.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.0
+      es-abstract: 1.24.2
       es-shim-unscopables: 1.1.0
 
   arraybuffer.prototype.slice@1.0.4:
     dependencies:
       array-buffer-byte-length: 1.0.2
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.0
+      es-abstract: 1.24.2
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
       is-array-buffer: 3.0.5
@@ -9407,6 +9801,12 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
+  ast-v8-to-istanbul@1.0.3:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      estree-walker: 3.0.3
+      js-tokens: 10.0.0
+
   astral-regex@2.0.0: {}
 
   async-exit-hook@2.0.1: {}
@@ -9421,23 +9821,13 @@ snapshots:
 
   atomic-sleep@1.0.0: {}
 
-  autoprefixer@10.4.21(postcss@8.5.6):
-    dependencies:
-      browserslist: 4.27.0
-      caniuse-lite: 1.0.30001751
-      fraction.js: 4.3.7
-      normalize-range: 0.1.2
-      picocolors: 1.1.1
-      postcss: 8.5.6
-      postcss-value-parser: 4.2.0
-
-  autoprefixer@10.4.27(postcss@8.5.9):
+  autoprefixer@10.5.0(postcss@8.5.15):
     dependencies:
       browserslist: 4.28.2
-      caniuse-lite: 1.0.30001787
+      caniuse-lite: 1.0.30001793
       fraction.js: 5.3.4
       picocolors: 1.1.1
-      postcss: 8.5.9
+      postcss: 8.5.15
       postcss-value-parser: 4.2.0
 
   available-typed-arrays@1.0.7:
@@ -9449,15 +9839,7 @@ snapshots:
       '@fastify/error': 4.2.0
       fastq: 1.20.1
 
-  axe-core@4.11.1: {}
-
-  axios@1.14.0:
-    dependencies:
-      follow-redirects: 1.15.11
-      form-data: 4.0.5
-      proxy-from-env: 2.1.0
-    transitivePeerDependencies:
-      - debug
+  axe-core@4.12.0: {}
 
   axios@1.16.1:
     dependencies:
@@ -9469,106 +9851,99 @@ snapshots:
       - debug
       - supports-color
 
-  b4a@1.8.0: {}
+  b4a@1.8.1: {}
 
-  babel-jest@29.7.0(@babel/core@7.29.0):
+  babel-jest@30.4.1(@babel/core@7.29.7):
     dependencies:
-      '@babel/core': 7.29.0
-      '@jest/transform': 29.7.0
+      '@babel/core': 7.29.7
+      '@jest/transform': 30.4.1
       '@types/babel__core': 7.20.5
-      babel-plugin-istanbul: 6.1.1
-      babel-preset-jest: 29.6.3(@babel/core@7.29.0)
+      babel-plugin-istanbul: 7.0.1
+      babel-preset-jest: 30.4.0(@babel/core@7.29.7)
       chalk: 4.1.2
       graceful-fs: 4.2.11
       slash: 3.0.0
     transitivePeerDependencies:
       - supports-color
 
-  babel-plugin-istanbul@6.1.1:
+  babel-plugin-istanbul@7.0.1:
     dependencies:
-      '@babel/helper-plugin-utils': 7.28.6
+      '@babel/helper-plugin-utils': 7.29.7
       '@istanbuljs/load-nyc-config': 1.1.0
       '@istanbuljs/schema': 0.1.6
-      istanbul-lib-instrument: 5.2.1
+      istanbul-lib-instrument: 6.0.3
       test-exclude: 6.0.0
     transitivePeerDependencies:
       - supports-color
 
-  babel-plugin-jest-hoist@29.6.3:
+  babel-plugin-jest-hoist@30.4.0:
     dependencies:
-      '@babel/template': 7.28.6
-      '@babel/types': 7.29.0
       '@types/babel__core': 7.20.5
-      '@types/babel__traverse': 7.28.0
 
-  babel-preset-current-node-syntax@1.2.0(@babel/core@7.29.0):
-    dependencies:
-      '@babel/core': 7.29.0
-      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.29.0)
-      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.29.0)
-      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.29.0)
-      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.29.0)
-      '@babel/plugin-syntax-import-attributes': 7.28.6(@babel/core@7.29.0)
-      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.29.0)
-      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.29.0)
-      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.29.0)
-      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.29.0)
-      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.29.0)
-      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.29.0)
-      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.29.0)
-      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.29.0)
-      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.29.0)
-      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.29.0)
-
-  babel-preset-jest@29.6.3(@babel/core@7.29.0):
-    dependencies:
-      '@babel/core': 7.29.0
-      babel-plugin-jest-hoist: 29.6.3
-      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.29.0)
+  babel-preset-current-node-syntax@1.2.0(@babel/core@7.29.7):
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.29.7)
+      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.29.7)
+      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.29.7)
+      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.29.7)
+      '@babel/plugin-syntax-import-attributes': 7.29.7(@babel/core@7.29.7)
+      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.29.7)
+      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.29.7)
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.29.7)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.29.7)
+      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.29.7)
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.29.7)
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.29.7)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.29.7)
+      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.29.7)
+      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.29.7)
+
+  babel-preset-jest@30.4.0(@babel/core@7.29.7):
+    dependencies:
+      '@babel/core': 7.29.7
+      babel-plugin-jest-hoist: 30.4.0
+      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.29.7)
 
   balanced-match@1.0.2: {}
 
   balanced-match@4.0.4: {}
 
-  bare-events@2.8.2: {}
+  bare-events@2.9.1: {}
 
-  bare-fs@4.6.0:
+  bare-fs@4.7.2:
     dependencies:
-      bare-events: 2.8.2
-      bare-path: 3.0.0
-      bare-stream: 2.12.0(bare-events@2.8.2)
-      bare-url: 2.4.0
+      bare-events: 2.9.1
+      bare-path: 3.0.1
+      bare-stream: 2.13.1(bare-events@2.9.1)
+      bare-url: 2.4.3
       fast-fifo: 1.3.2
     transitivePeerDependencies:
       - bare-abort-controller
       - react-native-b4a
 
-  bare-os@3.8.7: {}
+  bare-os@3.9.1: {}
 
-  bare-path@3.0.0:
+  bare-path@3.0.1:
     dependencies:
-      bare-os: 3.8.7
+      bare-os: 3.9.1
 
-  bare-stream@2.12.0(bare-events@2.8.2):
+  bare-stream@2.13.1(bare-events@2.9.1):
     dependencies:
-      streamx: 2.25.0
+      streamx: 2.26.0
       teex: 1.0.1
     optionalDependencies:
-      bare-events: 2.8.2
+      bare-events: 2.9.1
     transitivePeerDependencies:
       - react-native-b4a
 
-  bare-url@2.4.0:
+  bare-url@2.4.3:
     dependencies:
-      bare-path: 3.0.0
+      bare-path: 3.0.1
 
   base64-js@1.5.1: {}
 
-  baseline-browser-mapping@2.10.16: {}
-
-  baseline-browser-mapping@2.8.20: {}
-
-  basic-ftp@5.0.5: {}
+  baseline-browser-mapping@2.10.33: {}
 
   basic-ftp@5.3.1: {}
 
@@ -9602,21 +9977,16 @@ snapshots:
       widest-line: 3.1.0
       wrap-ansi: 7.0.0
 
-  brace-expansion@1.1.12:
+  brace-expansion@1.1.15:
     dependencies:
       balanced-match: 1.0.2
       concat-map: 0.0.1
 
-  brace-expansion@1.1.13:
-    dependencies:
-      balanced-match: 1.0.2
-      concat-map: 0.0.1
-
-  brace-expansion@2.0.3:
+  brace-expansion@2.1.1:
     dependencies:
       balanced-match: 1.0.2
 
-  brace-expansion@5.0.5:
+  brace-expansion@5.0.6:
     dependencies:
       balanced-match: 4.0.4
 
@@ -9626,20 +9996,12 @@ snapshots:
 
   browser-stdout@1.3.1: {}
 
-  browserslist@4.27.0:
-    dependencies:
-      baseline-browser-mapping: 2.8.20
-      caniuse-lite: 1.0.30001751
-      electron-to-chromium: 1.5.240
-      node-releases: 2.0.26
-      update-browserslist-db: 1.1.4(browserslist@4.27.0)
-
   browserslist@4.28.2:
     dependencies:
-      baseline-browser-mapping: 2.10.16
-      caniuse-lite: 1.0.30001787
-      electron-to-chromium: 1.5.333
-      node-releases: 2.0.37
+      baseline-browser-mapping: 2.10.33
+      caniuse-lite: 1.0.30001793
+      electron-to-chromium: 1.5.365
+      node-releases: 2.0.47
       update-browserslist-db: 1.2.3(browserslist@4.28.2)
 
   bser@2.1.1:
@@ -9666,24 +10028,29 @@ snapshots:
 
   buffers@0.1.1: {}
 
-  builtin-modules@5.0.0: {}
+  builtin-modules@5.2.0: {}
+
+  bundle-require@5.1.0(esbuild@0.27.7):
+    dependencies:
+      esbuild: 0.27.7
+      load-tsconfig: 0.2.5
 
   cac@6.7.14: {}
 
-  cacheable@2.3.4:
+  cacheable@2.3.5:
     dependencies:
-      '@cacheable/memory': 2.0.8
+      '@cacheable/memory': 2.0.9
       '@cacheable/utils': 2.4.1
       hookified: 1.15.1
       keyv: 5.6.0
-      qified: 0.9.1
+      qified: 0.10.1
 
   call-bind-apply-helpers@1.0.2:
     dependencies:
       es-errors: 1.3.0
       function-bind: 1.1.2
 
-  call-bind@1.0.8:
+  call-bind@1.0.9:
     dependencies:
       call-bind-apply-helpers: 1.0.2
       es-define-property: 1.0.1
@@ -9701,9 +10068,7 @@ snapshots:
 
   camelcase@6.3.0: {}
 
-  caniuse-lite@1.0.30001751: {}
-
-  caniuse-lite@1.0.30001787: {}
+  caniuse-lite@1.0.30001793: {}
 
   capital-case@1.0.4:
     dependencies:
@@ -9715,14 +10080,6 @@ snapshots:
     dependencies:
       assertion-error: 1.1.0
 
-  chai@5.3.3:
-    dependencies:
-      assertion-error: 2.0.1
-      check-error: 2.1.3
-      deep-eql: 5.0.2
-      loupe: 3.2.1
-      pathval: 2.0.1
-
   chai@6.2.2: {}
 
   chainsaw@0.1.0:
@@ -9750,8 +10107,6 @@ snapshots:
 
   check-error@1.0.2: {}
 
-  check-error@2.1.3: {}
-
   cheerio-select@2.1.0:
     dependencies:
       boolbase: 1.0.0
@@ -9772,7 +10127,7 @@ snapshots:
       parse5: 7.3.0
       parse5-htmlparser2-tree-adapter: 7.1.0
       parse5-parser-stream: 7.1.2
-      undici: 7.24.7
+      undici: 7.27.0
       whatwg-mimetype: 4.0.0
 
   chokidar@3.6.0:
@@ -9793,27 +10148,14 @@ snapshots:
 
   chrome-launcher@1.2.1:
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       escape-string-regexp: 4.0.0
       is-wsl: 2.2.0
       lighthouse-logger: 2.0.2
     transitivePeerDependencies:
       - supports-color
 
-  chromedriver@147.0.1:
-    dependencies:
-      '@testim/chrome-version': 1.1.4
-      axios: 1.14.0
-      compare-versions: 6.1.1
-      extract-zip: 2.0.1
-      proxy-agent: 6.5.0
-      proxy-from-env: 2.1.0
-      tcp-port-used: 1.0.2
-    transitivePeerDependencies:
-      - debug
-      - supports-color
-
-  chromedriver@148.0.3:
+  chromedriver@148.0.4:
     dependencies:
       '@testim/chrome-version': 1.1.4
       adm-zip: 0.5.17
@@ -9836,7 +10178,7 @@ snapshots:
 
   ci-info@4.4.0: {}
 
-  cjs-module-lexer@1.4.3: {}
+  cjs-module-lexer@2.2.0: {}
 
   class-transformer@0.5.1: {}
 
@@ -9884,13 +10226,13 @@ snapshots:
 
   codemirror@6.0.2:
     dependencies:
-      '@codemirror/autocomplete': 6.19.1
-      '@codemirror/commands': 6.10.0
-      '@codemirror/language': 6.11.3
-      '@codemirror/lint': 6.9.1
-      '@codemirror/search': 6.5.11
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/commands': 6.10.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/lint': 6.9.6
+      '@codemirror/search': 6.7.0
       '@codemirror/state': 6.5.4
-      '@codemirror/view': 6.41.0
+      '@codemirror/view': 6.43.0
 
   collect-v8-coverage@1.0.3: {}
 
@@ -9916,10 +10258,16 @@ snapshots:
 
   commander@12.0.0: {}
 
-  commander@13.1.0: {}
+  commander@14.0.0: {}
+
+  commander@14.0.2: {}
 
   commander@14.0.3: {}
 
+  commander@15.0.0: {}
+
+  commander@4.1.1: {}
+
   commander@9.1.0: {}
 
   commander@9.5.0: {}
@@ -9945,7 +10293,9 @@ snapshots:
 
   confbox@0.1.8: {}
 
-  confbox@0.2.2: {}
+  confbox@0.2.4: {}
+
+  consola@3.4.2: {}
 
   content-disposition@1.1.0: {}
 
@@ -9959,14 +10309,14 @@ snapshots:
 
   core-util-is@1.0.3: {}
 
-  cosmiconfig@9.0.1(typescript@6.0.2):
+  cosmiconfig@9.0.1(typescript@6.0.3):
     dependencies:
       env-paths: 2.2.1
       import-fresh: 3.3.1
-      js-yaml: 4.1.0
+      js-yaml: 4.2.0
       parse-json: 5.2.0
     optionalDependencies:
-      typescript: 6.0.2
+      typescript: 6.0.3
 
   crc-32@1.2.2: {}
 
@@ -9980,24 +10330,9 @@ snapshots:
       crc-32: 1.2.2
       readable-stream: 4.7.0
 
-  create-jest@29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2)):
-    dependencies:
-      '@jest/types': 29.6.3
-      chalk: 4.1.2
-      exit: 0.1.2
-      graceful-fs: 4.2.11
-      jest-config: 29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
-      jest-util: 29.7.0
-      prompts: 2.4.2
-    transitivePeerDependencies:
-      - '@types/node'
-      - babel-plugin-macros
-      - supports-color
-      - ts-node
-
   create-require@1.1.1: {}
 
-  create-wdio@9.27.0(@types/node@25.5.2):
+  create-wdio@9.27.2(@types/node@25.9.1):
     dependencies:
       chalk: 5.6.2
       commander: 14.0.3
@@ -10005,11 +10340,11 @@ snapshots:
       ejs: 3.1.10
       execa: 9.6.1
       import-meta-resolve: 4.2.0
-      inquirer: 12.11.1(@types/node@25.5.2)
+      inquirer: 12.11.1(@types/node@25.9.1)
       normalize-package-data: 7.0.1
       read-pkg-up: 10.1.0
       recursive-readdir: 2.2.3
-      semver: 7.7.4
+      semver: 7.8.1
       type-fest: 4.41.0
       yargs: 17.7.2
     transitivePeerDependencies:
@@ -10094,8 +10429,6 @@ snapshots:
       es-errors: 1.3.0
       is-data-view: 1.0.2
 
-  de-indent@1.0.2: {}
-
   debug@3.2.7:
     dependencies:
       ms: 2.1.3
@@ -10108,9 +10441,11 @@ snapshots:
     dependencies:
       ms: 2.1.2
 
-  debug@4.4.3:
+  debug@4.4.3(supports-color@10.2.2):
     dependencies:
       ms: 2.1.3
+    optionalDependencies:
+      supports-color: 10.2.2
 
   debug@4.4.3(supports-color@5.5.0):
     dependencies:
@@ -10141,7 +10476,7 @@ snapshots:
   deep-equal@2.2.3:
     dependencies:
       array-buffer-byte-length: 1.0.2
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       es-get-iterator: 1.1.3
       get-intrinsic: 1.3.0
       is-arguments: 1.2.0
@@ -10157,7 +10492,7 @@ snapshots:
       side-channel: 1.1.0
       which-boxed-primitive: 1.1.1
       which-collection: 1.0.2
-      which-typed-array: 1.1.19
+      which-typed-array: 1.1.21
 
   deep-is@0.1.4: {}
 
@@ -10214,7 +10549,7 @@ snapshots:
 
   devtools@8.42.0:
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@wdio/config': 8.41.0
       '@wdio/logger': 8.38.0
       '@wdio/protocols': 8.40.3
@@ -10239,14 +10574,12 @@ snapshots:
 
   didyoumean@1.2.2: {}
 
-  diff-sequences@29.6.3: {}
-
-  diff@4.0.2: {}
-
   diff@4.0.4: {}
 
   diff@5.2.2: {}
 
+  diff@7.0.0: {}
+
   diff@8.0.4: {}
 
   doctrine@2.1.0:
@@ -10273,7 +10606,7 @@ snapshots:
 
   dotenv@16.3.1: {}
 
-  dotenv@17.4.1: {}
+  dotenv@17.4.2: {}
 
   dunder-proto@1.0.1:
     dependencies:
@@ -10311,7 +10644,7 @@ snapshots:
       '@zip.js/zip.js': 2.8.26
       decamelize: 6.0.1
       edge-paths: 3.0.5
-      fast-xml-parser: 4.5.3
+      fast-xml-parser: 4.5.6
       node-fetch: 3.3.2
       which: 4.0.0
 
@@ -10321,7 +10654,7 @@ snapshots:
       '@zip.js/zip.js': 2.8.26
       decamelize: 6.0.1
       edge-paths: 3.0.5
-      fast-xml-parser: 5.5.10
+      fast-xml-parser: 5.8.0
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
       which: 6.0.1
@@ -10332,9 +10665,7 @@ snapshots:
     dependencies:
       jake: 10.9.4
 
-  electron-to-chromium@1.5.240: {}
-
-  electron-to-chromium@1.5.333: {}
+  electron-to-chromium@1.5.365: {}
 
   emittery@0.13.1: {}
 
@@ -10351,10 +10682,10 @@ snapshots:
     dependencies:
       once: 1.4.0
 
-  enhanced-resolve@5.20.1:
+  enhanced-resolve@5.22.1:
     dependencies:
       graceful-fs: 4.2.11
-      tapable: 2.3.2
+      tapable: 2.3.3
 
   entities@2.2.0: {}
 
@@ -10364,6 +10695,8 @@ snapshots:
 
   entities@7.0.1: {}
 
+  entities@8.0.0: {}
+
   env-paths@2.2.1: {}
 
   envinfo@7.11.0: {}
@@ -10376,19 +10709,19 @@ snapshots:
     dependencies:
       stackframe: 1.3.4
 
-  es-abstract@1.24.0:
+  es-abstract@1.24.2:
     dependencies:
       array-buffer-byte-length: 1.0.2
       arraybuffer.prototype.slice: 1.0.4
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       data-view-buffer: 1.0.2
       data-view-byte-length: 1.0.2
       data-view-byte-offset: 1.0.1
       es-define-property: 1.0.1
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       es-set-tostringtag: 2.1.0
       es-to-primitive: 1.3.0
       function.prototype.name: 1.1.8
@@ -10400,7 +10733,7 @@ snapshots:
       has-property-descriptors: 1.0.2
       has-proto: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       internal-slot: 1.1.0
       is-array-buffer: 3.0.5
       is-callable: 1.2.7
@@ -10418,7 +10751,7 @@ snapshots:
       object.assign: 4.1.7
       own-keys: 1.0.1
       regexp.prototype.flags: 1.5.4
-      safe-array-concat: 1.1.3
+      safe-array-concat: 1.1.4
       safe-push-apply: 1.0.0
       safe-regex-test: 1.1.0
       set-proto: 1.0.0
@@ -10429,9 +10762,9 @@ snapshots:
       typed-array-buffer: 1.0.3
       typed-array-byte-length: 1.0.3
       typed-array-byte-offset: 1.0.4
-      typed-array-length: 1.0.7
+      typed-array-length: 1.0.8
       unbox-primitive: 1.1.0
-      which-typed-array: 1.1.19
+      which-typed-array: 1.1.21
 
   es-define-property@1.0.1: {}
 
@@ -10439,7 +10772,7 @@ snapshots:
 
   es-get-iterator@1.1.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       get-intrinsic: 1.3.0
       has-symbols: 1.1.0
       is-arguments: 1.2.0
@@ -10449,11 +10782,9 @@ snapshots:
       isarray: 2.0.5
       stop-iteration-iterator: 1.1.0
 
-  es-module-lexer@1.7.0: {}
-
-  es-module-lexer@2.0.0: {}
+  es-module-lexer@2.1.0: {}
 
-  es-object-atoms@1.1.1:
+  es-object-atoms@1.1.2:
     dependencies:
       es-errors: 1.3.0
 
@@ -10462,11 +10793,11 @@ snapshots:
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
       has-tostringtag: 1.0.2
-      hasown: 2.0.2
+      hasown: 2.0.4
 
   es-shim-unscopables@1.1.0:
     dependencies:
-      hasown: 2.0.2
+      hasown: 2.0.4
 
   es-to-primitive@1.3.0:
     dependencies:
@@ -10503,6 +10834,35 @@ snapshots:
       '@esbuild/win32-ia32': 0.27.7
       '@esbuild/win32-x64': 0.27.7
 
+  esbuild@0.28.0:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.28.0
+      '@esbuild/android-arm': 0.28.0
+      '@esbuild/android-arm64': 0.28.0
+      '@esbuild/android-x64': 0.28.0
+      '@esbuild/darwin-arm64': 0.28.0
+      '@esbuild/darwin-x64': 0.28.0
+      '@esbuild/freebsd-arm64': 0.28.0
+      '@esbuild/freebsd-x64': 0.28.0
+      '@esbuild/linux-arm': 0.28.0
+      '@esbuild/linux-arm64': 0.28.0
+      '@esbuild/linux-ia32': 0.28.0
+      '@esbuild/linux-loong64': 0.28.0
+      '@esbuild/linux-mips64el': 0.28.0
+      '@esbuild/linux-ppc64': 0.28.0
+      '@esbuild/linux-riscv64': 0.28.0
+      '@esbuild/linux-s390x': 0.28.0
+      '@esbuild/linux-x64': 0.28.0
+      '@esbuild/netbsd-arm64': 0.28.0
+      '@esbuild/netbsd-x64': 0.28.0
+      '@esbuild/openbsd-arm64': 0.28.0
+      '@esbuild/openbsd-x64': 0.28.0
+      '@esbuild/openharmony-arm64': 0.28.0
+      '@esbuild/sunos-x64': 0.28.0
+      '@esbuild/win32-arm64': 0.28.0
+      '@esbuild/win32-ia32': 0.28.0
+      '@esbuild/win32-x64': 0.28.0
+
   escalade@3.2.0: {}
 
   escape-html@1.0.3: {}
@@ -10521,29 +10881,29 @@ snapshots:
     optionalDependencies:
       source-map: 0.6.1
 
-  eslint-config-prettier@10.1.8(eslint@10.2.0(jiti@2.6.1)):
+  eslint-config-prettier@10.1.8(eslint@10.4.1(jiti@2.7.0)):
     dependencies:
-      eslint: 10.2.0(jiti@2.6.1)
+      eslint: 10.4.1(jiti@2.7.0)
 
-  eslint-import-resolver-node@0.3.9:
+  eslint-import-resolver-node@0.3.10:
     dependencies:
       debug: 3.2.7
-      is-core-module: 2.16.1
-      resolve: 1.22.11
+      is-core-module: 2.16.2
+      resolve: 2.0.0-next.7
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2))(eslint-import-resolver-node@0.3.9)(eslint@10.2.0(jiti@2.6.1)):
+  eslint-module-utils@2.13.0(@typescript-eslint/parser@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3))(eslint-import-resolver-node@0.3.10)(eslint@10.4.1(jiti@2.7.0)):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
-      '@typescript-eslint/parser': 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
-      eslint: 10.2.0(jiti@2.6.1)
-      eslint-import-resolver-node: 0.3.9
+      '@typescript-eslint/parser': 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
+      eslint: 10.4.1(jiti@2.7.0)
+      eslint-import-resolver-node: 0.3.10
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2))(eslint@10.2.0(jiti@2.6.1)):
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3))(eslint@10.4.1(jiti@2.7.0)):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9
@@ -10552,13 +10912,13 @@ snapshots:
       array.prototype.flatmap: 1.3.3
       debug: 3.2.7
       doctrine: 2.1.0
-      eslint: 10.2.0(jiti@2.6.1)
-      eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2))(eslint-import-resolver-node@0.3.9)(eslint@10.2.0(jiti@2.6.1))
-      hasown: 2.0.2
-      is-core-module: 2.16.1
+      eslint: 10.4.1(jiti@2.7.0)
+      eslint-import-resolver-node: 0.3.10
+      eslint-module-utils: 2.13.0(@typescript-eslint/parser@8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3))(eslint-import-resolver-node@0.3.10)(eslint@10.4.1(jiti@2.7.0))
+      hasown: 2.0.4
+      is-core-module: 2.16.2
       is-glob: 4.0.3
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       object.fromentries: 2.0.8
       object.groupby: 1.0.3
       object.values: 1.2.1
@@ -10566,45 +10926,49 @@ snapshots:
       string.prototype.trimend: 1.0.9
       tsconfig-paths: 3.15.0
     optionalDependencies:
-      '@typescript-eslint/parser': 8.58.1(eslint@10.2.0(jiti@2.6.1))(typescript@6.0.2)
+      '@typescript-eslint/parser': 8.60.1(eslint@10.4.1(jiti@2.7.0))(typescript@6.0.3)
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
 
-  eslint-plugin-prettier@5.5.5(eslint-config-prettier@10.1.8(eslint@10.2.0(jiti@2.6.1)))(eslint@10.2.0(jiti@2.6.1))(prettier@3.8.1):
+  eslint-plugin-prettier@5.5.6(eslint-config-prettier@10.1.8(eslint@10.4.1(jiti@2.7.0)))(eslint@10.4.1(jiti@2.7.0))(prettier@3.8.3):
     dependencies:
-      eslint: 10.2.0(jiti@2.6.1)
-      prettier: 3.8.1
+      eslint: 10.4.1(jiti@2.7.0)
+      prettier: 3.8.3
       prettier-linter-helpers: 1.0.1
-      synckit: 0.11.12
+      synckit: 0.11.13
     optionalDependencies:
-      eslint-config-prettier: 10.1.8(eslint@10.2.0(jiti@2.6.1))
+      eslint-config-prettier: 10.1.8(eslint@10.4.1(jiti@2.7.0))
+
+  eslint-plugin-security@4.0.0:
+    dependencies:
+      safe-regex: 2.1.1
 
-  eslint-plugin-unicorn@64.0.0(eslint@10.2.0(jiti@2.6.1)):
+  eslint-plugin-unicorn@64.0.0(eslint@10.4.1(jiti@2.7.0)):
     dependencies:
-      '@babel/helper-validator-identifier': 7.28.5
-      '@eslint-community/eslint-utils': 4.9.1(eslint@10.2.0(jiti@2.6.1))
+      '@babel/helper-validator-identifier': 7.29.7
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.4.1(jiti@2.7.0))
       change-case: 5.4.4
       ci-info: 4.4.0
       clean-regexp: 1.0.0
       core-js-compat: 3.49.0
-      eslint: 10.2.0(jiti@2.6.1)
+      eslint: 10.4.1(jiti@2.7.0)
       find-up-simple: 1.0.1
-      globals: 17.4.0
+      globals: 17.6.0
       indent-string: 5.0.0
       is-builtin-module: 5.0.0
       jsesc: 3.1.0
       pluralize: 8.0.0
       regexp-tree: 0.1.27
-      regjsparser: 0.13.0
-      semver: 7.7.4
+      regjsparser: 0.13.1
+      semver: 7.8.1
       strip-indent: 4.1.1
 
   eslint-scope@9.1.2:
     dependencies:
       '@types/esrecurse': 4.3.1
-      '@types/estree': 1.0.8
+      '@types/estree': 1.0.9
       esrecurse: 4.3.0
       estraverse: 5.3.0
 
@@ -10612,21 +10976,21 @@ snapshots:
 
   eslint-visitor-keys@5.0.1: {}
 
-  eslint@10.2.0(jiti@2.6.1):
+  eslint@10.4.1(jiti@2.7.0):
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@10.2.0(jiti@2.6.1))
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.4.1(jiti@2.7.0))
       '@eslint-community/regexpp': 4.12.2
       '@eslint/config-array': 0.23.5
-      '@eslint/config-helpers': 0.5.5
+      '@eslint/config-helpers': 0.6.0
       '@eslint/core': 1.2.1
-      '@eslint/plugin-kit': 0.7.1
-      '@humanfs/node': 0.16.7
+      '@eslint/plugin-kit': 0.7.2
+      '@humanfs/node': 0.16.8
       '@humanwhocodes/module-importer': 1.0.1
       '@humanwhocodes/retry': 0.4.3
-      '@types/estree': 1.0.8
-      ajv: 6.14.0
+      '@types/estree': 1.0.9
+      ajv: 6.15.0
       cross-spawn: 7.0.6
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       escape-string-regexp: 4.0.0
       eslint-scope: 9.1.2
       eslint-visitor-keys: 5.0.1
@@ -10645,7 +11009,7 @@ snapshots:
       natural-compare: 1.4.0
       optionator: 0.9.4
     optionalDependencies:
-      jiti: 2.6.1
+      jiti: 2.7.0
     transitivePeerDependencies:
       - supports-color
 
@@ -10671,7 +11035,7 @@ snapshots:
 
   estree-walker@3.0.3:
     dependencies:
-      '@types/estree': 1.0.8
+      '@types/estree': 1.0.9
 
   esutils@2.0.3: {}
 
@@ -10679,7 +11043,7 @@ snapshots:
 
   events-universal@1.0.1:
     dependencies:
-      bare-events: 2.8.2
+      bare-events: 2.9.1
     transitivePeerDependencies:
       - bare-abort-controller
 
@@ -10714,42 +11078,34 @@ snapshots:
 
   exit-hook@4.0.0: {}
 
-  exit@0.1.2: {}
+  exit-x@0.2.2: {}
 
   expect-type@1.3.0: {}
 
-  expect-webdriverio@5.6.5(@wdio/globals@9.27.0)(@wdio/logger@9.18.0)(webdriverio@9.27.0(puppeteer-core@21.11.0)):
+  expect-webdriverio@5.6.7(@wdio/globals@9.27.2)(@wdio/logger@9.18.0)(webdriverio@9.27.2(puppeteer-core@21.11.0)):
     dependencies:
-      '@vitest/snapshot': 4.1.3
-      '@wdio/globals': 9.27.0(expect-webdriverio@5.6.5)(webdriverio@9.27.0(puppeteer-core@21.11.0))
+      '@vitest/snapshot': 4.1.8
+      '@wdio/globals': 9.27.2(expect-webdriverio@5.6.7)(webdriverio@9.27.2(puppeteer-core@21.11.0))
       '@wdio/logger': 9.18.0
       deep-eql: 5.0.2
-      expect: 30.3.0
-      jest-matcher-utils: 30.3.0
-      webdriverio: 9.27.0(puppeteer-core@21.11.0)
-
-  expect@29.7.0:
-    dependencies:
-      '@jest/expect-utils': 29.7.0
-      jest-get-type: 29.6.3
-      jest-matcher-utils: 29.7.0
-      jest-message-util: 29.7.0
-      jest-util: 29.7.0
+      expect: 30.4.1
+      jest-matcher-utils: 30.4.1
+      webdriverio: 9.27.2(puppeteer-core@21.11.0)
 
-  expect@30.3.0:
+  expect@30.4.1:
     dependencies:
-      '@jest/expect-utils': 30.3.0
+      '@jest/expect-utils': 30.4.1
       '@jest/get-type': 30.1.0
-      jest-matcher-utils: 30.3.0
-      jest-message-util: 30.3.0
-      jest-mock: 30.3.0
-      jest-util: 30.3.0
+      jest-matcher-utils: 30.4.1
+      jest-message-util: 30.4.1
+      jest-mock: 30.4.1
+      jest-util: 30.4.1
 
-  exsolve@1.0.7: {}
+  exsolve@1.0.8: {}
 
   extract-zip@2.0.1:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       get-stream: 5.2.0
       yauzl: 2.10.0
     optionalDependencies:
@@ -10777,12 +11133,12 @@ snapshots:
 
   fast-json-stable-stringify@2.1.0: {}
 
-  fast-json-stringify@6.3.0:
+  fast-json-stringify@6.4.0:
     dependencies:
       '@fastify/merge-json-schemas': 0.2.1
-      ajv: 8.18.0
-      ajv-formats: 3.0.1(ajv@8.18.0)
-      fast-uri: 3.1.0
+      ajv: 8.20.0
+      ajv-formats: 3.0.1(ajv@8.20.0)
+      fast-uri: 3.1.2
       json-schema-ref-resolver: 3.0.0
       rfdc: 1.4.1
 
@@ -10792,27 +11148,30 @@ snapshots:
     dependencies:
       fast-decode-uri-component: 1.0.1
 
-  fast-uri@3.1.0: {}
+  fast-uri@3.1.2: {}
 
-  fast-xml-builder@1.1.4:
+  fast-xml-builder@1.2.0:
     dependencies:
-      path-expression-matcher: 1.4.0
+      path-expression-matcher: 1.5.0
+      xml-naming: 0.1.0
 
-  fast-xml-parser@4.5.3:
+  fast-xml-parser@4.5.6:
     dependencies:
       strnum: 1.1.2
 
-  fast-xml-parser@5.5.10:
+  fast-xml-parser@5.8.0:
     dependencies:
-      fast-xml-builder: 1.1.4
-      path-expression-matcher: 1.4.0
-      strnum: 2.2.3
+      '@nodable/entities': 2.1.1
+      fast-xml-builder: 1.2.0
+      path-expression-matcher: 1.5.0
+      strnum: 2.3.0
+      xml-naming: 0.1.0
 
   fastest-levenshtein@1.0.16: {}
 
   fastify-plugin@5.1.0: {}
 
-  fastify@5.8.4:
+  fastify@5.8.5:
     dependencies:
       '@fastify/ajv-compiler': 4.0.5
       '@fastify/error': 4.2.0
@@ -10820,15 +11179,15 @@ snapshots:
       '@fastify/proxy-addr': 5.1.0
       abstract-logging: 2.0.1
       avvio: 9.2.0
-      fast-json-stringify: 6.3.0
-      find-my-way: 9.5.0
+      fast-json-stringify: 6.4.0
+      find-my-way: 9.6.0
       light-my-request: 6.6.0
       pino: 10.3.1
       process-warning: 5.0.0
       rfdc: 1.4.1
       secure-json-parse: 4.1.0
-      semver: 7.7.4
-      toad-cache: 3.7.0
+      semver: 7.8.1
+      toad-cache: 3.7.1
 
   fastq@1.20.1:
     dependencies:
@@ -10859,7 +11218,7 @@ snapshots:
     dependencies:
       is-unicode-supported: 2.1.0
 
-  file-entry-cache@11.1.2:
+  file-entry-cache@11.1.3:
     dependencies:
       flat-cache: 6.1.22
 
@@ -10867,7 +11226,7 @@ snapshots:
     dependencies:
       flat-cache: 4.0.1
 
-  filelist@1.0.4:
+  filelist@1.0.6:
     dependencies:
       minimatch: 5.1.9
 
@@ -10875,11 +11234,11 @@ snapshots:
     dependencies:
       to-regex-range: 5.0.1
 
-  find-my-way@9.5.0:
+  find-my-way@9.6.0:
     dependencies:
       fast-deep-equal: 3.1.3
       fast-querystring: 1.1.2
-      safe-regex2: 5.1.0
+      safe-regex2: 5.1.1
 
   find-up-simple@1.0.1: {}
 
@@ -10898,21 +11257,25 @@ snapshots:
       locate-path: 7.2.0
       path-exists: 5.0.0
 
+  fix-dts-default-cjs-exports@1.0.1:
+    dependencies:
+      magic-string: 0.30.21
+      mlly: 1.8.2
+      rollup: 4.61.0
+
   flat-cache@4.0.1:
     dependencies:
-      flatted: 3.3.3
+      flatted: 3.4.2
       keyv: 4.5.4
 
   flat-cache@6.1.22:
     dependencies:
-      cacheable: 2.3.4
+      cacheable: 2.3.5
       flatted: 3.4.2
       hookified: 1.15.1
 
   flat@5.0.2: {}
 
-  flatted@3.3.3: {}
-
   flatted@3.4.2: {}
 
   fluent-ffmpeg@2.1.3:
@@ -10920,8 +11283,6 @@ snapshots:
       async: 0.2.10
       which: 1.3.1
 
-  follow-redirects@1.15.11: {}
-
   follow-redirects@1.16.0: {}
 
   for-each@0.3.5:
@@ -10938,24 +11299,23 @@ snapshots:
       asynckit: 0.4.0
       combined-stream: 1.0.8
       es-set-tostringtag: 2.1.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       mime-types: 2.1.35
 
   formdata-polyfill@4.0.10:
     dependencies:
       fetch-blob: 3.2.0
 
-  fraction.js@4.3.7: {}
-
   fraction.js@5.3.4: {}
 
   fs-constants@1.0.0: {}
 
-  fs-extra@11.3.2:
+  fs-extra@11.3.5:
     dependencies:
       graceful-fs: 4.2.11
-      jsonfile: 6.2.0
+      jsonfile: 6.2.1
       universalify: 2.0.1
+    optional: true
 
   fs.realpath@1.0.0: {}
 
@@ -10973,11 +11333,11 @@ snapshots:
 
   function.prototype.name@1.1.8:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
       functions-have-names: 1.2.3
-      hasown: 2.0.2
+      hasown: 2.0.4
       is-callable: 1.2.7
 
   functions-have-names@1.2.3: {}
@@ -11015,7 +11375,7 @@ snapshots:
 
   get-caller-file@2.0.5: {}
 
-  get-east-asian-width@1.5.0: {}
+  get-east-asian-width@1.6.0: {}
 
   get-func-name@2.0.2: {}
 
@@ -11024,12 +11384,12 @@ snapshots:
       call-bind-apply-helpers: 1.0.2
       es-define-property: 1.0.1
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       function-bind: 1.1.2
       get-proto: 1.0.1
       gopd: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       math-intrinsics: 1.1.0
 
   get-package-type@0.1.0: {}
@@ -11039,7 +11399,7 @@ snapshots:
   get-proto@1.0.1:
     dependencies:
       dunder-proto: 1.0.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   get-stream@5.2.0:
     dependencies:
@@ -11058,15 +11418,11 @@ snapshots:
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
 
-  get-tsconfig@4.13.7:
-    dependencies:
-      resolve-pkg-maps: 1.0.0
-
   get-uri@6.0.5:
     dependencies:
-      basic-ftp: 5.0.5
+      basic-ftp: 5.3.1
       data-uri-to-buffer: 6.0.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -11074,7 +11430,7 @@ snapshots:
     dependencies:
       basic-ftp: 5.3.1
       data-uri-to-buffer: 8.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -11118,6 +11474,10 @@ snapshots:
       minimatch: 5.1.9
       once: 1.4.0
 
+  global-directory@4.0.1:
+    dependencies:
+      ini: 4.1.1
+
   global-dirs@3.0.1:
     dependencies:
       ini: 2.0.0
@@ -11132,7 +11492,7 @@ snapshots:
       kind-of: 6.0.3
       which: 1.3.1
 
-  globals@17.4.0: {}
+  globals@17.6.0: {}
 
   globalthis@1.0.4:
     dependencies:
@@ -11156,14 +11516,14 @@ snapshots:
 
   grapheme-splitter@1.0.4: {}
 
-  happy-dom@20.8.9:
+  happy-dom@20.9.0:
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@types/whatwg-mimetype': 3.0.2
       '@types/ws': 8.18.1
       entities: 7.0.1
       whatwg-mimetype: 3.0.0
-      ws: 8.20.0
+      ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
@@ -11172,6 +11532,10 @@ snapshots:
     dependencies:
       ansi-regex: 4.1.1
 
+  has-ansi@6.0.2:
+    dependencies:
+      ansi-regex: 6.2.2
+
   has-bigints@1.1.0: {}
 
   has-flag@3.0.0: {}
@@ -11198,7 +11562,7 @@ snapshots:
     dependencies:
       hookified: 1.15.1
 
-  hasown@2.0.2:
+  hasown@2.0.4:
     dependencies:
       function-bind: 1.1.2
 
@@ -11206,7 +11570,7 @@ snapshots:
 
   hookified@1.15.1: {}
 
-  hookified@2.1.1: {}
+  hookified@2.2.0: {}
 
   hosted-git-info@2.8.9: {}
 
@@ -11218,6 +11582,10 @@ snapshots:
     dependencies:
       lru-cache: 10.4.3
 
+  hosted-git-info@9.0.3:
+    dependencies:
+      lru-cache: 11.5.1
+
   htm@3.1.1: {}
 
   html-encoding-sniffer@4.0.0:
@@ -11248,35 +11616,35 @@ snapshots:
   http-proxy-agent@7.0.2:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
   http-proxy-agent@9.0.0:
     dependencies:
       agent-base: 9.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
   https-proxy-agent@5.0.1:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
   https-proxy-agent@7.0.6:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
   https-proxy-agent@9.0.0:
     dependencies:
       agent-base: 9.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -11307,7 +11675,8 @@ snapshots:
       parent-module: 1.0.1
       resolve-from: 4.0.0
 
-  import-lazy@4.0.0: {}
+  import-lazy@4.0.0:
+    optional: true
 
   import-local@3.2.0:
     dependencies:
@@ -11335,29 +11704,31 @@ snapshots:
 
   ini@2.0.0: {}
 
-  inquirer@12.11.1(@types/node@25.5.2):
+  ini@4.1.1: {}
+
+  inquirer@12.11.1(@types/node@25.9.1):
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@25.5.2)
-      '@inquirer/prompts': 7.10.1(@types/node@25.5.2)
-      '@inquirer/type': 3.0.10(@types/node@25.5.2)
+      '@inquirer/core': 10.3.2(@types/node@25.9.1)
+      '@inquirer/prompts': 7.10.1(@types/node@25.9.1)
+      '@inquirer/type': 3.0.10(@types/node@25.9.1)
       mute-stream: 2.0.0
       run-async: 4.0.6
       rxjs: 7.8.2
     optionalDependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
 
   internal-slot@1.1.0:
     dependencies:
       es-errors: 1.3.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       side-channel: 1.1.0
 
-  ip-address@10.0.1: {}
+  ip-address@10.2.0: {}
 
   ip-regex@4.3.0: {}
 
-  ipaddr.js@2.3.0: {}
+  ipaddr.js@2.4.0: {}
 
   is-arguments@1.2.0:
     dependencies:
@@ -11366,7 +11737,7 @@ snapshots:
 
   is-array-buffer@3.0.5:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       get-intrinsic: 1.3.0
 
@@ -11395,13 +11766,13 @@ snapshots:
 
   is-builtin-module@5.0.0:
     dependencies:
-      builtin-modules: 5.0.0
+      builtin-modules: 5.2.0
 
   is-callable@1.2.7: {}
 
-  is-core-module@2.16.1:
+  is-core-module@2.16.2:
     dependencies:
-      hasown: 2.0.2
+      hasown: 2.0.4
 
   is-data-view@1.0.2:
     dependencies:
@@ -11443,6 +11814,11 @@ snapshots:
       global-dirs: 3.0.1
       is-path-inside: 3.0.3
 
+  is-installed-globally@1.0.0:
+    dependencies:
+      global-directory: 4.0.1
+      is-path-inside: 4.0.0
+
   is-interactive@1.0.0: {}
 
   is-map@2.0.3: {}
@@ -11464,8 +11840,6 @@ snapshots:
 
   is-plain-obj@4.1.0: {}
 
-  is-plain-object@5.0.0: {}
-
   is-potential-custom-element-name@1.0.1: {}
 
   is-regex@1.2.1:
@@ -11473,7 +11847,7 @@ snapshots:
       call-bound: 1.0.4
       gopd: 1.2.0
       has-tostringtag: 1.0.2
-      hasown: 2.0.2
+      hasown: 2.0.4
 
   is-set@2.0.3: {}
 
@@ -11498,7 +11872,7 @@ snapshots:
 
   is-typed-array@1.1.15:
     dependencies:
-      which-typed-array: 1.1.19
+      which-typed-array: 1.1.21
 
   is-unicode-supported@0.1.0: {}
 
@@ -11533,29 +11907,19 @@ snapshots:
 
   isexe@2.0.0: {}
 
-  isexe@3.1.1: {}
+  isexe@3.1.5: {}
 
   isexe@4.0.0: {}
 
   istanbul-lib-coverage@3.2.2: {}
 
-  istanbul-lib-instrument@5.2.1:
-    dependencies:
-      '@babel/core': 7.29.0
-      '@babel/parser': 7.29.2
-      '@istanbuljs/schema': 0.1.6
-      istanbul-lib-coverage: 3.2.2
-      semver: 6.3.1
-    transitivePeerDependencies:
-      - supports-color
-
   istanbul-lib-instrument@6.0.3:
     dependencies:
-      '@babel/core': 7.29.0
-      '@babel/parser': 7.29.2
+      '@babel/core': 7.29.7
+      '@babel/parser': 7.29.7
       '@istanbuljs/schema': 0.1.6
       istanbul-lib-coverage: 3.2.2
-      semver: 7.7.4
+      semver: 7.8.1
     transitivePeerDependencies:
       - supports-color
 
@@ -11565,11 +11929,11 @@ snapshots:
       make-dir: 4.0.0
       supports-color: 7.2.0
 
-  istanbul-lib-source-maps@4.0.1:
+  istanbul-lib-source-maps@5.0.6:
     dependencies:
-      debug: 4.4.3
+      '@jridgewell/trace-mapping': 0.3.31
+      debug: 4.4.3(supports-color@5.5.0)
       istanbul-lib-coverage: 3.2.2
-      source-map: 0.6.1
     transitivePeerDependencies:
       - supports-color
 
@@ -11587,364 +11951,329 @@ snapshots:
   jake@10.9.4:
     dependencies:
       async: 3.2.6
-      filelist: 1.0.4
+      filelist: 1.0.6
       picocolors: 1.1.1
 
-  jest-changed-files@29.7.0:
+  jest-changed-files@30.4.1:
     dependencies:
       execa: 5.1.1
-      jest-util: 29.7.0
+      jest-util: 30.4.1
       p-limit: 3.1.0
 
-  jest-circus@29.7.0:
+  jest-circus@30.4.2:
     dependencies:
-      '@jest/environment': 29.7.0
-      '@jest/expect': 29.7.0
-      '@jest/test-result': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
+      '@jest/environment': 30.4.1
+      '@jest/expect': 30.4.1
+      '@jest/test-result': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       chalk: 4.1.2
       co: 4.6.0
       dedent: 1.7.2
       is-generator-fn: 2.1.0
-      jest-each: 29.7.0
-      jest-matcher-utils: 29.7.0
-      jest-message-util: 29.7.0
-      jest-runtime: 29.7.0
-      jest-snapshot: 29.7.0
-      jest-util: 29.7.0
+      jest-each: 30.4.1
+      jest-matcher-utils: 30.4.1
+      jest-message-util: 30.4.1
+      jest-runtime: 30.4.2
+      jest-snapshot: 30.4.1
+      jest-util: 30.4.1
       p-limit: 3.1.0
-      pretty-format: 29.7.0
-      pure-rand: 6.1.0
+      pretty-format: 30.4.1
+      pure-rand: 7.0.1
       slash: 3.0.0
       stack-utils: 2.0.6
     transitivePeerDependencies:
       - babel-plugin-macros
       - supports-color
 
-  jest-cli@29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2)):
+  jest-cli@30.4.2(@types/node@25.9.1)(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3)):
     dependencies:
-      '@jest/core': 29.7.0(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
-      '@jest/test-result': 29.7.0
-      '@jest/types': 29.6.3
+      '@jest/core': 30.4.2(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3))
+      '@jest/test-result': 30.4.1
+      '@jest/types': 30.4.1
       chalk: 4.1.2
-      create-jest: 29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
-      exit: 0.1.2
+      exit-x: 0.2.2
       import-local: 3.2.0
-      jest-config: 29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
-      jest-util: 29.7.0
-      jest-validate: 29.7.0
+      jest-config: 30.4.2(@types/node@25.9.1)(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3))
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
       yargs: 17.7.2
     transitivePeerDependencies:
       - '@types/node'
       - babel-plugin-macros
+      - esbuild-register
       - supports-color
       - ts-node
 
-  jest-config@29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2)):
+  jest-config@30.4.2(@types/node@25.9.1)(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3)):
     dependencies:
-      '@babel/core': 7.29.0
-      '@jest/test-sequencer': 29.7.0
-      '@jest/types': 29.6.3
-      babel-jest: 29.7.0(@babel/core@7.29.0)
+      '@babel/core': 7.29.7
+      '@jest/get-type': 30.1.0
+      '@jest/pattern': 30.4.0
+      '@jest/test-sequencer': 30.4.1
+      '@jest/types': 30.4.1
+      babel-jest: 30.4.1(@babel/core@7.29.7)
       chalk: 4.1.2
-      ci-info: 3.3.0
+      ci-info: 4.4.0
       deepmerge: 4.3.1
-      glob: 7.2.3
+      glob: 10.5.0
       graceful-fs: 4.2.11
-      jest-circus: 29.7.0
-      jest-environment-node: 29.7.0
-      jest-get-type: 29.6.3
-      jest-regex-util: 29.6.3
-      jest-resolve: 29.7.0
-      jest-runner: 29.7.0
-      jest-util: 29.7.0
-      jest-validate: 29.7.0
-      micromatch: 4.0.8
+      jest-circus: 30.4.2
+      jest-docblock: 30.4.0
+      jest-environment-node: 30.4.1
+      jest-regex-util: 30.4.0
+      jest-resolve: 30.4.1
+      jest-runner: 30.4.2
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
       parse-json: 5.2.0
-      pretty-format: 29.7.0
+      pretty-format: 30.4.1
       slash: 3.0.0
       strip-json-comments: 3.1.1
     optionalDependencies:
-      '@types/node': 25.5.2
-      ts-node: 10.9.2(@types/node@25.5.2)(typescript@6.0.2)
+      '@types/node': 25.9.1
+      ts-node: 10.9.2(@types/node@25.9.1)(typescript@6.0.3)
     transitivePeerDependencies:
       - babel-plugin-macros
       - supports-color
 
-  jest-diff@29.7.0:
+  jest-diff@30.4.1:
     dependencies:
-      chalk: 4.1.2
-      diff-sequences: 29.6.3
-      jest-get-type: 29.6.3
-      pretty-format: 29.7.0
-
-  jest-diff@30.3.0:
-    dependencies:
-      '@jest/diff-sequences': 30.3.0
+      '@jest/diff-sequences': 30.4.0
       '@jest/get-type': 30.1.0
       chalk: 4.1.2
-      pretty-format: 30.3.0
+      pretty-format: 30.4.1
 
-  jest-docblock@29.7.0:
+  jest-docblock@30.4.0:
     dependencies:
       detect-newline: 3.1.0
 
-  jest-each@29.7.0:
+  jest-each@30.4.1:
     dependencies:
-      '@jest/types': 29.6.3
+      '@jest/get-type': 30.1.0
+      '@jest/types': 30.4.1
       chalk: 4.1.2
-      jest-get-type: 29.6.3
-      jest-util: 29.7.0
-      pretty-format: 29.7.0
+      jest-util: 30.4.1
+      pretty-format: 30.4.1
 
-  jest-environment-node@29.7.0:
+  jest-environment-node@30.4.1:
     dependencies:
-      '@jest/environment': 29.7.0
-      '@jest/fake-timers': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
-      jest-mock: 29.7.0
-      jest-util: 29.7.0
+      '@jest/environment': 30.4.1
+      '@jest/fake-timers': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
+      jest-mock: 30.4.1
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
 
-  jest-get-type@29.6.3: {}
-
-  jest-haste-map@29.7.0:
+  jest-haste-map@30.4.1:
     dependencies:
-      '@jest/types': 29.6.3
-      '@types/graceful-fs': 4.1.9
-      '@types/node': 25.5.2
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       anymatch: 3.1.3
       fb-watchman: 2.0.2
       graceful-fs: 4.2.11
-      jest-regex-util: 29.6.3
-      jest-util: 29.7.0
-      jest-worker: 29.7.0
-      micromatch: 4.0.8
+      jest-regex-util: 30.4.0
+      jest-util: 30.4.1
+      jest-worker: 30.4.1
+      picomatch: 4.0.4
       walker: 1.0.8
     optionalDependencies:
       fsevents: 2.3.3
 
-  jest-leak-detector@29.7.0:
-    dependencies:
-      jest-get-type: 29.6.3
-      pretty-format: 29.7.0
-
-  jest-matcher-utils@29.7.0:
-    dependencies:
-      chalk: 4.1.2
-      jest-diff: 29.7.0
-      jest-get-type: 29.6.3
-      pretty-format: 29.7.0
-
-  jest-matcher-utils@30.3.0:
+  jest-leak-detector@30.4.1:
     dependencies:
       '@jest/get-type': 30.1.0
-      chalk: 4.1.2
-      jest-diff: 30.3.0
-      pretty-format: 30.3.0
+      pretty-format: 30.4.1
 
-  jest-message-util@29.7.0:
+  jest-matcher-utils@30.4.1:
     dependencies:
-      '@babel/code-frame': 7.29.0
-      '@jest/types': 29.6.3
-      '@types/stack-utils': 2.0.3
+      '@jest/get-type': 30.1.0
       chalk: 4.1.2
-      graceful-fs: 4.2.11
-      micromatch: 4.0.8
-      pretty-format: 29.7.0
-      slash: 3.0.0
-      stack-utils: 2.0.6
+      jest-diff: 30.4.1
+      pretty-format: 30.4.1
 
-  jest-message-util@30.3.0:
+  jest-message-util@30.4.1:
     dependencies:
-      '@babel/code-frame': 7.29.0
-      '@jest/types': 30.3.0
+      '@babel/code-frame': 7.29.7
+      '@jest/types': 30.4.1
       '@types/stack-utils': 2.0.3
       chalk: 4.1.2
       graceful-fs: 4.2.11
+      jest-util: 30.4.1
       picomatch: 4.0.4
-      pretty-format: 30.3.0
+      pretty-format: 30.4.1
       slash: 3.0.0
       stack-utils: 2.0.6
 
-  jest-mock@29.7.0:
-    dependencies:
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
-      jest-util: 29.7.0
-
-  jest-mock@30.3.0:
+  jest-mock@30.4.1:
     dependencies:
-      '@jest/types': 30.3.0
-      '@types/node': 25.5.2
-      jest-util: 30.3.0
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
+      jest-util: 30.4.1
 
-  jest-pnp-resolver@1.2.3(jest-resolve@29.7.0):
+  jest-pnp-resolver@1.2.3(jest-resolve@30.4.1):
     optionalDependencies:
-      jest-resolve: 29.7.0
-
-  jest-regex-util@29.6.3: {}
+      jest-resolve: 30.4.1
 
-  jest-regex-util@30.0.1: {}
+  jest-regex-util@30.4.0: {}
 
-  jest-resolve-dependencies@29.7.0:
+  jest-resolve-dependencies@30.4.2:
     dependencies:
-      jest-regex-util: 29.6.3
-      jest-snapshot: 29.7.0
+      jest-regex-util: 30.4.0
+      jest-snapshot: 30.4.1
     transitivePeerDependencies:
       - supports-color
 
-  jest-resolve@29.7.0:
+  jest-resolve@30.4.1:
     dependencies:
       chalk: 4.1.2
       graceful-fs: 4.2.11
-      jest-haste-map: 29.7.0
-      jest-pnp-resolver: 1.2.3(jest-resolve@29.7.0)
-      jest-util: 29.7.0
-      jest-validate: 29.7.0
-      resolve: 1.22.11
-      resolve.exports: 2.0.3
+      jest-haste-map: 30.4.1
+      jest-pnp-resolver: 1.2.3(jest-resolve@30.4.1)
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
       slash: 3.0.0
+      unrs-resolver: 1.12.2
 
-  jest-runner@29.7.0:
+  jest-runner@30.4.2:
     dependencies:
-      '@jest/console': 29.7.0
-      '@jest/environment': 29.7.0
-      '@jest/test-result': 29.7.0
-      '@jest/transform': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
+      '@jest/console': 30.4.1
+      '@jest/environment': 30.4.1
+      '@jest/test-result': 30.4.1
+      '@jest/transform': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       chalk: 4.1.2
       emittery: 0.13.1
+      exit-x: 0.2.2
       graceful-fs: 4.2.11
-      jest-docblock: 29.7.0
-      jest-environment-node: 29.7.0
-      jest-haste-map: 29.7.0
-      jest-leak-detector: 29.7.0
-      jest-message-util: 29.7.0
-      jest-resolve: 29.7.0
-      jest-runtime: 29.7.0
-      jest-util: 29.7.0
-      jest-watcher: 29.7.0
-      jest-worker: 29.7.0
+      jest-docblock: 30.4.0
+      jest-environment-node: 30.4.1
+      jest-haste-map: 30.4.1
+      jest-leak-detector: 30.4.1
+      jest-message-util: 30.4.1
+      jest-resolve: 30.4.1
+      jest-runtime: 30.4.2
+      jest-util: 30.4.1
+      jest-watcher: 30.4.1
+      jest-worker: 30.4.1
       p-limit: 3.1.0
       source-map-support: 0.5.13
     transitivePeerDependencies:
       - supports-color
 
-  jest-runtime@29.7.0:
+  jest-runtime@30.4.2:
     dependencies:
-      '@jest/environment': 29.7.0
-      '@jest/fake-timers': 29.7.0
-      '@jest/globals': 29.7.0
-      '@jest/source-map': 29.6.3
-      '@jest/test-result': 29.7.0
-      '@jest/transform': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
+      '@jest/environment': 30.4.1
+      '@jest/fake-timers': 30.4.1
+      '@jest/globals': 30.4.1
+      '@jest/source-map': 30.0.1
+      '@jest/test-result': 30.4.1
+      '@jest/transform': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       chalk: 4.1.2
-      cjs-module-lexer: 1.4.3
+      cjs-module-lexer: 2.2.0
       collect-v8-coverage: 1.0.3
-      glob: 7.2.3
+      glob: 10.5.0
       graceful-fs: 4.2.11
-      jest-haste-map: 29.7.0
-      jest-message-util: 29.7.0
-      jest-mock: 29.7.0
-      jest-regex-util: 29.6.3
-      jest-resolve: 29.7.0
-      jest-snapshot: 29.7.0
-      jest-util: 29.7.0
+      jest-haste-map: 30.4.1
+      jest-message-util: 30.4.1
+      jest-mock: 30.4.1
+      jest-regex-util: 30.4.0
+      jest-resolve: 30.4.1
+      jest-snapshot: 30.4.1
+      jest-util: 30.4.1
       slash: 3.0.0
       strip-bom: 4.0.0
     transitivePeerDependencies:
       - supports-color
 
-  jest-snapshot@29.7.0:
-    dependencies:
-      '@babel/core': 7.29.0
-      '@babel/generator': 7.29.1
-      '@babel/plugin-syntax-jsx': 7.28.6(@babel/core@7.29.0)
-      '@babel/plugin-syntax-typescript': 7.28.6(@babel/core@7.29.0)
-      '@babel/types': 7.29.0
-      '@jest/expect-utils': 29.7.0
-      '@jest/transform': 29.7.0
-      '@jest/types': 29.6.3
-      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.29.0)
+  jest-snapshot@30.4.1:
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7)
+      '@babel/plugin-syntax-typescript': 7.29.7(@babel/core@7.29.7)
+      '@babel/types': 7.29.7
+      '@jest/expect-utils': 30.4.1
+      '@jest/get-type': 30.1.0
+      '@jest/snapshot-utils': 30.4.1
+      '@jest/transform': 30.4.1
+      '@jest/types': 30.4.1
+      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.29.7)
       chalk: 4.1.2
-      expect: 29.7.0
+      expect: 30.4.1
       graceful-fs: 4.2.11
-      jest-diff: 29.7.0
-      jest-get-type: 29.6.3
-      jest-matcher-utils: 29.7.0
-      jest-message-util: 29.7.0
-      jest-util: 29.7.0
-      natural-compare: 1.4.0
-      pretty-format: 29.7.0
-      semver: 7.7.4
+      jest-diff: 30.4.1
+      jest-matcher-utils: 30.4.1
+      jest-message-util: 30.4.1
+      jest-util: 30.4.1
+      pretty-format: 30.4.1
+      semver: 7.8.1
+      synckit: 0.11.13
     transitivePeerDependencies:
       - supports-color
 
-  jest-util@29.7.0:
-    dependencies:
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
-      chalk: 4.1.2
-      ci-info: 3.3.0
-      graceful-fs: 4.2.11
-      picomatch: 2.3.2
-
-  jest-util@30.3.0:
+  jest-util@30.4.1:
     dependencies:
-      '@jest/types': 30.3.0
-      '@types/node': 25.5.2
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       chalk: 4.1.2
       ci-info: 4.4.0
       graceful-fs: 4.2.11
       picomatch: 4.0.4
 
-  jest-validate@29.7.0:
+  jest-validate@30.4.1:
     dependencies:
-      '@jest/types': 29.6.3
+      '@jest/get-type': 30.1.0
+      '@jest/types': 30.4.1
       camelcase: 6.3.0
       chalk: 4.1.2
-      jest-get-type: 29.6.3
       leven: 3.1.0
-      pretty-format: 29.7.0
+      pretty-format: 30.4.1
 
-  jest-watcher@29.7.0:
+  jest-watcher@30.4.1:
     dependencies:
-      '@jest/test-result': 29.7.0
-      '@jest/types': 29.6.3
-      '@types/node': 25.5.2
+      '@jest/test-result': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 25.9.1
       ansi-escapes: 4.3.2
       chalk: 4.1.2
       emittery: 0.13.1
-      jest-util: 29.7.0
+      jest-util: 30.4.1
       string-length: 4.0.2
 
-  jest-worker@29.7.0:
+  jest-worker@30.4.1:
     dependencies:
-      '@types/node': 25.5.2
-      jest-util: 29.7.0
+      '@types/node': 25.9.1
+      '@ungap/structured-clone': 1.3.1
+      jest-util: 30.4.1
       merge-stream: 2.0.0
       supports-color: 8.1.1
 
-  jest@29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2)):
+  jest@30.4.2(@types/node@25.9.1)(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3)):
     dependencies:
-      '@jest/core': 29.7.0(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
-      '@jest/types': 29.6.3
+      '@jest/core': 30.4.2(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3))
+      '@jest/types': 30.4.1
       import-local: 3.2.0
-      jest-cli: 29.7.0(@types/node@25.5.2)(ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2))
+      jest-cli: 30.4.2(@types/node@25.9.1)(ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3))
     transitivePeerDependencies:
       - '@types/node'
       - babel-plugin-macros
+      - esbuild-register
       - supports-color
       - ts-node
 
-  jiti@2.6.1: {}
+  jiti@2.7.0: {}
+
+  jju@1.4.0:
+    optional: true
 
-  jju@1.4.0: {}
+  joycon@3.1.1: {}
+
+  js-tokens@10.0.0: {}
 
   js-tokens@4.0.0: {}
 
@@ -11953,7 +12282,7 @@ snapshots:
       argparse: 1.0.10
       esprima: 4.0.1
 
-  js-yaml@4.1.0:
+  js-yaml@4.2.0:
     dependencies:
       argparse: 2.0.1
 
@@ -11978,7 +12307,7 @@ snapshots:
       whatwg-encoding: 3.1.1
       whatwg-mimetype: 4.0.0
       whatwg-url: 14.2.0
-      ws: 8.20.0
+      ws: 8.21.0
       xml-name-validator: 5.0.0
     transitivePeerDependencies:
       - bufferutil
@@ -12011,11 +12340,12 @@ snapshots:
 
   json5@2.2.3: {}
 
-  jsonfile@6.2.0:
+  jsonfile@6.2.1:
     dependencies:
       universalify: 2.0.1
     optionalDependencies:
       graceful-fs: 4.2.11
+    optional: true
 
   jszip@3.10.1:
     dependencies:
@@ -12034,8 +12364,6 @@ snapshots:
 
   kind-of@6.0.3: {}
 
-  kleur@3.0.3: {}
-
   knuth-shuffle-seeded@1.0.6:
     dependencies:
       seed-random: 2.2.0
@@ -12065,7 +12393,7 @@ snapshots:
 
   lighthouse-logger@2.0.2:
     dependencies:
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       marky: 1.3.0
     transitivePeerDependencies:
       - supports-color
@@ -12127,21 +12455,21 @@ snapshots:
 
   listenercount@1.0.1: {}
 
-  lit-element@4.2.1:
+  lit-element@4.2.2:
     dependencies:
-      '@lit-labs/ssr-dom-shim': 1.4.0
-      '@lit/reactive-element': 2.1.1
-      lit-html: 3.3.1
+      '@lit-labs/ssr-dom-shim': 1.6.0
+      '@lit/reactive-element': 2.1.2
+      lit-html: 3.3.3
 
-  lit-html@3.3.1:
+  lit-html@3.3.3:
     dependencies:
       '@types/trusted-types': 2.0.7
 
-  lit@3.3.2:
+  lit@3.3.3:
     dependencies:
-      '@lit/reactive-element': 2.1.1
-      lit-element: 4.2.1
-      lit-html: 3.3.1
+      '@lit/reactive-element': 2.1.2
+      lit-element: 4.2.2
+      lit-html: 3.3.3
 
   load-json-file@4.0.0:
     dependencies:
@@ -12150,10 +12478,12 @@ snapshots:
       pify: 3.0.0
       strip-bom: 3.0.0
 
-  local-pkg@1.1.2:
+  load-tsconfig@0.2.5: {}
+
+  local-pkg@1.2.1:
     dependencies:
-      mlly: 1.8.0
-      pkg-types: 2.3.0
+      mlly: 1.8.2
+      pkg-types: 2.3.1
       quansync: 0.2.11
 
   locate-app@2.5.0:
@@ -12200,8 +12530,6 @@ snapshots:
 
   lodash.zip@4.2.0: {}
 
-  lodash@4.17.21: {}
-
   lodash@4.18.1: {}
 
   log-symbols@4.1.0:
@@ -12217,15 +12545,13 @@ snapshots:
     dependencies:
       get-func-name: 2.0.2
 
-  loupe@3.2.1: {}
-
   lower-case@2.0.2:
     dependencies:
       tslib: 2.8.1
 
   lru-cache@10.4.3: {}
 
-  lru-cache@11.3.2: {}
+  lru-cache@11.5.1: {}
 
   lru-cache@5.1.1:
     dependencies:
@@ -12239,15 +12565,21 @@ snapshots:
 
   luxon@3.2.1: {}
 
-  luxon@3.6.1: {}
+  luxon@3.7.2: {}
 
   magic-string@0.30.21:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  magicast@0.5.3:
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      source-map-js: 1.2.1
+
   make-dir@4.0.0:
     dependencies:
-      semver: 7.7.4
+      semver: 7.8.1
 
   make-error@1.3.6: {}
 
@@ -12286,29 +12618,26 @@ snapshots:
 
   mimic-fn@2.1.0: {}
 
-  minimatch@10.0.3:
+  minimatch@10.2.3:
     dependencies:
-      '@isaacs/brace-expansion': 5.0.0
+      brace-expansion: 5.0.6
+    optional: true
 
   minimatch@10.2.5:
     dependencies:
-      brace-expansion: 5.0.5
-
-  minimatch@3.1.2:
-    dependencies:
-      brace-expansion: 1.1.12
+      brace-expansion: 5.0.6
 
   minimatch@3.1.5:
     dependencies:
-      brace-expansion: 1.1.13
+      brace-expansion: 1.1.15
 
   minimatch@5.1.9:
     dependencies:
-      brace-expansion: 2.0.3
+      brace-expansion: 2.1.1
 
   minimatch@9.0.9:
     dependencies:
-      brace-expansion: 2.0.3
+      brace-expansion: 2.1.1
 
   minimist@1.2.6: {}
 
@@ -12326,12 +12655,14 @@ snapshots:
 
   mkdirp@2.1.6: {}
 
-  mlly@1.8.0:
+  mkdirp@3.0.1: {}
+
+  mlly@1.8.2:
     dependencies:
-      acorn: 8.15.0
+      acorn: 8.16.0
       pathe: 2.0.3
       pkg-types: 1.3.1
-      ufo: 1.6.1
+      ufo: 1.6.4
 
   mocha@10.8.2:
     dependencies:
@@ -12344,7 +12675,7 @@ snapshots:
       find-up: 5.0.0
       glob: 8.1.0
       he: 1.2.0
-      js-yaml: 4.1.0
+      js-yaml: 4.2.0
       log-symbols: 4.1.0
       minimatch: 5.1.9
       ms: 2.1.3
@@ -12356,6 +12687,30 @@ snapshots:
       yargs-parser: 20.2.9
       yargs-unparser: 2.0.0
 
+  mocha@11.7.6:
+    dependencies:
+      browser-stdout: 1.3.1
+      chokidar: 4.0.3
+      debug: 4.4.3(supports-color@8.1.1)
+      diff: 7.0.0
+      escape-string-regexp: 4.0.0
+      find-up: 5.0.0
+      glob: 10.5.0
+      he: 1.2.0
+      is-path-inside: 3.0.3
+      js-yaml: 4.2.0
+      log-symbols: 4.1.0
+      minimatch: 9.0.9
+      ms: 2.1.3
+      picocolors: 1.1.1
+      serialize-javascript: 6.0.2
+      strip-json-comments: 3.1.1
+      supports-color: 8.1.1
+      workerpool: 9.3.4
+      yargs: 17.7.2
+      yargs-parser: 21.1.1
+      yargs-unparser: 2.0.0
+
   modern-tar@0.7.6: {}
 
   mrmime@2.0.1: {}
@@ -12364,8 +12719,6 @@ snapshots:
 
   ms@2.1.3: {}
 
-  muggle-string@0.4.1: {}
-
   mute-stream@2.0.0: {}
 
   mz@2.7.0:
@@ -12374,25 +12727,27 @@ snapshots:
       object-assign: 4.1.1
       thenify-all: 1.6.0
 
-  nanoid@3.3.11: {}
+  nanoid@3.3.12: {}
+
+  napi-postinstall@0.3.4: {}
 
   natural-compare@1.4.0: {}
 
-  netmask@2.0.2: {}
+  netmask@2.1.1: {}
 
   nice-try@1.0.5: {}
 
-  nightwatch-axe-verbose@2.4.0:
+  nightwatch-axe-verbose@2.5.1:
     dependencies:
-      axe-core: 4.11.1
+      axe-core: 4.12.0
 
-  nightwatch@3.15.0(@cucumber/cucumber@11.3.0)(chromedriver@148.0.3):
+  nightwatch@3.16.0(@cucumber/cucumber@13.0.0)(chromedriver@148.0.4):
     dependencies:
       '@nightwatch/chai': 5.0.3
       '@nightwatch/html-reporter-template': 0.3.0
       '@nightwatch/nightwatch-inspector': 1.0.1
       '@types/chai': 4.3.20
-      '@types/selenium-webdriver': 4.35.5
+      '@types/selenium-webdriver': 4.35.6
       ansi-to-html: 0.7.2
       aria-query: 5.1.3
       assertion-error: 1.1.0
@@ -12400,7 +12755,7 @@ snapshots:
       chai-nightwatch: 0.5.3
       chalk: 4.1.2
       ci-info: 3.3.0
-      cli-table3: 0.6.3
+      cli-table3: 0.6.5
       devtools-protocol: 0.0.1140464
       didyoumean: 1.2.2
       dotenv: 16.3.1
@@ -12408,11 +12763,11 @@ snapshots:
       envinfo: 7.11.0
       glob: 7.2.3
       jsdom: 24.1.3
-      lodash: 4.17.21
-      minimatch: 3.1.2
+      lodash: 4.18.1
+      minimatch: 3.1.5
       minimist: 1.2.6
       mocha: 10.8.2
-      nightwatch-axe-verbose: 2.4.0
+      nightwatch-axe-verbose: 2.5.1
       open: 8.4.2
       ora: 5.4.1
       piscina: 4.9.2
@@ -12423,8 +12778,8 @@ snapshots:
       untildify: 4.0.0
       uuid: 8.3.2
     optionalDependencies:
-      '@cucumber/cucumber': 11.3.0
-      chromedriver: 148.0.3
+      '@cucumber/cucumber': 13.0.0
+      chromedriver: 148.0.4
     transitivePeerDependencies:
       - bufferutil
       - canvas
@@ -12438,6 +12793,13 @@ snapshots:
 
   node-domexception@1.0.0: {}
 
+  node-exports-info@1.6.0:
+    dependencies:
+      array.prototype.flatmap: 1.3.3
+      es-errors: 1.3.0
+      object.entries: 1.1.9
+      semver: 6.3.1
+
   node-fetch@2.7.0:
     dependencies:
       whatwg-url: 5.0.0
@@ -12450,9 +12812,7 @@ snapshots:
 
   node-int64@0.4.0: {}
 
-  node-releases@2.0.26: {}
-
-  node-releases@2.0.37: {}
+  node-releases@2.0.47: {}
 
   nodemon@3.1.14:
     dependencies:
@@ -12461,7 +12821,7 @@ snapshots:
       ignore-by-default: 1.0.1
       minimatch: 10.2.5
       pstree.remy: 1.1.8
-      semver: 7.7.3
+      semver: 7.8.1
       simple-update-notifier: 2.0.0
       supports-color: 5.5.0
       touch: 3.1.1
@@ -12470,25 +12830,29 @@ snapshots:
   normalize-package-data@2.5.0:
     dependencies:
       hosted-git-info: 2.8.9
-      resolve: 1.22.11
+      resolve: 1.22.12
       semver: 5.7.2
       validate-npm-package-license: 3.0.4
 
   normalize-package-data@6.0.2:
     dependencies:
       hosted-git-info: 7.0.2
-      semver: 7.7.4
+      semver: 7.8.1
       validate-npm-package-license: 3.0.4
 
   normalize-package-data@7.0.1:
     dependencies:
       hosted-git-info: 8.1.0
-      semver: 7.7.4
+      semver: 7.8.1
       validate-npm-package-license: 3.0.4
 
-  normalize-path@3.0.0: {}
+  normalize-package-data@8.0.0:
+    dependencies:
+      hosted-git-info: 9.0.3
+      semver: 7.8.1
+      validate-npm-package-license: 3.0.4
 
-  normalize-range@0.1.2: {}
+  normalize-path@3.0.0: {}
 
   npm-run-all@4.1.5:
     dependencies:
@@ -12496,10 +12860,10 @@ snapshots:
       chalk: 2.4.2
       cross-spawn: 6.0.6
       memorystream: 0.3.1
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       pidtree: 0.3.1
       read-pkg: 3.0.0
-      shell-quote: 1.8.3
+      shell-quote: 1.8.4
       string.prototype.padend: 3.1.6
 
   npm-run-path@4.0.1:
@@ -12523,39 +12887,46 @@ snapshots:
 
   object-is@1.1.6:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
 
   object-keys@1.1.1: {}
 
   object.assign@4.1.7:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       has-symbols: 1.1.0
       object-keys: 1.1.1
 
+  object.entries@1.1.9:
+    dependencies:
+      call-bind: 1.0.9
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.2
+
   object.fromentries@2.0.8:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-object-atoms: 1.1.1
+      es-abstract: 1.24.2
+      es-object-atoms: 1.1.2
 
   object.groupby@1.0.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.0
+      es-abstract: 1.24.2
 
   object.values@1.2.1:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   obug@2.1.1: {}
 
@@ -12632,7 +13003,7 @@ snapshots:
     dependencies:
       '@tootallnate/quickjs-emscripten': 0.23.0
       agent-base: 7.1.4
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       get-uri: 6.0.5
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
@@ -12644,7 +13015,7 @@ snapshots:
   pac-proxy-agent@9.0.1:
     dependencies:
       agent-base: 9.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       get-uri: 8.0.0
       http-proxy-agent: 9.0.0
       https-proxy-agent: 9.0.0
@@ -12657,17 +13028,17 @@ snapshots:
   pac-resolver@7.0.1:
     dependencies:
       degenerator: 5.0.1
-      netmask: 2.0.2
+      netmask: 2.1.1
 
   pac-resolver@9.0.1(quickjs-wasi@2.2.0):
     dependencies:
       degenerator: 7.0.1(quickjs-wasi@2.2.0)
-      netmask: 2.0.2
+      netmask: 2.1.1
       quickjs-wasi: 2.2.0
 
   package-json-from-dist@1.0.1: {}
 
-  package-manager-detector@1.5.0: {}
+  package-manager-detector@1.6.0: {}
 
   pad-right@0.2.2:
     dependencies:
@@ -12686,14 +13057,14 @@ snapshots:
 
   parse-json@5.2.0:
     dependencies:
-      '@babel/code-frame': 7.29.0
+      '@babel/code-frame': 7.29.7
       error-ex: 1.3.4
       json-parse-even-better-errors: 2.3.1
       lines-and-columns: 1.2.4
 
   parse-json@7.1.1:
     dependencies:
-      '@babel/code-frame': 7.29.0
+      '@babel/code-frame': 7.29.7
       error-ex: 1.3.4
       json-parse-even-better-errors: 3.0.2
       lines-and-columns: 2.0.4
@@ -12701,7 +13072,7 @@ snapshots:
 
   parse-json@8.3.0:
     dependencies:
-      '@babel/code-frame': 7.29.0
+      '@babel/code-frame': 7.29.7
       index-to-position: 1.2.0
       type-fest: 4.41.0
 
@@ -12720,9 +13091,9 @@ snapshots:
     dependencies:
       entities: 6.0.1
 
-  parse5@8.0.0:
+  parse5@8.0.1:
     dependencies:
-      entities: 6.0.1
+      entities: 8.0.0
 
   path-browserify@1.0.1: {}
 
@@ -12730,7 +13101,7 @@ snapshots:
 
   path-exists@5.0.0: {}
 
-  path-expression-matcher@1.4.0: {}
+  path-expression-matcher@1.5.0: {}
 
   path-is-absolute@1.0.1: {}
 
@@ -12749,7 +13120,7 @@ snapshots:
 
   path-scurry@2.0.2:
     dependencies:
-      lru-cache: 11.3.2
+      lru-cache: 11.5.1
       minipass: 7.1.3
 
   path-type@3.0.0:
@@ -12762,8 +13133,6 @@ snapshots:
 
   pathval@1.1.1: {}
 
-  pathval@2.0.1: {}
-
   pend@1.2.0: {}
 
   picocolors@1.1.1: {}
@@ -12796,7 +13165,7 @@ snapshots:
       real-require: 0.2.0
       safe-stable-stringify: 2.5.0
       sonic-boom: 4.2.1
-      thread-stream: 4.0.0
+      thread-stream: 4.2.0
 
   pirates@4.0.7: {}
 
@@ -12811,13 +13180,13 @@ snapshots:
   pkg-types@1.3.1:
     dependencies:
       confbox: 0.1.8
-      mlly: 1.8.0
+      mlly: 1.8.2
       pathe: 2.0.3
 
-  pkg-types@2.3.0:
+  pkg-types@2.3.1:
     dependencies:
-      confbox: 0.2.2
-      exsolve: 1.0.7
+      confbox: 0.2.4
+      exsolve: 1.0.8
       pathe: 2.0.3
 
   placeholder-loading@0.7.0: {}
@@ -12830,39 +13199,39 @@ snapshots:
 
   possible-typed-array-names@1.1.0: {}
 
-  postcss-import@16.1.1(postcss@8.5.6):
+  postcss-import@16.1.1(postcss@8.5.15):
     dependencies:
-      postcss: 8.5.6
+      postcss: 8.5.15
       postcss-value-parser: 4.2.0
       read-cache: 1.0.0
-      resolve: 1.22.11
+      resolve: 1.22.12
 
-  postcss-lit@1.4.1(jiti@2.6.1)(postcss@8.5.9)(tsx@4.21.0)(yaml@2.8.3):
+  postcss-lit@1.4.1(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(yaml@2.9.0):
     dependencies:
-      '@babel/generator': 7.29.1
-      '@babel/parser': 7.29.2
-      '@babel/traverse': 7.29.0
+      '@babel/generator': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/traverse': 7.29.7
       lilconfig: 3.1.3
-      postcss: 8.5.9
-      postcss-load-config: 6.0.1(jiti@2.6.1)(postcss@8.5.9)(tsx@4.21.0)(yaml@2.8.3)
+      postcss: 8.5.15
+      postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(yaml@2.9.0)
     transitivePeerDependencies:
       - jiti
       - supports-color
       - tsx
       - yaml
 
-  postcss-load-config@6.0.1(jiti@2.6.1)(postcss@8.5.9)(tsx@4.21.0)(yaml@2.8.3):
+  postcss-load-config@6.0.1(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(yaml@2.9.0):
     dependencies:
       lilconfig: 3.1.3
     optionalDependencies:
-      jiti: 2.6.1
-      postcss: 8.5.9
-      tsx: 4.21.0
-      yaml: 2.8.3
+      jiti: 2.7.0
+      postcss: 8.5.15
+      tsx: 4.22.4
+      yaml: 2.9.0
 
-  postcss-safe-parser@7.0.1(postcss@8.5.9):
+  postcss-safe-parser@7.0.1(postcss@8.5.15):
     dependencies:
-      postcss: 8.5.9
+      postcss: 8.5.15
 
   postcss-selector-parser@7.1.1:
     dependencies:
@@ -12871,19 +13240,13 @@ snapshots:
 
   postcss-value-parser@4.2.0: {}
 
-  postcss@8.5.6:
-    dependencies:
-      nanoid: 3.3.11
-      picocolors: 1.1.1
-      source-map-js: 1.2.1
-
-  postcss@8.5.9:
+  postcss@8.5.15:
     dependencies:
-      nanoid: 3.3.11
+      nanoid: 3.3.12
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
-  preact@10.29.1: {}
+  preact@10.29.2: {}
 
   prelude-ls@1.2.1: {}
 
@@ -12891,19 +13254,14 @@ snapshots:
     dependencies:
       fast-diff: 1.3.0
 
-  prettier@3.8.1: {}
-
-  pretty-format@29.7.0:
-    dependencies:
-      '@jest/schemas': 29.6.3
-      ansi-styles: 5.2.0
-      react-is: 18.3.1
+  prettier@3.8.3: {}
 
-  pretty-format@30.3.0:
+  pretty-format@30.4.1:
     dependencies:
-      '@jest/schemas': 30.0.5
+      '@jest/schemas': 30.4.1
       ansi-styles: 5.2.0
-      react-is: 18.3.1
+      react-is-18: react-is@18.3.1
+      react-is-19: react-is@19.2.7
 
   pretty-ms@9.3.0:
     dependencies:
@@ -12919,17 +13277,12 @@ snapshots:
 
   progress@2.0.3: {}
 
-  prompts@2.4.2:
-    dependencies:
-      kleur: 3.0.3
-      sisteransi: 1.0.5
-
   property-expr@2.0.6: {}
 
   proxy-agent@6.3.1:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
       lru-cache: 7.18.3
@@ -12942,7 +13295,7 @@ snapshots:
   proxy-agent@6.5.0:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
       lru-cache: 7.18.3
@@ -12955,7 +13308,7 @@ snapshots:
   proxy-agent@8.0.1:
     dependencies:
       agent-base: 9.0.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       http-proxy-agent: 9.0.0
       https-proxy-agent: 9.0.0
       lru-cache: 7.18.3
@@ -12999,11 +13352,11 @@ snapshots:
       - supports-color
       - utf-8-validate
 
-  pure-rand@6.1.0: {}
+  pure-rand@7.0.1: {}
 
-  qified@0.9.1:
+  qified@0.10.1:
     dependencies:
-      hookified: 2.1.1
+      hookified: 2.2.0
 
   quansync@0.2.11: {}
 
@@ -13023,15 +13376,17 @@ snapshots:
 
   react-is@18.3.1: {}
 
+  react-is@19.2.7: {}
+
   read-cache@1.0.0:
     dependencies:
       pify: 2.3.0
 
-  read-package-up@11.0.0:
+  read-package-up@12.0.0:
     dependencies:
       find-up-simple: 1.0.1
-      read-pkg: 9.0.1
-      type-fest: 4.41.0
+      read-pkg: 10.1.0
+      type-fest: 5.7.0
 
   read-pkg-up@10.1.0:
     dependencies:
@@ -13045,6 +13400,14 @@ snapshots:
       read-pkg: 5.2.0
       type-fest: 0.8.1
 
+  read-pkg@10.1.0:
+    dependencies:
+      '@types/normalize-package-data': 2.4.4
+      normalize-package-data: 8.0.0
+      parse-json: 8.3.0
+      type-fest: 5.7.0
+      unicorn-magic: 0.4.0
+
   read-pkg@3.0.0:
     dependencies:
       load-json-file: 4.0.0
@@ -13065,14 +13428,6 @@ snapshots:
       parse-json: 7.1.1
       type-fest: 4.41.0
 
-  read-pkg@9.0.1:
-    dependencies:
-      '@types/normalize-package-data': 2.4.4
-      normalize-package-data: 6.0.2
-      parse-json: 8.3.0
-      type-fest: 4.41.0
-      unicorn-magic: 0.1.0
-
   readable-stream@2.3.8:
     dependencies:
       core-util-is: 1.0.3
@@ -13109,6 +13464,8 @@ snapshots:
 
   real-require@0.2.0: {}
 
+  real-require@1.0.0: {}
+
   recursive-readdir@2.2.3:
     dependencies:
       minimatch: 3.1.5
@@ -13119,11 +13476,11 @@ snapshots:
 
   reflect.getprototypeof@1.0.10:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.0
+      es-abstract: 1.24.2
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
       get-intrinsic: 1.3.0
       get-proto: 1.0.1
       which-builtin-type: 1.2.1
@@ -13136,14 +13493,14 @@ snapshots:
 
   regexp.prototype.flags@1.5.4:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
       es-errors: 1.3.0
       get-proto: 1.0.1
       gopd: 1.2.0
       set-function-name: 2.0.2
 
-  regjsparser@0.13.0:
+  regjsparser@0.13.1:
     dependencies:
       jsesc: 3.1.0
 
@@ -13163,17 +13520,23 @@ snapshots:
 
   resolve-from@5.0.0: {}
 
-  resolve-pkg-maps@1.0.0: {}
-
   resolve-pkg@2.0.0:
     dependencies:
       resolve-from: 5.0.0
 
-  resolve.exports@2.0.3: {}
+  resolve@1.22.12:
+    dependencies:
+      es-errors: 1.3.0
+      is-core-module: 2.16.2
+      path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
 
-  resolve@1.22.11:
+  resolve@2.0.0-next.7:
     dependencies:
-      is-core-module: 2.16.1
+      es-errors: 1.3.0
+      is-core-module: 2.16.2
+      node-exports-info: 1.6.0
+      object-keys: 1.1.1
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
@@ -13198,56 +13561,56 @@ snapshots:
     dependencies:
       glob: 7.2.3
 
-  rolldown@1.0.0-rc.13:
+  rolldown@1.0.3:
     dependencies:
-      '@oxc-project/types': 0.123.0
-      '@rolldown/pluginutils': 1.0.0-rc.13
+      '@oxc-project/types': 0.133.0
+      '@rolldown/pluginutils': 1.0.1
     optionalDependencies:
-      '@rolldown/binding-android-arm64': 1.0.0-rc.13
-      '@rolldown/binding-darwin-arm64': 1.0.0-rc.13
-      '@rolldown/binding-darwin-x64': 1.0.0-rc.13
-      '@rolldown/binding-freebsd-x64': 1.0.0-rc.13
-      '@rolldown/binding-linux-arm-gnueabihf': 1.0.0-rc.13
-      '@rolldown/binding-linux-arm64-gnu': 1.0.0-rc.13
-      '@rolldown/binding-linux-arm64-musl': 1.0.0-rc.13
-      '@rolldown/binding-linux-ppc64-gnu': 1.0.0-rc.13
-      '@rolldown/binding-linux-s390x-gnu': 1.0.0-rc.13
-      '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.13
-      '@rolldown/binding-linux-x64-musl': 1.0.0-rc.13
-      '@rolldown/binding-openharmony-arm64': 1.0.0-rc.13
-      '@rolldown/binding-wasm32-wasi': 1.0.0-rc.13
-      '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.13
-      '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.13
-
-  rollup@4.60.1:
-    dependencies:
-      '@types/estree': 1.0.8
+      '@rolldown/binding-android-arm64': 1.0.3
+      '@rolldown/binding-darwin-arm64': 1.0.3
+      '@rolldown/binding-darwin-x64': 1.0.3
+      '@rolldown/binding-freebsd-x64': 1.0.3
+      '@rolldown/binding-linux-arm-gnueabihf': 1.0.3
+      '@rolldown/binding-linux-arm64-gnu': 1.0.3
+      '@rolldown/binding-linux-arm64-musl': 1.0.3
+      '@rolldown/binding-linux-ppc64-gnu': 1.0.3
+      '@rolldown/binding-linux-s390x-gnu': 1.0.3
+      '@rolldown/binding-linux-x64-gnu': 1.0.3
+      '@rolldown/binding-linux-x64-musl': 1.0.3
+      '@rolldown/binding-openharmony-arm64': 1.0.3
+      '@rolldown/binding-wasm32-wasi': 1.0.3
+      '@rolldown/binding-win32-arm64-msvc': 1.0.3
+      '@rolldown/binding-win32-x64-msvc': 1.0.3
+
+  rollup@4.61.0:
+    dependencies:
+      '@types/estree': 1.0.9
     optionalDependencies:
-      '@rollup/rollup-android-arm-eabi': 4.60.1
-      '@rollup/rollup-android-arm64': 4.60.1
-      '@rollup/rollup-darwin-arm64': 4.60.1
-      '@rollup/rollup-darwin-x64': 4.60.1
-      '@rollup/rollup-freebsd-arm64': 4.60.1
-      '@rollup/rollup-freebsd-x64': 4.60.1
-      '@rollup/rollup-linux-arm-gnueabihf': 4.60.1
-      '@rollup/rollup-linux-arm-musleabihf': 4.60.1
-      '@rollup/rollup-linux-arm64-gnu': 4.60.1
-      '@rollup/rollup-linux-arm64-musl': 4.60.1
-      '@rollup/rollup-linux-loong64-gnu': 4.60.1
-      '@rollup/rollup-linux-loong64-musl': 4.60.1
-      '@rollup/rollup-linux-ppc64-gnu': 4.60.1
-      '@rollup/rollup-linux-ppc64-musl': 4.60.1
-      '@rollup/rollup-linux-riscv64-gnu': 4.60.1
-      '@rollup/rollup-linux-riscv64-musl': 4.60.1
-      '@rollup/rollup-linux-s390x-gnu': 4.60.1
-      '@rollup/rollup-linux-x64-gnu': 4.60.1
-      '@rollup/rollup-linux-x64-musl': 4.60.1
-      '@rollup/rollup-openbsd-x64': 4.60.1
-      '@rollup/rollup-openharmony-arm64': 4.60.1
-      '@rollup/rollup-win32-arm64-msvc': 4.60.1
-      '@rollup/rollup-win32-ia32-msvc': 4.60.1
-      '@rollup/rollup-win32-x64-gnu': 4.60.1
-      '@rollup/rollup-win32-x64-msvc': 4.60.1
+      '@rollup/rollup-android-arm-eabi': 4.61.0
+      '@rollup/rollup-android-arm64': 4.61.0
+      '@rollup/rollup-darwin-arm64': 4.61.0
+      '@rollup/rollup-darwin-x64': 4.61.0
+      '@rollup/rollup-freebsd-arm64': 4.61.0
+      '@rollup/rollup-freebsd-x64': 4.61.0
+      '@rollup/rollup-linux-arm-gnueabihf': 4.61.0
+      '@rollup/rollup-linux-arm-musleabihf': 4.61.0
+      '@rollup/rollup-linux-arm64-gnu': 4.61.0
+      '@rollup/rollup-linux-arm64-musl': 4.61.0
+      '@rollup/rollup-linux-loong64-gnu': 4.61.0
+      '@rollup/rollup-linux-loong64-musl': 4.61.0
+      '@rollup/rollup-linux-ppc64-gnu': 4.61.0
+      '@rollup/rollup-linux-ppc64-musl': 4.61.0
+      '@rollup/rollup-linux-riscv64-gnu': 4.61.0
+      '@rollup/rollup-linux-riscv64-musl': 4.61.0
+      '@rollup/rollup-linux-s390x-gnu': 4.61.0
+      '@rollup/rollup-linux-x64-gnu': 4.61.0
+      '@rollup/rollup-linux-x64-musl': 4.61.0
+      '@rollup/rollup-openbsd-x64': 4.61.0
+      '@rollup/rollup-openharmony-arm64': 4.61.0
+      '@rollup/rollup-win32-arm64-msvc': 4.61.0
+      '@rollup/rollup-win32-ia32-msvc': 4.61.0
+      '@rollup/rollup-win32-x64-gnu': 4.61.0
+      '@rollup/rollup-win32-x64-msvc': 4.61.0
       fsevents: 2.3.3
 
   rrweb-cssom@0.7.1: {}
@@ -13268,9 +13631,9 @@ snapshots:
 
   safaridriver@1.0.1: {}
 
-  safe-array-concat@1.1.3:
+  safe-array-concat@1.1.4:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       get-intrinsic: 1.3.0
       has-symbols: 1.1.0
@@ -13291,13 +13654,13 @@ snapshots:
       es-errors: 1.3.0
       is-regex: 1.2.1
 
-  safe-regex2@5.0.0:
+  safe-regex2@5.1.1:
     dependencies:
       ret: 0.5.0
 
-  safe-regex2@5.1.0:
+  safe-regex@2.1.1:
     dependencies:
-      ret: 0.5.0
+      regexp-tree: 0.1.27
 
   safe-stable-stringify@2.5.0: {}
 
@@ -13315,8 +13678,18 @@ snapshots:
     dependencies:
       '@bazel/runfiles': 6.5.0
       jszip: 3.10.1
-      tmp: 0.2.3
-      ws: 8.20.0
+      tmp: 0.2.7
+      ws: 8.21.0
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  selenium-webdriver@4.44.0:
+    dependencies:
+      '@bazel/runfiles': 6.5.0
+      jszip: 3.10.1
+      tmp: 0.2.7
+      ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
@@ -13333,11 +13706,10 @@ snapshots:
     dependencies:
       lru-cache: 6.0.0
 
-  semver@7.7.1: {}
-
-  semver@7.7.3: {}
+  semver@7.7.4:
+    optional: true
 
-  semver@7.7.4: {}
+  semver@7.8.1: {}
 
   serialize-error@12.0.0:
     dependencies:
@@ -13369,7 +13741,7 @@ snapshots:
     dependencies:
       dunder-proto: 1.0.1
       es-errors: 1.3.0
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   setimmediate@1.0.5: {}
 
@@ -13387,9 +13759,9 @@ snapshots:
 
   shebang-regex@3.0.0: {}
 
-  shell-quote@1.8.3: {}
+  shell-quote@1.8.4: {}
 
-  side-channel-list@1.0.0:
+  side-channel-list@1.0.1:
     dependencies:
       es-errors: 1.3.0
       object-inspect: 1.13.4
@@ -13413,7 +13785,7 @@ snapshots:
     dependencies:
       es-errors: 1.3.0
       object-inspect: 1.13.4
-      side-channel-list: 1.0.0
+      side-channel-list: 1.0.1
       side-channel-map: 1.0.1
       side-channel-weakmap: 1.0.2
 
@@ -13425,7 +13797,7 @@ snapshots:
 
   simple-update-notifier@2.0.0:
     dependencies:
-      semver: 7.7.3
+      semver: 7.8.1
 
   sirv@3.0.2:
     dependencies:
@@ -13433,8 +13805,6 @@ snapshots:
       mrmime: 2.0.1
       totalist: 3.0.1
 
-  sisteransi@1.0.5: {}
-
   slash@3.0.0: {}
 
   slash@5.1.0: {}
@@ -13450,22 +13820,22 @@ snapshots:
   socks-proxy-agent@10.0.0:
     dependencies:
       agent-base: 9.0.0
-      debug: 4.4.3
-      socks: 2.8.7
+      debug: 4.4.3(supports-color@5.5.0)
+      socks: 2.8.9
     transitivePeerDependencies:
       - supports-color
 
   socks-proxy-agent@8.0.5:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3
-      socks: 2.8.7
+      debug: 4.4.3(supports-color@5.5.0)
+      socks: 2.8.9
     transitivePeerDependencies:
       - supports-color
 
-  socks@2.8.7:
+  socks@2.8.9:
     dependencies:
-      ip-address: 10.0.1
+      ip-address: 10.2.0
       smart-buffer: 4.2.0
 
   sonic-boom@4.2.1:
@@ -13486,6 +13856,8 @@ snapshots:
 
   source-map@0.6.1: {}
 
+  source-map@0.7.6: {}
+
   spacetrim@0.11.59: {}
 
   spdx-correct@3.2.0:
@@ -13506,7 +13878,7 @@ snapshots:
 
   sprintf-js@1.0.3: {}
 
-  stack-trace@1.0.0-pre2: {}
+  stack-trace@1.0.0: {}
 
   stack-utils@2.0.6:
     dependencies:
@@ -13526,9 +13898,7 @@ snapshots:
 
   statuses@2.0.2: {}
 
-  std-env@3.10.0: {}
-
-  std-env@4.0.0: {}
+  std-env@4.1.0: {}
 
   stop-iteration-iterator@1.1.0:
     dependencies:
@@ -13539,7 +13909,7 @@ snapshots:
 
   stream-shift@1.0.3: {}
 
-  streamx@2.25.0:
+  streamx@2.26.0:
     dependencies:
       events-universal: 1.0.1
       fast-fifo: 1.3.2
@@ -13569,40 +13939,40 @@ snapshots:
       emoji-regex: 9.2.2
       strip-ansi: 7.2.0
 
-  string-width@8.2.0:
+  string-width@8.2.1:
     dependencies:
-      get-east-asian-width: 1.5.0
+      get-east-asian-width: 1.6.0
       strip-ansi: 7.2.0
 
   string.prototype.padend@3.1.6:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-object-atoms: 1.1.1
+      es-abstract: 1.24.2
+      es-object-atoms: 1.1.2
 
   string.prototype.trim@1.2.10:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-data-property: 1.1.4
       define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-object-atoms: 1.1.1
+      es-abstract: 1.24.2
+      es-object-atoms: 1.1.2
       has-property-descriptors: 1.0.2
 
   string.prototype.trimend@1.0.9:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   string.prototype.trimstart@1.0.8:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      es-object-atoms: 1.1.2
 
   string_decoder@1.1.1:
     dependencies:
@@ -13616,10 +13986,6 @@ snapshots:
     dependencies:
       ansi-regex: 5.0.1
 
-  strip-ansi@7.1.2:
-    dependencies:
-      ansi-regex: 6.2.2
-
   strip-ansi@7.2.0:
     dependencies:
       ansi-regex: 6.2.2
@@ -13638,53 +14004,52 @@ snapshots:
 
   strnum@1.1.2: {}
 
-  strnum@2.2.3: {}
+  strnum@2.3.0: {}
 
   style-mod@4.1.3: {}
 
-  stylelint-config-recommended@18.0.0(stylelint@17.6.0(typescript@6.0.2)):
+  stylelint-config-recommended@18.0.0(stylelint@17.12.0(typescript@6.0.3)):
     dependencies:
-      stylelint: 17.6.0(typescript@6.0.2)
+      stylelint: 17.12.0(typescript@6.0.3)
 
-  stylelint-config-tailwindcss@1.0.1(stylelint@17.6.0(typescript@6.0.2))(tailwindcss@4.2.2):
+  stylelint-config-tailwindcss@1.0.1(stylelint@17.12.0(typescript@6.0.3))(tailwindcss@4.3.0):
     dependencies:
-      stylelint: 17.6.0(typescript@6.0.2)
-      tailwindcss: 4.2.2
+      stylelint: 17.12.0(typescript@6.0.3)
+      tailwindcss: 4.3.0
 
-  stylelint@17.6.0(typescript@6.0.2):
+  stylelint@17.12.0(typescript@6.0.3):
     dependencies:
-      '@csstools/css-calc': 3.1.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-calc': 3.2.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
       '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
-      '@csstools/css-syntax-patches-for-csstree': 1.1.2(css-tree@3.2.1)
+      '@csstools/css-syntax-patches-for-csstree': 1.1.4(css-tree@3.2.1)
       '@csstools/css-tokenizer': 4.0.0
       '@csstools/media-query-list-parser': 5.0.0(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
       '@csstools/selector-resolve-nested': 4.0.0(postcss-selector-parser@7.1.1)
       '@csstools/selector-specificity': 6.0.0(postcss-selector-parser@7.1.1)
       colord: 2.9.3
-      cosmiconfig: 9.0.1(typescript@6.0.2)
+      cosmiconfig: 9.0.1(typescript@6.0.3)
       css-functions-list: 3.3.3
       css-tree: 3.2.1
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
       fast-glob: 3.3.3
       fastest-levenshtein: 1.0.16
-      file-entry-cache: 11.1.2
+      file-entry-cache: 11.1.3
       global-modules: 2.0.0
       globby: 16.2.0
       globjoin: 0.1.4
       html-tags: 5.1.0
       ignore: 7.0.5
       import-meta-resolve: 4.2.0
-      is-plain-object: 5.0.0
       mathml-tag-names: 4.0.0
       meow: 14.1.0
       micromatch: 4.0.8
       normalize-path: 3.0.0
       picocolors: 1.1.1
-      postcss: 8.5.9
-      postcss-safe-parser: 7.0.1(postcss@8.5.9)
+      postcss: 8.5.15
+      postcss-safe-parser: 7.0.1(postcss@8.5.15)
       postcss-selector-parser: 7.1.1
       postcss-value-parser: 4.2.0
-      string-width: 8.2.0
+      string-width: 8.2.1
       supports-hyperlinks: 4.4.0
       svg-tags: 1.0.0
       table: 6.9.0
@@ -13693,6 +14058,16 @@ snapshots:
       - supports-color
       - typescript
 
+  sucrase@3.35.1:
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      commander: 4.1.1
+      lines-and-columns: 1.2.4
+      mz: 2.7.0
+      pirates: 4.0.7
+      tinyglobby: 0.2.17
+      ts-interface-checker: 0.1.13
+
   supports-color@10.2.2: {}
 
   supports-color@5.5.0:
@@ -13718,27 +14093,29 @@ snapshots:
 
   symbol-tree@3.2.4: {}
 
-  synckit@0.11.12:
+  synckit@0.11.13:
     dependencies:
-      '@pkgr/core': 0.2.9
+      '@pkgr/core': 0.3.6
 
   table@6.9.0:
     dependencies:
-      ajv: 8.18.0
+      ajv: 8.20.0
       lodash.truncate: 4.4.2
       slice-ansi: 4.0.0
       string-width: 4.2.3
       strip-ansi: 6.0.1
 
-  tailwindcss@4.2.2: {}
+  tagged-tag@1.0.0: {}
+
+  tailwindcss@4.3.0: {}
 
-  tapable@2.3.2: {}
+  tapable@2.3.3: {}
 
   tar-fs@3.0.4:
     dependencies:
       mkdirp-classic: 0.5.3
       pump: 3.0.4
-      tar-stream: 3.1.8
+      tar-stream: 3.2.0
     transitivePeerDependencies:
       - bare-abort-controller
       - bare-buffer
@@ -13747,10 +14124,10 @@ snapshots:
   tar-fs@3.1.2:
     dependencies:
       pump: 3.0.4
-      tar-stream: 3.1.8
+      tar-stream: 3.2.0
     optionalDependencies:
-      bare-fs: 4.6.0
-      bare-path: 3.0.0
+      bare-fs: 4.7.2
+      bare-path: 3.0.1
     transitivePeerDependencies:
       - bare-abort-controller
       - bare-buffer
@@ -13764,12 +14141,12 @@ snapshots:
       inherits: 2.0.4
       readable-stream: 3.6.2
 
-  tar-stream@3.1.8:
+  tar-stream@3.2.0:
     dependencies:
-      b4a: 1.8.0
-      bare-fs: 4.6.0
+      b4a: 1.8.1
+      bare-fs: 4.7.2
       fast-fifo: 1.3.2
-      streamx: 2.25.0
+      streamx: 2.26.0
     transitivePeerDependencies:
       - bare-abort-controller
       - bare-buffer
@@ -13784,7 +14161,7 @@ snapshots:
 
   teex@1.0.1:
     dependencies:
-      streamx: 2.25.0
+      streamx: 2.26.0
     transitivePeerDependencies:
       - bare-abort-controller
       - react-native-b4a
@@ -13797,7 +14174,7 @@ snapshots:
 
   text-decoder@1.2.7:
     dependencies:
-      b4a: 1.8.0
+      b4a: 1.8.1
     transitivePeerDependencies:
       - react-native-b4a
 
@@ -13809,9 +14186,9 @@ snapshots:
     dependencies:
       any-promise: 1.3.0
 
-  thread-stream@4.0.0:
+  thread-stream@4.2.0:
     dependencies:
-      real-require: 0.2.0
+      real-require: 1.0.0
 
   through@2.3.8: {}
 
@@ -13821,30 +14198,28 @@ snapshots:
 
   tinyexec@0.3.2: {}
 
-  tinyexec@1.1.1: {}
+  tinyexec@1.2.4: {}
 
-  tinyglobby@0.2.16:
+  tinyglobby@0.2.17:
     dependencies:
       fdir: 6.5.0(picomatch@4.0.4)
       picomatch: 4.0.4
 
-  tinypool@1.1.1: {}
-
   tinyrainbow@1.2.0: {}
 
   tinyrainbow@3.1.0: {}
 
-  tinyspy@3.0.2: {}
-
   tmp@0.2.3: {}
 
+  tmp@0.2.7: {}
+
   tmpl@1.0.5: {}
 
   to-regex-range@5.0.1:
     dependencies:
       is-number: 7.0.0
 
-  toad-cache@3.7.0: {}
+  toad-cache@3.7.1: {}
 
   toidentifier@1.0.1: {}
 
@@ -13871,25 +14246,27 @@ snapshots:
 
   tree-kill@1.2.2: {}
 
-  ts-api-utils@2.5.0(typescript@6.0.2):
+  ts-api-utils@2.5.0(typescript@6.0.3):
     dependencies:
-      typescript: 6.0.2
+      typescript: 6.0.3
 
-  ts-node@10.9.2(@types/node@25.5.2)(typescript@6.0.2):
+  ts-interface-checker@0.1.13: {}
+
+  ts-node@10.9.2(@types/node@25.9.1)(typescript@6.0.3):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
-      '@tsconfig/node10': 1.0.11
+      '@tsconfig/node10': 1.0.12
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.4
-      '@types/node': 25.5.2
-      acorn: 8.15.0
-      acorn-walk: 8.3.4
+      '@types/node': 25.9.1
+      acorn: 8.16.0
+      acorn-walk: 8.3.5
       arg: 4.1.3
       create-require: 1.1.1
-      diff: 4.0.2
+      diff: 4.0.4
       make-error: 1.3.6
-      typescript: 6.0.2
+      typescript: 6.0.3
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
 
@@ -13908,10 +14285,38 @@ snapshots:
 
   tslib@2.8.1: {}
 
-  tsx@4.21.0:
+  tsup@8.5.1(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(typescript@6.0.3)(yaml@2.9.0):
     dependencies:
+      bundle-require: 5.1.0(esbuild@0.27.7)
+      cac: 6.7.14
+      chokidar: 4.0.3
+      consola: 3.4.2
+      debug: 4.4.3(supports-color@5.5.0)
       esbuild: 0.27.7
-      get-tsconfig: 4.13.7
+      fix-dts-default-cjs-exports: 1.0.1
+      joycon: 3.1.1
+      picocolors: 1.1.1
+      postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.15)(tsx@4.22.4)(yaml@2.9.0)
+      resolve-from: 5.0.0
+      rollup: 4.61.0
+      source-map: 0.7.6
+      sucrase: 3.35.1
+      tinyexec: 0.3.2
+      tinyglobby: 0.2.17
+      tree-kill: 1.2.2
+    optionalDependencies:
+      '@microsoft/api-extractor': 7.58.7(@types/node@25.9.1)
+      postcss: 8.5.15
+      typescript: 6.0.3
+    transitivePeerDependencies:
+      - jiti
+      - supports-color
+      - tsx
+      - yaml
+
+  tsx@4.22.4:
+    dependencies:
+      esbuild: 0.28.0
     optionalDependencies:
       fsevents: 2.3.3
 
@@ -13939,6 +14344,10 @@ snapshots:
 
   type-fest@4.41.0: {}
 
+  type-fest@5.7.0:
+    dependencies:
+      tagged-tag: 1.0.0
+
   typed-array-buffer@1.0.3:
     dependencies:
       call-bound: 1.0.4
@@ -13947,7 +14356,7 @@ snapshots:
 
   typed-array-byte-length@1.0.3:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       for-each: 0.3.5
       gopd: 1.2.0
       has-proto: 1.2.0
@@ -13956,29 +14365,30 @@ snapshots:
   typed-array-byte-offset@1.0.4:
     dependencies:
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       for-each: 0.3.5
       gopd: 1.2.0
       has-proto: 1.2.0
       is-typed-array: 1.1.15
       reflect.getprototypeof: 1.0.10
 
-  typed-array-length@1.0.7:
+  typed-array-length@1.0.8:
     dependencies:
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       for-each: 0.3.5
       gopd: 1.2.0
       is-typed-array: 1.1.15
       possible-typed-array-names: 1.1.0
       reflect.getprototypeof: 1.0.10
 
-  typescript@5.8.2: {}
+  typescript@5.9.3:
+    optional: true
 
-  typescript@6.0.2: {}
+  typescript@6.0.3: {}
 
   ua-parser-js@1.0.41: {}
 
-  ufo@1.6.1: {}
+  ufo@1.6.4: {}
 
   unbox-primitive@1.1.0:
     dependencies:
@@ -13994,13 +14404,11 @@ snapshots:
 
   undefsafe@2.0.5: {}
 
-  undici-types@7.18.2: {}
+  undici-types@7.24.6: {}
 
-  undici@6.24.1: {}
+  undici@6.26.0: {}
 
-  undici@7.24.7: {}
-
-  unicorn-magic@0.1.0: {}
+  undici@7.27.0: {}
 
   unicorn-magic@0.3.0: {}
 
@@ -14008,23 +14416,71 @@ snapshots:
 
   universalify@0.2.0: {}
 
-  universalify@2.0.1: {}
+  universalify@2.0.1:
+    optional: true
+
+  unplugin-dts@1.0.2(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(esbuild@0.28.0)(rolldown@1.0.3)(rollup@4.61.0)(typescript@6.0.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)):
+    dependencies:
+      '@rollup/pluginutils': 5.4.0(rollup@4.61.0)
+      '@volar/typescript': 2.4.28
+      compare-versions: 6.1.1
+      debug: 4.4.3(supports-color@5.5.0)
+      kolorist: 1.8.0
+      local-pkg: 1.2.1
+      magic-string: 0.30.21
+      typescript: 6.0.3
+      unplugin: 2.3.11
+    optionalDependencies:
+      '@microsoft/api-extractor': 7.58.7(@types/node@25.9.1)
+      esbuild: 0.28.0
+      rolldown: 1.0.3
+      rollup: 4.61.0
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
+    transitivePeerDependencies:
+      - supports-color
 
   unplugin-icons@23.0.1:
     dependencies:
       '@antfu/install-pkg': 1.1.0
-      '@iconify/utils': 3.1.0
-      local-pkg: 1.1.2
+      '@iconify/utils': 3.1.3
+      local-pkg: 1.2.1
       obug: 2.1.1
       unplugin: 2.3.11
 
   unplugin@2.3.11:
     dependencies:
       '@jridgewell/remapping': 2.3.5
-      acorn: 8.15.0
+      acorn: 8.16.0
       picomatch: 4.0.4
       webpack-virtual-modules: 0.6.2
 
+  unrs-resolver@1.12.2:
+    dependencies:
+      napi-postinstall: 0.3.4
+    optionalDependencies:
+      '@unrs/resolver-binding-android-arm-eabi': 1.12.2
+      '@unrs/resolver-binding-android-arm64': 1.12.2
+      '@unrs/resolver-binding-darwin-arm64': 1.12.2
+      '@unrs/resolver-binding-darwin-x64': 1.12.2
+      '@unrs/resolver-binding-freebsd-x64': 1.12.2
+      '@unrs/resolver-binding-linux-arm-gnueabihf': 1.12.2
+      '@unrs/resolver-binding-linux-arm-musleabihf': 1.12.2
+      '@unrs/resolver-binding-linux-arm64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-arm64-musl': 1.12.2
+      '@unrs/resolver-binding-linux-loong64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-loong64-musl': 1.12.2
+      '@unrs/resolver-binding-linux-ppc64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-riscv64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-riscv64-musl': 1.12.2
+      '@unrs/resolver-binding-linux-s390x-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-x64-gnu': 1.12.2
+      '@unrs/resolver-binding-linux-x64-musl': 1.12.2
+      '@unrs/resolver-binding-openharmony-arm64': 1.12.2
+      '@unrs/resolver-binding-wasm32-wasi': 1.12.2
+      '@unrs/resolver-binding-win32-arm64-msvc': 1.12.2
+      '@unrs/resolver-binding-win32-ia32-msvc': 1.12.2
+      '@unrs/resolver-binding-win32-x64-msvc': 1.12.2
+
   untildify@4.0.0: {}
 
   unzipper@0.10.14:
@@ -14040,12 +14496,6 @@ snapshots:
       readable-stream: 2.3.8
       setimmediate: 1.0.5
 
-  update-browserslist-db@1.1.4(browserslist@4.27.0):
-    dependencies:
-      browserslist: 4.27.0
-      escalade: 3.2.0
-      picocolors: 1.1.1
-
   update-browserslist-db@1.2.3(browserslist@4.28.2):
     dependencies:
       browserslist: 4.28.2
@@ -14077,8 +14527,6 @@ snapshots:
 
   uuid@10.0.0: {}
 
-  uuid@11.0.5: {}
-
   uuid@8.3.2: {}
 
   uuid@9.0.1: {}
@@ -14096,135 +14544,70 @@ snapshots:
       spdx-correct: 3.2.0
       spdx-expression-parse: 3.0.1
 
-  vite-node@2.1.9(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3):
-    dependencies:
-      cac: 6.7.14
-      debug: 4.4.3
-      es-module-lexer: 1.7.0
-      pathe: 1.1.2
-      vite: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
-    transitivePeerDependencies:
-      - '@types/node'
-      - '@vitejs/devtools'
-      - esbuild
-      - jiti
-      - less
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vite-plugin-dts@4.5.4(@types/node@25.5.2)(rollup@4.60.1)(typescript@6.0.2)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)):
+  vite-plugin-dts@5.0.2(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(esbuild@0.28.0)(rolldown@1.0.3)(rollup@4.61.0)(typescript@6.0.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)):
     dependencies:
-      '@microsoft/api-extractor': 7.53.3(@types/node@25.5.2)
-      '@rollup/pluginutils': 5.3.0(rollup@4.60.1)
-      '@volar/typescript': 2.4.23
-      '@vue/language-core': 2.2.0(typescript@6.0.2)
-      compare-versions: 6.1.1
-      debug: 4.4.3
-      kolorist: 1.8.0
-      local-pkg: 1.1.2
-      magic-string: 0.30.21
-      typescript: 6.0.2
+      unplugin-dts: 1.0.2(@microsoft/api-extractor@7.58.7(@types/node@25.9.1))(esbuild@0.28.0)(rolldown@1.0.3)(rollup@4.61.0)(typescript@6.0.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
     optionalDependencies:
-      vite: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+      '@microsoft/api-extractor': 7.58.7(@types/node@25.9.1)
+      rollup: 4.61.0
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
     transitivePeerDependencies:
-      - '@types/node'
-      - rollup
+      - '@rspack/core'
+      - '@vue/language-core'
+      - esbuild
+      - rolldown
       - supports-color
+      - typescript
+      - webpack
 
-  vite-plugin-singlefile@2.3.2(rollup@4.60.1)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)):
+  vite-plugin-singlefile@2.3.3(rollup@4.61.0)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)):
     dependencies:
       micromatch: 4.0.8
-      rollup: 4.60.1
-      vite: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
+    optionalDependencies:
+      rollup: 4.61.0
 
-  vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3):
+  vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0):
     dependencies:
       lightningcss: 1.32.0
       picomatch: 4.0.4
-      postcss: 8.5.9
-      rolldown: 1.0.0-rc.13
-      tinyglobby: 0.2.16
+      postcss: 8.5.15
+      rolldown: 1.0.3
+      tinyglobby: 0.2.17
     optionalDependencies:
-      '@types/node': 25.5.2
-      esbuild: 0.27.7
+      '@types/node': 25.9.1
+      esbuild: 0.28.0
       fsevents: 2.3.3
-      jiti: 2.6.1
-      tsx: 4.21.0
-      yaml: 2.8.3
-
-  vitest@2.1.9(@types/node@25.5.2)(@vitest/browser@4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))))(esbuild@0.27.7)(happy-dom@20.8.9)(jiti@2.6.1)(jsdom@24.1.3)(tsx@4.21.0)(yaml@2.8.3):
-    dependencies:
-      '@vitest/expect': 2.1.9
-      '@vitest/mocker': 2.1.9(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
-      '@vitest/pretty-format': 2.1.9
-      '@vitest/runner': 2.1.9
-      '@vitest/snapshot': 2.1.9
-      '@vitest/spy': 2.1.9
-      '@vitest/utils': 2.1.9
-      chai: 5.3.3
-      debug: 4.4.3
-      expect-type: 1.3.0
-      magic-string: 0.30.21
-      pathe: 1.1.2
-      std-env: 3.10.0
-      tinybench: 2.9.0
-      tinyexec: 0.3.2
-      tinypool: 1.1.1
-      tinyrainbow: 1.2.0
-      vite: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
-      vite-node: 2.1.9(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
-      why-is-node-running: 2.3.0
-    optionalDependencies:
-      '@types/node': 25.5.2
-      '@vitest/browser': 4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)))
-      happy-dom: 20.8.9
-      jsdom: 24.1.3
-    transitivePeerDependencies:
-      - '@vitejs/devtools'
-      - esbuild
-      - jiti
-      - less
-      - msw
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vitest@4.1.3(@types/node@25.5.2)(happy-dom@20.8.9)(jsdom@24.1.3)(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)):
-    dependencies:
-      '@vitest/expect': 4.1.3
-      '@vitest/mocker': 4.1.3(vite@8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3))
-      '@vitest/pretty-format': 4.1.3
-      '@vitest/runner': 4.1.3
-      '@vitest/snapshot': 4.1.3
-      '@vitest/spy': 4.1.3
-      '@vitest/utils': 4.1.3
-      es-module-lexer: 2.0.0
+      jiti: 2.7.0
+      tsx: 4.22.4
+      yaml: 2.9.0
+
+  vitest@4.1.8(@types/node@25.9.1)(@vitest/coverage-v8@4.1.8)(happy-dom@20.9.0)(jsdom@24.1.3)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)):
+    dependencies:
+      '@vitest/expect': 4.1.8
+      '@vitest/mocker': 4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+      '@vitest/pretty-format': 4.1.8
+      '@vitest/runner': 4.1.8
+      '@vitest/snapshot': 4.1.8
+      '@vitest/spy': 4.1.8
+      '@vitest/utils': 4.1.8
+      es-module-lexer: 2.1.0
       expect-type: 1.3.0
       magic-string: 0.30.21
       obug: 2.1.1
       pathe: 2.0.3
       picomatch: 4.0.4
-      std-env: 4.0.0
+      std-env: 4.1.0
       tinybench: 2.9.0
-      tinyexec: 1.1.1
-      tinyglobby: 0.2.16
+      tinyexec: 1.2.4
+      tinyglobby: 0.2.17
       tinyrainbow: 3.1.0
-      vite: 8.0.7(@types/node@25.5.2)(esbuild@0.27.7)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.8.3)
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
       why-is-node-running: 2.3.0
     optionalDependencies:
-      '@types/node': 25.5.2
-      happy-dom: 20.8.9
+      '@types/node': 25.9.1
+      '@vitest/coverage-v8': 4.1.8(@vitest/browser@4.1.8)(vitest@4.1.8)
+      happy-dom: 20.9.0
       jsdom: 24.1.3
     transitivePeerDependencies:
       - msw
@@ -14241,7 +14624,7 @@ snapshots:
     dependencies:
       chalk: 4.1.2
       commander: 9.5.0
-      debug: 4.4.3
+      debug: 4.4.3(supports-color@5.5.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -14255,19 +14638,19 @@ snapshots:
 
   web-streams-polyfill@3.3.3: {}
 
-  webdriver@9.27.0:
+  webdriver@9.27.2:
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@types/ws': 8.18.1
-      '@wdio/config': 9.27.0
+      '@wdio/config': 9.27.2
       '@wdio/logger': 9.18.0
-      '@wdio/protocols': 9.27.0
-      '@wdio/types': 9.27.0
-      '@wdio/utils': 9.27.0
+      '@wdio/protocols': 9.27.2
+      '@wdio/types': 9.27.2
+      '@wdio/utils': 9.27.2
       deepmerge-ts: 7.1.5
       https-proxy-agent: 7.0.6
-      undici: 6.24.1
-      ws: 8.20.0
+      undici: 6.26.0
+      ws: 8.21.0
     transitivePeerDependencies:
       - bare-abort-controller
       - bare-buffer
@@ -14276,16 +14659,16 @@ snapshots:
       - supports-color
       - utf-8-validate
 
-  webdriverio@9.27.0(puppeteer-core@21.11.0):
+  webdriverio@9.27.2(puppeteer-core@21.11.0):
     dependencies:
-      '@types/node': 25.5.2
+      '@types/node': 25.9.1
       '@types/sinonjs__fake-timers': 8.1.5
-      '@wdio/config': 9.27.0
+      '@wdio/config': 9.27.2
       '@wdio/logger': 9.18.0
-      '@wdio/protocols': 9.27.0
+      '@wdio/protocols': 9.27.2
       '@wdio/repl': 9.16.2
-      '@wdio/types': 9.27.0
-      '@wdio/utils': 9.27.0
+      '@wdio/types': 9.27.2
+      '@wdio/utils': 9.27.2
       archiver: 7.0.1
       aria-query: 5.3.2
       cheerio: 1.2.0
@@ -14302,7 +14685,7 @@ snapshots:
       rgb2hex: 0.2.5
       serialize-error: 12.0.0
       urlpattern-polyfill: 10.1.0
-      webdriver: 9.27.0
+      webdriver: 9.27.2
     optionalDependencies:
       puppeteer-core: 21.11.0
     transitivePeerDependencies:
@@ -14359,7 +14742,7 @@ snapshots:
       isarray: 2.0.5
       which-boxed-primitive: 1.1.1
       which-collection: 1.0.2
-      which-typed-array: 1.1.19
+      which-typed-array: 1.1.21
 
   which-collection@1.0.2:
     dependencies:
@@ -14368,10 +14751,10 @@ snapshots:
       is-weakmap: 2.0.2
       is-weakset: 2.0.4
 
-  which-typed-array@1.1.19:
+  which-typed-array@1.1.21:
     dependencies:
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
+      call-bind: 1.0.9
       call-bound: 1.0.4
       for-each: 0.3.5
       get-proto: 1.0.1
@@ -14388,7 +14771,7 @@ snapshots:
 
   which@4.0.0:
     dependencies:
-      isexe: 3.1.1
+      isexe: 3.1.5
 
   which@6.0.1:
     dependencies:
@@ -14407,6 +14790,8 @@ snapshots:
 
   workerpool@6.5.1: {}
 
+  workerpool@9.3.4: {}
+
   wrap-ansi@6.2.0:
     dependencies:
       ansi-styles: 4.3.0
@@ -14427,10 +14812,10 @@ snapshots:
 
   wrappy@1.0.2: {}
 
-  write-file-atomic@4.0.2:
+  write-file-atomic@5.0.1:
     dependencies:
       imurmurhash: 0.1.4
-      signal-exit: 3.0.7
+      signal-exit: 4.1.0
 
   write-file-atomic@7.0.1:
     dependencies:
@@ -14438,10 +14823,12 @@ snapshots:
 
   ws@8.16.0: {}
 
-  ws@8.20.0: {}
+  ws@8.21.0: {}
 
   xml-name-validator@5.0.0: {}
 
+  xml-naming@0.1.0: {}
+
   xmlbuilder@15.1.1: {}
 
   xmlchars@2.2.0: {}
@@ -14452,7 +14839,7 @@ snapshots:
 
   yallist@4.0.0: {}
 
-  yaml@2.8.3: {}
+  yaml@2.9.0: {}
 
   yargs-parser@20.2.9: {}
 
@@ -14507,7 +14894,7 @@ snapshots:
       toposort: 2.0.2
       type-fest: 2.19.0
 
-  yup@1.6.1:
+  yup@1.7.1:
     dependencies:
       property-expr: 2.0.6
       tiny-case: 1.0.3
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index da8b8f2c..c577713a 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,9 +1,13 @@
 # pnpm-workspace.yaml
 packages:
+  - 'packages/shared'
+  - 'packages/core'
   - 'packages/backend'
   - 'packages/script'
   - 'packages/service'
   - 'packages/app'
   - 'packages/nightwatch-devtools'
   - 'packages/selenium-devtools'
-  - 'example'
+  - 'examples/wdio'
+  - 'examples/selenium'
+  - 'examples/nightwatch'
diff --git a/tsconfig.json b/tsconfig.json
index 17fb23b7..97c599d0 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -25,6 +25,10 @@
       "@components/*": ["packages/app/src/components/*"],
       "@core/*": ["packages/app/src/core/*"],
 
+      "@wdio/devtools-shared": ["packages/shared/src/index.ts"],
+      "@wdio/devtools-shared/*": ["packages/shared/src/*"],
+      "@wdio/devtools-core": ["packages/core/src/index.ts"],
+      "@wdio/devtools-core/*": ["packages/core/src/*"],
       "@wdio/devtools-backend": ["packages/backend/src/index.ts"],
       "@wdio/devtools-backend/*": ["packages/backend/src/*"],
       "@wdio/devtools-script": ["packages/script/src/index.ts"],