diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 05b5f35..ff084c9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -312,9 +312,9 @@ jobs:
       - name: e2e
         run: |
           if [ "$ZIPX_VERIFY_CLEAN_FULL" = "true" ]; then
-            sbt 'cleanFull; e2e/chekhovInstall; e2e/Test/testFull'
+            sbt 'cleanFull; e2e/chekhovInstall; e2e/Test/testFull; ascentChekhovJS/Test/testFull'
           else
-            sbt 'e2e/chekhovInstall; e2e/Test/testFull'
+            sbt 'e2e/chekhovInstall; e2e/Test/testFull; ascentChekhovJS/Test/testFull'
           fi
         env:
           ZIPX_VERIFY_CLEAN_FULL: ${{ github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'clean') }}
@@ -353,7 +353,7 @@ jobs:
         env:
           PGP_SECRET: ${{ secrets.PGP_SECRET }}
       - name: publish
-        run: sbt 'domTypes/publishSigned; domTypesJS/publishSigned; domTypesNative/publishSigned; preview/publishSigned; sbtAscentPreview/publishSigned; core/publishSigned; coreJS/publishSigned; coreNative/publishSigned; domFacadeJS/publishSigned; conduitBridge/publishSigned; conduitBridgeJS/publishSigned; conduitBridgeNative/publishSigned; css/publishSigned; cssJS/publishSigned; cssNative/publishSigned; datastar/publishSigned; datastarJS/publishSigned; datastarNative/publishSigned; domCore/publishSigned; domCoreJS/publishSigned; domCoreNative/publishSigned; mountEngine/publishSigned; mountEngineJS/publishSigned; mountEngineNative/publishSigned; html/publishSigned; htmlJS/publishSigned; htmlNative/publishSigned; jsJS/publishSigned; datastarHttp/publishSigned; datastarJsJS/publishSigned; sonaRelease'
+        run: sbt 'domTypes/publishSigned; domTypesJS/publishSigned; domTypesNative/publishSigned; preview/publishSigned; sbtAscentPreview/publishSigned; core/publishSigned; coreJS/publishSigned; coreNative/publishSigned; domFacadeJS/publishSigned; ascentChekhov/publishSigned; conduitBridge/publishSigned; conduitBridgeJS/publishSigned; conduitBridgeNative/publishSigned; css/publishSigned; cssJS/publishSigned; cssNative/publishSigned; datastar/publishSigned; datastarJS/publishSigned; datastarNative/publishSigned; domCore/publishSigned; domCoreJS/publishSigned; domCoreNative/publishSigned; mountEngine/publishSigned; mountEngineJS/publishSigned; mountEngineNative/publishSigned; html/publishSigned; htmlJS/publishSigned; htmlNative/publishSigned; jsJS/publishSigned; ascentChekhovJS/publishSigned; datastarHttp/publishSigned; datastarJsJS/publishSigned; sonaRelease'
   docs:
     name: docs
     if: (startsWith(github.ref, 'refs/tags/v')) || (github.event_name == 'workflow_dispatch')
diff --git a/README.md b/README.md
index 5296f61..86c51b0 100644
--- a/README.md
+++ b/README.md
@@ -240,9 +240,32 @@ toggling one item doesn't rebuild the others — that's the surgical patching.
 sbt testJVM                    # JVM suites (use testFull per module on sbt 2)
 sbt todoConduitJS/ascentPreviewStage # splice + stage the example without a browser
 sbt e2e/chekhovInstall && sbt e2e/testFull   # Firefox suites against splice+preview
+sbt "e2e/chekhovInstall; ascentChekhovJS/testFull"  # JSEnv typed handles (ascent-chekhov)
 ./scripts/install-git-hooks    # once per clone: pre-commit runs scalafmtCheckAll
 ```
 
+Component tests (JSEnv) mount a `UI` and talk to nodes as `InputHandle` / `ButtonHandle`:
+
+```scala
+import ascent.*, ascent.dsl.*, ascent.chekhov.AscentChekhov.withMounted
+
+withMounted(ui) { root =>
+  root.button("inc").click *>
+    root.getByTestId("count").innerText.map(t => assertTrue(t == "1"))
+}
+```
+
+JVM `ChekhovSuite` uses the same lattice as tagged Playwright selectors (`HtmlTag.input` keeps `fill` off a button). Chekhov's `Page.getByPlaceholder(text)` already exists, so the typed call is on `PageHandles` (not an overloaded `page.getByPlaceholder`):
+
+```scala
+import ascent.HtmlTag
+import ascent.chekhov.PageHandles
+
+PageHandles.getByPlaceholder(page, "Your name", HtmlTag.input).fill("Ada")
+PageHandles.getByTestId(page, "inc", HtmlTag.button).click
+page.button("inc").click
+```
+
 ascent is built with Scala 3 and cross-compiled to **JVM, Scala.js, and Scala Native** via
 `sbt-projectmatrix`. The module layout:
 
@@ -259,6 +282,7 @@ ascent is built with Scala 3 and cross-compiled to **JVM, Scala.js, and Scala Na
 | `datastar-js`   | Browser datastar runtime: SSE → Squawk / DOM, action dispatch ([readme](datastar-js/README.md)) |
 | `datastar-http` | Server wrapper over `zio-http-datastar-sdk` ([readme](datastar-http/README.md)) |
 | `preview`       | Static file server + SSE reload (`ascent-preview`) ([readme](preview/README.md)) |
+| `chekhov`       | Typed Chekhov locators (`ascent-chekhov`): JSEnv live handles + JVM `Page` selectors |
 | `sbt-ascent-preview` | `enablePlugins(AscentPreviewPlugin)` then `sbt ~<module>/ascentPreview` |
 | `domgen`        | JVM-only generator that emits the typed catalogs from W3C webref ([readme](domgen/README.md)) |
 | `example/*`     | One self-contained splice+preview app per subdir (e.g. `todo-conduit`)        |
diff --git a/build.sbt b/build.sbt
index d8969b5..a216eba 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1,6 +1,8 @@
 import ascent.preview.sbt.AscentPreviewPlugin
 import ascent.preview.sbt.AscentPreviewPlugin.autoImport.*
 import ascent.preview.sbt.AscentPreviewPort
+import chekhov.ChekhovBrowser
+import chekhov.jsenv.ChekhovJSEnv
 
 MyVersions.settings
 
@@ -117,6 +119,7 @@ val ascentModules = Seq(
   "ascent-datastar",
   "ascent-datastar-http",
   "ascent-preview",
+  "ascent-chekhov",
 )
 
 /** Published Specular jars depend on the Maven Central `ascent-*` release, but the docs modules `dependsOn` local
@@ -147,7 +150,8 @@ lazy val root = (project in file("."))
       html.projectRefs ++ datastar.projectRefs ++ datastarJs.projectRefs ++
       datastarHttp.projectRefs ++ datastarExample.projectRefs ++ datastarExampleServer.projectRefs ++
       hybridChat.projectRefs ++ hybridChatServer.projectRefs ++
-      todoConduit.projectRefs ++ docs.projectRefs ++ preview.projectRefs :+
+      todoConduit.projectRefs ++ docs.projectRefs ++ preview.projectRefs ++
+      ascentChekhov.projectRefs :+
       LocalProject("sbtAscentPreview")) *
   )
   .settings(
@@ -625,18 +629,55 @@ def ascentPlatformTestCommand(find: ProjectMatrix => ProjectFinder): String =
     .sorted
     .mkString("; ")
 
-addCommandAlias("testJVM", ascentPlatformTestCommand(_.jvm))
+// ascentChekhov is not in ascentMatrices: its JS row is ChekhovJSEnv (not jsdom) and must
+// stay off testJS. The JVM row is browser-free selector tests and joins testJVM here.
+addCommandAlias("testJVM", ascentPlatformTestCommand(_.jvm) + "; ascentChekhov/test")
 addCommandAlias("testJS", ascentPlatformTestCommand(_.js))
 addCommandAlias("testNative", ascentPlatformTestCommand(_.native))
 
 lazy val e2eStage = taskKey[Unit]("Stage example preview trees for Chekhov e2e")
 
 // Browser suites. Not aggregated so library `testFull` stays browser-free.
+// --- ascent-chekhov : typed Chekhov locators over the HTML lattice (jvm + js). ---
+//   Shared sources are the TagHandle typeclass + handle algebra (no live DOM, no Chekhov
+//   imports). The JVM row interprets handles as Playwright selector strings via chekhov-core.
+//   The JS row mounts a UI into chekhov-dom's iframe withRoot and talks to live ascent.dom
+//   nodes. Not in ascentMatrices: JS tests need ChekhovJSEnv (see testJVM / e2e capability).
+lazy val ascentChekhov = (projectMatrix in file("chekhov"))
+  .disablePlugins(chekhov.sbt.ChekhovPlugin)
+  .dependsOn(core)
+  .settings(
+    name := "ascent-chekhov",
+    scalacOptions ++= commonScalacOptions,
+    zioTestSettings,
+  )
+  .jvmPlatform(
+    scalaVersions,
+    Nil,
+    (p: Project) => p.settings(MyVersions.chekhovCoreLib),
+  )
+  .jsPlatform(
+    scalaVersions,
+    Nil,
+    (p: Project) =>
+      p.dependsOn(js.js(scala3Version))
+        .settings(
+          MyVersions.chekhovDomLib,
+          scalaJSLinkerConfig ~= (_.withModuleKind(ModuleKind.ESModule)),
+          // Do not enable ChekhovPlugin here: it sets Test / fork := true, which is a JVM
+          // suite setting. JSEnv is constructed directly (same Firefox pin as e2e).
+          Test / jsEnv := Def.uncached(
+            ChekhovJSEnv(browser = ChekhovBrowser.Firefox, headless = true, keepOpen = false)
+          ),
+        ),
+  )
+
 lazy val e2e = (project in file("e2e"))
   .dependsOn(
     preview.jvm(scala3Version),
     datastarExampleServer.jvm(scala3Version),
     hybridChatServer.jvm(scala3Version),
+    ascentChekhov.jvm(scala3Version),
   )
   .settings(
     name           := "ascent-e2e",
diff --git a/chekhov/src/main/scala/ascent/chekhov/HandleBackend.scala b/chekhov/src/main/scala/ascent/chekhov/HandleBackend.scala
new file mode 100644
index 0000000..d2fc644
--- /dev/null
+++ b/chekhov/src/main/scala/ascent/chekhov/HandleBackend.scala
@@ -0,0 +1,14 @@
+package ascent.chekhov
+
+import zio.Trace
+
+/** Effectful DOM verbs a handle needs. Shared by the JS live-node backend and the JVM Playwright selector backend.
+  * Implementations must not appear in this file (no Chekhov, no `ascent.dom`).
+  */
+trait HandleBackend[F[_]]:
+  def click(selector: String)(using Trace): F[Unit]
+  def fill(selector: String, value: String)(using Trace): F[Unit]
+  def press(selector: String, key: String)(using Trace): F[Unit]
+  def innerText(selector: String)(using Trace): F[String]
+  def textContent(selector: String)(using Trace): F[String]
+end HandleBackend
diff --git a/chekhov/src/main/scala/ascent/chekhov/Handles.scala b/chekhov/src/main/scala/ascent/chekhov/Handles.scala
new file mode 100644
index 0000000..c2ed233
--- /dev/null
+++ b/chekhov/src/main/scala/ascent/chekhov/Handles.scala
@@ -0,0 +1,25 @@
+package ascent.chekhov
+
+import zio.Trace
+
+/** Untyped element. `fill` is deliberately absent: a button or span must not compile a fill. */
+class ElementHandle[F[_]](val selector: String, val backend: HandleBackend[F]):
+  def click(using Trace): F[Unit]              = backend.click(selector)
+  def press(key: String)(using Trace): F[Unit] = backend.press(selector, key)
+  def innerText(using Trace): F[String]        = backend.innerText(selector)
+  def textContent(using Trace): F[String]      = backend.textContent(selector)
+
+/** `<input>` — the only shared extra verb is [[fill]]. Live `value` / `checked` live on the JS row. */
+final class InputHandle[F[_]](selector: String, backend: HandleBackend[F]) extends ElementHandle[F](selector, backend):
+  def fill(value: String)(using Trace): F[Unit] = backend.fill(selector, value)
+
+/** `<textarea>` — same shared verbs as [[InputHandle]]. */
+final class TextAreaHandle[F[_]](selector: String, backend: HandleBackend[F])
+    extends ElementHandle[F](selector, backend):
+  def fill(value: String)(using Trace): F[Unit] = backend.fill(selector, value)
+
+/** `<button>` — no `fill`. */
+final class ButtonHandle[F[_]](selector: String, backend: HandleBackend[F]) extends ElementHandle[F](selector, backend)
+
+/** `<select>` — `selectOption` is JS-only until Chekhov's `Locator` grows it. */
+final class SelectHandle[F[_]](selector: String, backend: HandleBackend[F]) extends ElementHandle[F](selector, backend)
diff --git a/chekhov/src/main/scala/ascent/chekhov/Selectors.scala b/chekhov/src/main/scala/ascent/chekhov/Selectors.scala
new file mode 100644
index 0000000..dc4418c
--- /dev/null
+++ b/chekhov/src/main/scala/ascent/chekhov/Selectors.scala
@@ -0,0 +1,31 @@
+package ascent.chekhov
+
+import ascent.domtypes.{ElementKey, VoidElementKey}
+
+/** CSS selector fragments built from the HTML lattice. No live DOM, no Playwright. */
+object Selectors:
+
+  /** Escape a value that will sit inside a double-quoted CSS attribute selector. */
+  def escapeAttr(value: String): String =
+    value.replace("\\", "\\\\").replace("\"", "\\\"")
+
+  def testIdSelector(testId: String): String =
+    s"""[data-testid="${escapeAttr(testId)}"]"""
+
+  def taggedSelector(tagName: String, testId: String): String =
+    s"${tagName}${testIdSelector(testId)}"
+
+  def taggedTestId(testId: String, tag: ElementKey | VoidElementKey): String =
+    val name = tag match
+      case k: ElementKey     => k.domName
+      case k: VoidElementKey => k.domName
+    taggedSelector(name, testId)
+
+  def placeholderSelector(tagName: String, text: String): String =
+    s"""${tagName}[placeholder="${escapeAttr(text)}"]"""
+
+  def roleSelector(role: String): String =
+    s"""[role="${escapeAttr(role)}"]"""
+end Selectors
+
+export Selectors.{escapeAttr, testIdSelector, taggedSelector, taggedTestId, placeholderSelector, roleSelector}
diff --git a/chekhov/src/main/scala/ascent/chekhov/TagHandle.scala b/chekhov/src/main/scala/ascent/chekhov/TagHandle.scala
new file mode 100644
index 0000000..1b19195
--- /dev/null
+++ b/chekhov/src/main/scala/ascent/chekhov/TagHandle.scala
@@ -0,0 +1,45 @@
+package ascent.chekhov
+
+/** Maps an [[HtmlTag]] marker onto a handle constructor.
+  *
+  * `ElementKey` is unparameterized (`val button: ElementKey`), so a given on `Elements.button.type` is not inferred
+  * from `E.button`. Callers pass [[HtmlTag.button]] (or `root.button("inc")`) so the handle kind is a compile-time
+  * fact. Named `HtmlTag`, not `Tag`, to stay clear of `zio.Tag`.
+  */
+trait TagHandle[K]:
+  type Handle[F[_]] <: ElementHandle[F]
+  def tagName: String
+  def wrap[F[_]](selector: String, backend: HandleBackend[F]): Handle[F]
+
+/** Singleton markers that preserve distinct types under inference (`HtmlTag.input` vs `HtmlTag.button`). */
+object HtmlTag:
+  object input
+  object button
+  object textarea
+  object select
+
+object TagHandle:
+  given input: TagHandle[HtmlTag.input.type] with
+    type Handle[F[_]] = InputHandle[F]
+    def tagName: String                                                         = "input"
+    def wrap[F[_]](selector: String, backend: HandleBackend[F]): InputHandle[F] =
+      InputHandle(selector, backend)
+
+  given button: TagHandle[HtmlTag.button.type] with
+    type Handle[F[_]] = ButtonHandle[F]
+    def tagName: String                                                          = "button"
+    def wrap[F[_]](selector: String, backend: HandleBackend[F]): ButtonHandle[F] =
+      ButtonHandle(selector, backend)
+
+  given textarea: TagHandle[HtmlTag.textarea.type] with
+    type Handle[F[_]] = TextAreaHandle[F]
+    def tagName: String                                                            = "textarea"
+    def wrap[F[_]](selector: String, backend: HandleBackend[F]): TextAreaHandle[F] =
+      TextAreaHandle(selector, backend)
+
+  given select: TagHandle[HtmlTag.select.type] with
+    type Handle[F[_]] = SelectHandle[F]
+    def tagName: String                                                          = "select"
+    def wrap[F[_]](selector: String, backend: HandleBackend[F]): SelectHandle[F] =
+      SelectHandle(selector, backend)
+end TagHandle
diff --git a/chekhov/src/main/scala/ascent/chekhovExports.scala b/chekhov/src/main/scala/ascent/chekhovExports.scala
new file mode 100644
index 0000000..5dea012
--- /dev/null
+++ b/chekhov/src/main/scala/ascent/chekhovExports.scala
@@ -0,0 +1,22 @@
+package ascent
+
+/** Export facade for `ascent-chekhov`. Contributes the shared handle types to the open `package ascent` so tests can
+  * `import ascent.*` and see [[InputHandle]] / [[ButtonHandle]]. Platform backends (`withMounted`, `Page` extensions)
+  * are exported from the js / jvm trees.
+  */
+export ascent.chekhov.{
+  HandleBackend,
+  ElementHandle,
+  InputHandle,
+  TextAreaHandle,
+  ButtonHandle,
+  SelectHandle,
+  HtmlTag,
+  TagHandle,
+  Selectors,
+  testIdSelector,
+  taggedSelector,
+  taggedTestId,
+  placeholderSelector,
+  roleSelector,
+}
diff --git a/chekhov/src/main/scalajs/ascent/chekhov/AscentChekhov.scala b/chekhov/src/main/scalajs/ascent/chekhov/AscentChekhov.scala
new file mode 100644
index 0000000..575f6a0
--- /dev/null
+++ b/chekhov/src/main/scalajs/ascent/chekhov/AscentChekhov.scala
@@ -0,0 +1,250 @@
+package ascent.chekhov
+
+import ascent.ast.UI
+import ascent.dom
+import ascent.js.AscentApp
+import chekhov.dom.ChekhovDom
+import zio.*
+
+import scala.annotation.unused
+import scala.scalajs.js
+
+/** JSEnv mount + typed locators. Replaces `chekhov.ascent.ChekhovAscent.withMounted`. */
+object AscentChekhov:
+
+  type Effect[+A] = IO[Throwable, A]
+
+  /** Scoped throwaway iframe root, mount `ui`, run `use`, then unmount via [[ascent.js.Subscriptions.cancelAll]]. */
+  def withMounted[R, E, A](
+      ui: UI[R]
+  )(use: AscentRoot => ZIO[R, E, A])(using Trace): ZIO[R, E | Throwable, A] =
+    ChekhovDom.withRoot { sjsRoot =>
+      val root = sjsRoot.asInstanceOf[dom.Element]
+      ZIO.scoped {
+        for
+          _ <- ZIO.acquireRelease(AscentApp.mount(ui, root))(_.cancelAll)
+          a <- use(AscentRoot(root))
+        yield a
+      }
+    }
+end AscentChekhov
+
+/** Search root for an iframe-scoped mount. Always query this element, never parent `document.body`. */
+final class AscentRoot(val element: dom.Element):
+
+  def getByTestId(testId: String): EffectHandle =
+    ElementHandle(testIdSelector(testId), LiveBackend(this, None))
+
+  def getByTestId[K](testId: String, @unused tag: K)(using
+      h: TagHandle[K]
+  ): LiveHandles.LiveOf[h.Handle] =
+    // Wait on the testid (not `input[data-testid=…]`) so a wrong tag is a
+    // mismatch, not a timeout.
+    LiveHandles.typed(this, testIdSelector(testId), h)
+
+  def input(testId: String): InputHandle[AscentChekhov.Effect] =
+    getByTestId(testId, HtmlTag.input)
+
+  def button(testId: String): ButtonHandle[AscentChekhov.Effect] =
+    getByTestId(testId, HtmlTag.button)
+
+  def textarea(testId: String): TextAreaHandle[AscentChekhov.Effect] =
+    getByTestId(testId, HtmlTag.textarea)
+
+  def select(testId: String): SelectHandle[AscentChekhov.Effect] =
+    getByTestId(testId, HtmlTag.select)
+
+  def getByRole(role: String): EffectHandle =
+    ElementHandle(roleSelector(role), LiveBackend(this, None))
+
+  def css(selector: String): EffectHandle =
+    ElementHandle(selector, LiveBackend(this, None))
+
+  private[chekhov] def waitFor(
+      selector: String,
+      timeout: Duration = 5.seconds,
+      expectedTag: Option[String] = None,
+  )(using Trace): IO[Throwable, dom.Element] =
+    def attempt: UIO[Option[dom.Element]] =
+      ZIO.succeed(Option(element.querySelector(selector)).filter(el => el != null && !js.isUndefined(el)))
+
+    def loop: IO[Throwable, dom.Element] =
+      attempt.flatMap {
+        case Some(el) => ZIO.succeed(el)
+        case None     => ZIO.sleep(50.millis) *> loop
+      }
+
+    val hint = expectedTag.fold(selector)(tag => s"""$tag$selector""")
+    loop.timeoutFail(new RuntimeException(s"Timeout waiting for $hint"))(timeout)
+  end waitFor
+end AscentRoot
+
+object LiveHandles:
+  type LiveOf[H[_[_]]] = H[AscentChekhov.Effect]
+
+  def typed[K](root: AscentRoot, selector: String, h: TagHandle[K]): LiveOf[h.Handle] =
+    h.wrap(selector, LiveBackend(root, Some(h.tagName)))
+
+/** Live-node backend. `expectedTag` is the catalog tag we must see after `querySelector`. */
+final class LiveBackend(root: AscentRoot, expectedTag: Option[String]) extends HandleBackend[AscentChekhov.Effect]:
+  def click(selector: String)(using Trace): AscentChekhov.Effect[Unit] =
+    resolve(selector).map(el => LiveOps.click(el))
+
+  def fill(selector: String, value: String)(using Trace): AscentChekhov.Effect[Unit] =
+    resolve(selector).flatMap(el => LiveOps.fill(el, value, selector))
+
+  def press(selector: String, key: String)(using Trace): AscentChekhov.Effect[Unit] =
+    resolve(selector).flatMap(el => LiveOps.press(el, key))
+
+  def innerText(selector: String)(using Trace): AscentChekhov.Effect[String] =
+    resolve(selector).map(el => Option(el.asInstanceOf[js.Dynamic].innerText.asInstanceOf[String]).getOrElse(""))
+
+  def textContent(selector: String)(using Trace): AscentChekhov.Effect[String] =
+    resolve(selector).map(el => Option(el.textContent).getOrElse(""))
+
+  def resolve(selector: String)(using Trace): AscentChekhov.Effect[dom.Element] =
+    root.waitFor(selector, expectedTag = expectedTag).flatMap { el =>
+      expectedTag match
+        case None      => ZIO.succeed(el)
+        case Some(tag) =>
+          val actual = el.tagName
+          if actual.equalsIgnoreCase(tag) then ZIO.succeed(el)
+          else ZIO.fail(new RuntimeException(s"expected ${tag.toUpperCase}, got $actual"))
+    }
+end LiveBackend
+
+/** JS extras that need the live node. Shared handles stay backend-only. */
+type EffectHandle = ElementHandle[AscentChekhov.Effect]
+
+extension [H <: ElementHandle[AscentChekhov.Effect]](handle: H)
+  def element(using Trace): AscentChekhov.Effect[dom.Element] =
+    handle.backend match
+      case live: LiveBackend => live.resolve(handle.selector)
+      case _                 => ZIO.fail(new RuntimeException("not a live handle"))
+
+  def focus(using Trace): AscentChekhov.Effect[Unit] =
+    element.map(el => LiveOps.focus(el))
+
+  def getAttribute(name: String)(using Trace): AscentChekhov.Effect[String] =
+    element.map(el => Option(el.getAttribute(name)).getOrElse(""))
+
+  def disabled(using Trace): AscentChekhov.Effect[Boolean] =
+    element.map(el => LiveOps.disabled(el))
+end extension
+
+extension (handle: InputHandle[AscentChekhov.Effect])
+  def value(using Trace): AscentChekhov.Effect[String] =
+    handle.element.map(el => LiveOps.stringProp(el, "value"))
+
+  def checked(using Trace): AscentChekhov.Effect[Boolean] =
+    handle.element.map(el => LiveOps.boolProp(el, "checked"))
+
+  def check(using Trace): AscentChekhov.Effect[Unit] =
+    handle.element.flatMap(el => LiveOps.setChecked(el, want = true, handle.selector))
+
+  def uncheck(using Trace): AscentChekhov.Effect[Unit] =
+    handle.element.flatMap(el => LiveOps.setChecked(el, want = false, handle.selector))
+
+  def selectionStart(using Trace): AscentChekhov.Effect[Int] =
+    handle.element.flatMap(el => LiveOps.selectionStart(el, handle.selector))
+end extension
+
+extension (handle: TextAreaHandle[AscentChekhov.Effect])
+  def value(using Trace): AscentChekhov.Effect[String] =
+    handle.element.map(el => LiveOps.stringProp(el, "value"))
+
+  def selectionStart(using Trace): AscentChekhov.Effect[Int] =
+    handle.element.flatMap(el => LiveOps.selectionStart(el, handle.selector))
+end extension
+
+extension (handle: ButtonHandle[AscentChekhov.Effect])
+  def value(using Trace): AscentChekhov.Effect[String] =
+    handle.element.map(el => LiveOps.stringProp(el, "value"))
+
+extension (handle: SelectHandle[AscentChekhov.Effect])
+  def value(using Trace): AscentChekhov.Effect[String] =
+    handle.element.map(el => LiveOps.stringProp(el, "value"))
+
+  def selectOption(value: String)(using Trace): AscentChekhov.Effect[Unit] =
+    handle.element.flatMap(el => LiveOps.selectOption(el, value, handle.selector))
+end extension
+
+private[chekhov] object LiveOps:
+  def click(el: dom.Element): Unit =
+    el.asInstanceOf[js.Dynamic].click()
+    ()
+
+  def focus(el: dom.Element): Unit =
+    el.asInstanceOf[js.Dynamic].focus()
+    ()
+
+  def stringProp(el: dom.Element, name: String): String =
+    Option(el.asInstanceOf[js.Dynamic].selectDynamic(name).asInstanceOf[String]).getOrElse("")
+
+  def boolProp(el: dom.Element, name: String): Boolean =
+    el.asInstanceOf[js.Dynamic].selectDynamic(name).asInstanceOf[Boolean]
+
+  def disabled(el: dom.Element): Boolean =
+    boolProp(el, "disabled")
+
+  def fill(el: dom.Element, value: String, selector: String): IO[Throwable, Unit] =
+    val tag = el.tagName
+    if tag.equalsIgnoreCase("INPUT") || tag.equalsIgnoreCase("TEXTAREA") then
+      ZIO.succeed {
+        val dyn = el.asInstanceOf[js.Dynamic]
+        dyn.value = value
+        dispatchInput(el)
+      }
+    else ZIO.fail(new RuntimeException(s"not an input: $selector"))
+
+  def setChecked(el: dom.Element, want: Boolean, selector: String): IO[Throwable, Unit] =
+    if el.tagName.equalsIgnoreCase("INPUT") then
+      ZIO.succeed {
+        val dyn = el.asInstanceOf[js.Dynamic]
+        dyn.checked = want
+        dispatchInput(el)
+      }
+    else ZIO.fail(new RuntimeException(s"not an input: $selector"))
+
+  def selectionStart(el: dom.Element, selector: String): IO[Throwable, Int] =
+    val tag = el.tagName
+    if tag.equalsIgnoreCase("INPUT") || tag.equalsIgnoreCase("TEXTAREA") then
+      ZIO.succeed(el.asInstanceOf[js.Dynamic].selectionStart.asInstanceOf[Int])
+    else ZIO.fail(new RuntimeException(s"not an input: $selector"))
+
+  def selectOption(el: dom.Element, value: String, selector: String): IO[Throwable, Unit] =
+    if el.tagName.equalsIgnoreCase("SELECT") then
+      ZIO.succeed {
+        val dyn = el.asInstanceOf[js.Dynamic]
+        dyn.value = value
+        dispatchInput(el)
+      }
+    else ZIO.fail(new RuntimeException(s"not a select: $selector"))
+
+  def press(el: dom.Element, key: String): IO[Throwable, Unit] =
+    ZIO.succeed {
+      val dyn  = el.asInstanceOf[js.Dynamic]
+      val view = eventView(el)
+      val init = js.Dynamic.literal(bubbles = true, cancelable = true, key = key)
+      val ev   = js.Dynamic.newInstance(view.selectDynamic("KeyboardEvent"))("keydown", init)
+      dyn.dispatchEvent(ev)
+      ()
+    }
+
+  def dispatchInput(el: dom.Element): Unit =
+    val view = eventView(el)
+    val init = js.Dynamic.literal(bubbles = true)
+    val ev   = js.Dynamic.newInstance(view.selectDynamic("InputEvent"))("input", init)
+    el.asInstanceOf[js.Dynamic].dispatchEvent(ev)
+    ()
+
+  /** Construct events in the iframe's window. Parent-window `InputEvent` is a different realm. */
+  def eventView(el: dom.Element): js.Dynamic =
+    val doc  = el.asInstanceOf[js.Dynamic].ownerDocument
+    val view =
+      if doc != null && !js.isUndefined(doc) then doc.selectDynamic("defaultView")
+      else js.undefined
+    // `js.Dynamic.global` is not a value; fall back through `.window`.
+    if view == null || js.isUndefined(view) then js.Dynamic.global.window
+    else view.asInstanceOf[js.Dynamic]
+end LiveOps
diff --git a/chekhov/src/main/scalajs/ascent/chekhovJsExports.scala b/chekhov/src/main/scalajs/ascent/chekhovJsExports.scala
new file mode 100644
index 0000000..61192eb
--- /dev/null
+++ b/chekhov/src/main/scalajs/ascent/chekhovJsExports.scala
@@ -0,0 +1,5 @@
+package ascent
+
+export ascent.chekhov.AscentChekhov
+export ascent.chekhov.AscentChekhov.withMounted
+export ascent.chekhov.AscentRoot
diff --git a/chekhov/src/main/scalajvm/ascent/chekhov/PageHandles.scala b/chekhov/src/main/scalajvm/ascent/chekhov/PageHandles.scala
new file mode 100644
index 0000000..de22339
--- /dev/null
+++ b/chekhov/src/main/scalajvm/ascent/chekhov/PageHandles.scala
@@ -0,0 +1,60 @@
+package ascent.chekhov
+
+import scala.annotation.unused
+
+import chekhov.{ChekhovError, Locator, Page}
+import zio.{IO, Trace}
+
+/** JVM interpreter: Ascent handles over Chekhov's remote [[Locator]].
+  *
+  * Methods live here rather than as `extension (page: Page)` members named `getByTestId` / `getByPlaceholder`. Those
+  * names already exist on [[Page]] with a different arity, and `page.getByPlaceholder(text, HtmlTag.input)` is parsed
+  * as a two-tuple argument to the existing one-arg method.
+  */
+object PageHandles:
+
+  type Effect[+A] = IO[ChekhovError, A]
+
+  final class LocatorBackend(locatorOf: String => Locator) extends HandleBackend[Effect]:
+    def click(selector: String)(using Trace): Effect[Unit] =
+      locatorOf(selector).click
+    def fill(selector: String, value: String)(using Trace): Effect[Unit] =
+      locatorOf(selector).fill(value)
+    def press(selector: String, key: String)(using Trace): Effect[Unit] =
+      locatorOf(selector).press(key)
+    def innerText(selector: String)(using Trace): Effect[String] =
+      locatorOf(selector).innerText
+    def textContent(selector: String)(using Trace): Effect[String] =
+      locatorOf(selector).textContent
+  end LocatorBackend
+
+  def backend(page: Page): LocatorBackend = LocatorBackend(page.locator)
+
+  def getByTestId[K](page: Page, testId: String, @unused tag: K)(using h: TagHandle[K]): h.Handle[Effect] =
+    h.wrap(taggedSelector(h.tagName, testId), backend(page))
+
+  def getByPlaceholder[K](page: Page, text: String, @unused tag: K)(using
+      h: TagHandle[K]
+  ): h.Handle[Effect] =
+    h.wrap(placeholderSelector(h.tagName, text), backend(page))
+
+  def input(page: Page, testId: String): InputHandle[Effect] =
+    getByTestId(page, testId, HtmlTag.input)
+
+  def button(page: Page, testId: String): ButtonHandle[Effect] =
+    getByTestId(page, testId, HtmlTag.button)
+
+  def textarea(page: Page, testId: String): TextAreaHandle[Effect] =
+    getByTestId(page, testId, HtmlTag.textarea)
+
+  def select(page: Page, testId: String): SelectHandle[Effect] =
+    getByTestId(page, testId, HtmlTag.select)
+end PageHandles
+
+extension (page: Page)
+  def input(testId: String): InputHandle[PageHandles.Effect]       = PageHandles.input(page, testId)
+  def button(testId: String): ButtonHandle[PageHandles.Effect]     = PageHandles.button(page, testId)
+  def textarea(testId: String): TextAreaHandle[PageHandles.Effect] =
+    PageHandles.textarea(page, testId)
+  def select(testId: String): SelectHandle[PageHandles.Effect] = PageHandles.select(page, testId)
+end extension
diff --git a/chekhov/src/main/scalajvm/ascent/chekhovJvmExports.scala b/chekhov/src/main/scalajvm/ascent/chekhovJvmExports.scala
new file mode 100644
index 0000000..742f281
--- /dev/null
+++ b/chekhov/src/main/scalajvm/ascent/chekhovJvmExports.scala
@@ -0,0 +1,4 @@
+package ascent
+
+export ascent.chekhov.PageHandles
+export ascent.chekhov.{input, button, textarea, select}
diff --git a/chekhov/src/test/scala/ascent/chekhov/SelectorsSpec.scala b/chekhov/src/test/scala/ascent/chekhov/SelectorsSpec.scala
new file mode 100644
index 0000000..5542137
--- /dev/null
+++ b/chekhov/src/test/scala/ascent/chekhov/SelectorsSpec.scala
@@ -0,0 +1,52 @@
+package ascent.chekhov
+
+import zio.test.*
+
+/** Browser-free: CSS fragments compiled from the lattice. */
+object SelectorsSpec extends ZIOSpecDefault:
+
+  def spec = suite("Selectors")(
+    test("taggedTestId prefixes the catalog tag") {
+      assertTrue(
+        taggedSelector(TagHandle.button.tagName, "inc") == """button[data-testid="inc"]""",
+        taggedSelector(TagHandle.input.tagName, "todo") == """input[data-testid="todo"]""",
+        taggedSelector(TagHandle.textarea.tagName, "bio") == """textarea[data-testid="bio"]""",
+        taggedSelector(TagHandle.select.tagName, "pick") == """select[data-testid="pick"]""",
+      )
+    },
+    test("placeholderSelector quotes the hint") {
+      assertTrue(
+        placeholderSelector("input", "What needs to be done?") ==
+          """input[placeholder="What needs to be done?"]"""
+      )
+    },
+    test("escapeAttr escapes quotes and backslashes") {
+      assertTrue(
+        testIdSelector("""a"b\c""") == """[data-testid="a\"b\\c"]""",
+        taggedSelector("button", """say "hi"""") == """button[data-testid="say \"hi\""]""",
+      )
+    },
+    test("TagHandle givens wrap the matching handle class") {
+      val backend = RecordingBackend()
+      val input   = TagHandle.input.wrap("input[data-testid=\"x\"]", backend)
+      val button  = TagHandle.button.wrap("button[data-testid=\"x\"]", backend)
+      val area    = TagHandle.textarea.wrap("textarea[data-testid=\"x\"]", backend)
+      val select  = TagHandle.select.wrap("select[data-testid=\"x\"]", backend)
+      assertTrue(
+        input.isInstanceOf[InputHandle[?]],
+        button.isInstanceOf[ButtonHandle[?]],
+        area.isInstanceOf[TextAreaHandle[?]],
+        select.isInstanceOf[SelectHandle[?]],
+        !button.isInstanceOf[InputHandle[?]],
+      )
+    },
+  )
+
+  /** No-op backend so wrap can be exercised without a Page. */
+  final class RecordingBackend extends HandleBackend[[A] =>> A]:
+    def click(selector: String)(using zio.Trace): Unit               = ()
+    def fill(selector: String, value: String)(using zio.Trace): Unit = ()
+    def press(selector: String, key: String)(using zio.Trace): Unit  = ()
+    def innerText(selector: String)(using zio.Trace): String         = ""
+    def textContent(selector: String)(using zio.Trace): String       = ""
+end SelectorsSpec
diff --git a/chekhov/src/test/scalajs/ascent/chekhov/AscentChekhovSpec.scala b/chekhov/src/test/scalajs/ascent/chekhov/AscentChekhovSpec.scala
new file mode 100644
index 0000000..040b3ea
--- /dev/null
+++ b/chekhov/src/test/scalajs/ascent/chekhov/AscentChekhovSpec.scala
@@ -0,0 +1,147 @@
+package ascent.chekhov
+
+import ascent.*
+import ascent.ast.Attr
+import ascent.dom
+import ascent.domtypes.AttrValue
+import ascent.dsl.*
+import ascent.chekhov.AscentChekhov.withMounted
+import zio.*
+import zio.test.*
+
+/** Live `withMounted` + typed handles under ChekhovJSEnv. */
+object AscentChekhovSpec extends ZIOSpecDefault:
+
+  override def aspects =
+    Chunk(
+      TestAspect.withLiveClock,
+      TestAspect.timeout(15.seconds),
+    )
+
+  private def testId(id: String): Attr[Any] =
+    Attr.StaticAttr("data-testid", AttrValue.Str(id))
+
+  def spec =
+    suite("AscentChekhov")(
+      test("withMounted mounts a counter and supports button click") {
+        for
+          count <- sq(0)
+          ui = E.div(
+            testId("root"),
+            E.span(testId("count"), count.map(_.toString)),
+            E.button(
+              testId("inc"),
+              A.typ("button"),
+              Ev.onClick(_ => count.update(_ + 1)),
+              "Increment",
+            ),
+          )
+          result <- withMounted(ui) { root =>
+            for
+              before <- root.getByTestId("count").innerText
+              _      <- root.button("inc").click
+              after  <- waitForText(root, "count", "1")
+            yield assertTrue(before == "0", after == "1")
+          }
+        yield result
+      },
+      test("withMounted removes the chekhov root on exit") {
+        for
+          ref    <- Ref.make[Option[dom.Element]](None)
+          during <- withMounted(E.div(testId("x"), "hi")) { root =>
+            ref.set(Some(root.element)).as(root.element.getAttribute("data-chekhov-root") == "true")
+          }
+          detached <- ref.get.map(_.exists(el => !el.isConnected))
+        yield assertTrue(during, detached)
+      },
+      test("concurrent withMounted scopes are isolated from each other") {
+        def scope(
+            tag: String,
+            other: String,
+            ref: Ref[Option[dom.Element]],
+            ready: Promise[Nothing, Unit],
+            otherReady: Promise[Nothing, Unit],
+        ) =
+          withMounted(E.div(testId(tag), tag)) { root =>
+            for
+              _  <- ref.set(Some(root.element))
+              _  <- ready.succeed(())
+              _  <- otherReady.await
+              ok <- ZIO.succeed(
+                root.element.getAttribute("data-chekhov-root") == "true" &&
+                  !root.element.ownerDocument.eq(dom.document) &&
+                  Option(root.element.querySelector(s"""[data-testid="$other"]""")).isEmpty &&
+                  Option(dom.document.querySelector(s"""[data-testid="$tag"]""")).isEmpty
+              )
+            yield ok
+          }
+
+        for
+          ra         <- Ref.make[Option[dom.Element]](None)
+          rb         <- Ref.make[Option[dom.Element]](None)
+          inA        <- Promise.make[Nothing, Unit]
+          inB        <- Promise.make[Nothing, Unit]
+          (okA, okB) <-
+            scope("iso-a", "iso-b", ra, inA, inB).zipPar(scope("iso-b", "iso-a", rb, inB, inA))
+          a <- ra.get
+          b <- rb.get
+        yield assertTrue(
+          okA,
+          okB,
+          (a, b) match
+            case (Some(x), Some(y)) => !x.ownerDocument.eq(y.ownerDocument)
+            case _                  => false
+          ,
+          a.forall(!_.isConnected),
+          b.forall(!_.isConnected),
+        )
+        end for
+      },
+      test("InputHandle.fill updates a Squawk bound to onInput") {
+        for
+          text <- sq("")
+          ui = E.div(
+            E.input(
+              testId("todo"),
+              A.typ("text"),
+              A.value(text),
+              Events.onInput(e => text.set(e.targetValue.getOrElse(""))),
+            ),
+            E.span(testId("echo"), text),
+          )
+          result <- withMounted(ui) { root =>
+            for
+              _    <- root.input("todo").fill("milk")
+              echo <- waitForText(root, "echo", "milk")
+              v    <- root.input("todo").value
+            yield assertTrue(echo == "milk", v == "milk")
+          }
+        yield result
+      },
+      test("tag mismatch fails with a clear message") {
+        val ui = E.div(E.button(testId("inc"), A.typ("button"), "Go"))
+        withMounted(ui) { root =>
+          root.input("inc").click.flip.map { err =>
+            val msg = err.getMessage
+            assertTrue(msg.contains("expected INPUT"), msg.contains("BUTTON"))
+          }
+        }
+      },
+      test("missing testid times out naming the selector") {
+        withMounted(E.div()) { root =>
+          root.button("nope").click.flip.map { err =>
+            val msg = err.getMessage
+            assertTrue(msg.contains("Timeout waiting for"), msg.contains("""button[data-testid="nope"]"""))
+          }
+        }
+      },
+    )
+
+  private def waitForText(root: AscentRoot, testIdName: String, expected: String)(using Trace): IO[Throwable, String] =
+    def loop: IO[Throwable, String] =
+      root.getByTestId(testIdName).innerText.flatMap { t =>
+        if t == expected then ZIO.succeed(t)
+        else ZIO.sleep(20.millis) *> loop
+      }
+    loop.timeoutFail(new RuntimeException(s"timed out waiting for $testIdName == $expected"))(5.seconds)
+end AscentChekhovSpec
diff --git a/docs/src/main/scala/ascent/docs/Modules.scala b/docs/src/main/scala/ascent/docs/Modules.scala
index 8e4e629..a03ed59 100644
--- a/docs/src/main/scala/ascent/docs/Modules.scala
+++ b/docs/src/main/scala/ascent/docs/Modules.scala
@@ -23,6 +23,7 @@ published so consumers resolve transitively.
 | `ascent-datastar-js` | Browser datastar runtime |
 | `ascent-datastar-http` | zio-http datastar server bridge |
 | `ascent-preview` | Local static serve + SSE tab reload. See [Preview](preview.html). |
+| `ascent-chekhov` | Typed Chekhov locators: JSEnv live handles + JVM `Page` selectors |
 | `sbt-ascent-preview` | `enablePlugins(AscentPreviewPlugin)` then `sbt ~<module>/ascentPreview` |
 
 ## Internals (transitive)
diff --git a/docs/src/main/scalajvm/ascent/docs/BuildSite.scala b/docs/src/main/scalajvm/ascent/docs/BuildSite.scala
index a971a72..ccc3f88 100644
--- a/docs/src/main/scalajvm/ascent/docs/BuildSite.scala
+++ b/docs/src/main/scalajvm/ascent/docs/BuildSite.scala
@@ -88,6 +88,7 @@ Docs pages are Specular `DocSpec`s: the same source asserts under zio-test and S
   "$org" %%  "ascent-datastar-http" % "$version", // server datastar
   "$org" %%% "ascent-datastar-js"   % "$version", // browser datastar
   "$org" %%  "ascent-preview"       % "$version", // local static + SSE reload
+  "$org" %%% "ascent-chekhov"       % "$version" % Test, // typed Chekhov locators
 )""",
         ),
         CodeSnippet(
diff --git a/e2e/src/test/scala/ascent/e2e/HybridChatSpec.scala b/e2e/src/test/scala/ascent/e2e/HybridChatSpec.scala
index f29137e..7f5adf1 100644
--- a/e2e/src/test/scala/ascent/e2e/HybridChatSpec.scala
+++ b/e2e/src/test/scala/ascent/e2e/HybridChatSpec.scala
@@ -1,5 +1,6 @@
 package ascent.e2e
 
+import ascent.chekhov.PageHandles
 import chekhov.*
 import example.chat.{ChatRoom, ChatServer}
 import zio.*
@@ -15,8 +16,10 @@ object HybridChatSpec extends AscentChekhovSuite:
           base <- PreviewServe.install(ChatServer.routes(room, Repo.preview("hybrid-chat")))
           page <- Chekhov.page
           _    <- page.goto(base.value + "/")
-          _    <- page.getByPlaceholder("Your name").fill("Ada")
-          _    <- page.getByPlaceholder("Type a message and press Enter").fill("hello from e2e")
+          _    <- PageHandles.getByPlaceholder(page, "Your name", ascent.HtmlTag.input).fill("Ada")
+          _    <- PageHandles
+            .getByPlaceholder(page, "Type a message and press Enter", ascent.HtmlTag.input)
+            .fill("hello from e2e")
           _    <- page.getByRole(Role.Button, name = Some("Send")).click
           body <- Poll.until("message appears")(page.innerText("#messages"))(_.contains("hello from e2e"))
         yield assertTrue(body.contains("hello from e2e"), body.contains("Ada")))
diff --git a/project/AscentZipx.scala b/project/AscentZipx.scala
index 70669f0..11cda8f 100644
--- a/project/AscentZipx.scala
+++ b/project/AscentZipx.scala
@@ -104,6 +104,7 @@ object AscentZipx extends AutoPlugin:
           command = zipxTasks.session(
             LocalProject("e2e") / chekhovInstall,
             LocalProject("e2e") / Test / testFull,
+            LocalProject("ascentChekhovJS") / Test / testFull,
           ),
         )
         .withNodeVersion(NodeVersion("24")),
diff --git a/project/ZipxVersions.scala b/project/ZipxVersions.scala
index 016fc46..cb4a971 100644
--- a/project/ZipxVersions.scala
+++ b/project/ZipxVersions.scala
@@ -33,8 +33,10 @@ object MyVersions extends ZipxVersions:
   val specularZioTest = specular.mod("specular-zio-test")
   val specularTheme   = specular.mod("early-effect-docs-theme")
 
-  val chekhovZioTest = Lib("rocks.earlyeffect", "chekhov-zio-test", "0.0.4")
+  val chekhovZioTest = Lib("rocks.earlyeffect", "chekhov-zio-test", "0.0.5")
   val chekhovDriver  = chekhovZioTest.mod("chekhov-driver")
+  val chekhovCore    = chekhovZioTest.mod("chekhov-core")
+  val chekhovDom     = chekhovZioTest.mod("chekhov-dom")
   val neotype        = Lib("io.github.kitlangton", "neotype", "0.7.0")
 
   val scalajs        = Plugin("org.scala-js", "sbt-scalajs", "1.22.0")
@@ -45,7 +47,7 @@ object MyVersions extends ZipxVersions:
   val specularPlugin = Plugin("rocks.earlyeffect", "sbt-specular", "0.14.0")
   val sbtSplice      = Plugin("rocks.earlyeffect", "sbt-splice", "0.1.0")
   val sbtReload      = Plugin("com.jamesward", "sbt-reload", "0.0.7")
-  val sbtChekhov     = Plugin("rocks.earlyeffect", "sbt-chekhov", "0.0.4")
+  val sbtChekhov     = Plugin("rocks.earlyeffect", "sbt-chekhov", "0.0.5")
 
   def zioTests        = library(zioTest.test, zioTestSbt.test)
   def zioLib          = library(zio)
@@ -60,5 +62,7 @@ object MyVersions extends ZipxVersions:
   def docsJvm         = library(specularZioTest, specularTheme)
   def docsJs          = library(specular, zioTest)
   def e2eTests        = library(chekhovZioTest.test, chekhovDriver.test)
+  def chekhovCoreLib  = library(chekhovCore)
+  def chekhovDomLib   = library(chekhovDom)
   def sbtPreviewLib   = library(neotype)
 end MyVersions
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 9cc75e4..428f372 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -8,4 +8,4 @@ addSbtPlugin("rocks.earlyeffect" % "sbt-dynver-ci" % "0.2.3")
 addSbtPlugin("rocks.earlyeffect" % "sbt-specular" % "0.14.0")
 addSbtPlugin("rocks.earlyeffect" % "sbt-splice" % "0.1.0")
 addSbtPlugin("com.jamesward" % "sbt-reload" % "0.0.7")
-addSbtPlugin("rocks.earlyeffect" % "sbt-chekhov" % "0.0.4")
+addSbtPlugin("rocks.earlyeffect" % "sbt-chekhov" % "0.0.5")