diff --git a/benchmarks/.gitignore b/benchmarks/.gitignore
new file mode 100644
index 00000000..09e58b73
--- /dev/null
+++ b/benchmarks/.gitignore
@@ -0,0 +1,5 @@
+elm-stuff/
+elm_home/
+elm.js
+index.html
+results/
diff --git a/benchmarks/Main.elm b/benchmarks/Main.elm
index 92ef6aec..a9f7557b 100644
--- a/benchmarks/Main.elm
+++ b/benchmarks/Main.elm
@@ -1,80 +1,240 @@
-module Main exposing (main)
+port module Main exposing (main)
 
-import Benchmark exposing (..)
-import Benchmark.Runner as Runner
-import Expect exposing (Expectation)
+{-| Throughput benchmarks for elm-test.
+
+Where `f-metric/` asks "is elm-test good at finding bugs", this asks "how fast
+does it get through a test". The two answer different questions, and the F-metric
+harness structurally cannot answer this one: its whole corpus is failing tests,
+so it never measures the case that dominates a real suite -- a fuzz test that
+passes and therefore runs its full budget.
+
+That's also the case where exhaustive checking should pay off by stopping early:
+`Fuzz.bool` given `--fuzz 100` has two possible inputs and ought to cost two
+runs, not a hundred.
+
+Headless rather than browser-based, so it runs in CI and so numbers can be
+produced without a human clicking anything. That means it no longer uses
+elm-explorations/benchmark, whose runner is a browser program; the statistics are
+simple enough to do in `runner.mjs`.
+
+Uses the public `Test.Runner` API. Its `run : () -> List Expectation` is a plain
+function, which is what makes it benchmarkable -- `Test.RunnerV2.runFuzzTest`
+returns a `Task`, and a Task can't be timed from inside Elm.
+
+-}
+
+import Array exposing (Array)
+import Json.Decode as Decode
+import Json.Encode as Encode
+import Platform
 import Random
 import Snippets
-import Test.Internal exposing (Test(..))
+import Test exposing (Test)
+import Test.Runner
 
 
-main : Runner.BenchmarkProgram
+port toJs : Encode.Value -> Cmd msg
+
+
+port fromJs : (Decode.Value -> msg) -> Sub msg
+
+
+main : Program () () Msg
 main =
-    Runner.program suite
-
-
-suite : Benchmark
-suite =
-    describe "Fuzz"
-        [ describe "int"
-            [ benchmark "generating" (benchTest Snippets.intPass)
-            , benchmark "simplifying" (benchTest Snippets.intFail)
-            ]
-        , describe "intRange"
-            [ benchmark "generating" (benchTest Snippets.intRangePass)
-            , benchmark "simplifying" (benchTest Snippets.intRangeFail)
-            ]
-        , describe "string"
-            [ benchmark "generating" (benchTest Snippets.stringPass)
-            , benchmark "simplifying" (benchTest Snippets.stringFail)
-            ]
-        , describe "float"
-            [ benchmark "generating" (benchTest Snippets.floatPass)
-            , benchmark "simplifying" (benchTest Snippets.floatFail)
-            ]
-        , describe "bool"
-            [ benchmark "generating" (benchTest Snippets.boolPass)
-            , benchmark "simplifying" (benchTest Snippets.boolFail)
-            ]
-        , describe "char"
-            [ benchmark "generating" (benchTest Snippets.charPass)
-            , benchmark "simplifying" (benchTest Snippets.charFail)
-            ]
-        , describe "list of int"
-            [ benchmark "generating" (benchTest Snippets.listIntPass)
-            , benchmark "simplifying" (benchTest Snippets.listIntFail)
-            ]
-        , describe "maybe of int"
-            [ benchmark "generating" (benchTest Snippets.maybeIntPass)
-            , benchmark "simplifying" (benchTest Snippets.maybeIntFail)
-            ]
-        , describe "result of string and int"
-            [ benchmark "generating" (benchTest Snippets.resultPass)
-            , benchmark "simplifying" (benchTest Snippets.resultFail)
-            ]
-        , describe "map"
-            [ benchmark "generating" (benchTest Snippets.mapPass)
-            , benchmark "simplifying" (benchTest Snippets.mapFail)
-            ]
-        , describe "andMap"
-            [ benchmark "generating" (benchTest Snippets.andMapPass)
-            , benchmark "simplifying" (benchTest Snippets.andMapFail)
-            ]
-        , describe "map5"
-            [ benchmark "generating" (benchTest Snippets.map5Pass)
-            , benchmark "simplifying" (benchTest Snippets.map5Fail)
-            ]
-        ]
-
-
-benchTest : Test -> (() -> List Expectation)
-benchTest test =
-    case test of
-        ElmTestVariant__FuzzTest fn ->
-            \_ -> fn (Random.initialSeed 0) 10
-
-        ElmTestVariant__Labeled _ test_ ->
-            benchTest test_
-
-        test_ ->
-            Debug.todo <| "No support for benchmarking this type of test: " ++ Debug.toString test_
+    Platform.worker
+        { init = \_ -> ( (), Cmd.none )
+        , update = update
+        , subscriptions = \_ -> fromJs FromJs
+        }
+
+
+type Msg
+    = FromJs Decode.Value
+
+
+type Request
+    = Manifest
+    | Run RunParams
+
+
+type alias RunParams =
+    { index : Int
+    , runs : Int
+    , seed : Int
+    , iterations : Int
+    }
+
+
+update : Msg -> () -> ( (), Cmd Msg )
+update (FromJs raw) model =
+    case Decode.decodeValue requestDecoder raw of
+        Err error ->
+            ( model
+            , toJs
+                (Encode.object
+                    [ ( "tag", Encode.string "error" )
+                    , ( "error", Encode.string (Decode.errorToString error) )
+                    ]
+                )
+            )
+
+        Ok Manifest ->
+            ( model
+            , toJs
+                (Encode.object
+                    [ ( "tag", Encode.string "manifest" )
+                    , ( "benchmarks"
+                      , Encode.list
+                            (\( name, passes, _ ) ->
+                                Encode.object
+                                    [ ( "name", Encode.string name )
+
+                                    {- runs/sec is only meaningful for a test that
+                                       actually executes its whole budget. A failing
+                                       test stops at the first value, so dividing by
+                                       `runs` would overstate it by orders of
+                                       magnitude.
+                                    -}
+                                    , ( "passes", Encode.bool passes )
+                                    ]
+                            )
+                            benchmarks
+                      )
+                    ]
+                )
+            )
+
+        Ok (Run params) ->
+            case Array.get params.index (Array.fromList benchmarks) of
+                Nothing ->
+                    ( model
+                    , toJs
+                        (Encode.object
+                            [ ( "tag", Encode.string "error" )
+                            , ( "error", Encode.string "no benchmark at that index" )
+                            ]
+                        )
+                    )
+
+                Just ( _, _, test ) ->
+                    ( model
+                    , toJs
+                        (Encode.object
+                            [ ( "tag", Encode.string "done" )
+
+                            {- The count exists to force the work. Without
+                               consuming the expectations there'd be nothing
+                               stopping the whole loop being optimized away.
+                            -}
+                            , ( "checksum", Encode.int (repeat params test) )
+                            ]
+                        )
+                    )
+
+
+requestDecoder : Decode.Decoder Request
+requestDecoder =
+    Decode.field "tag" Decode.string
+        |> Decode.andThen
+            (\tag ->
+                case tag of
+                    "manifest" ->
+                        Decode.succeed Manifest
+
+                    "run" ->
+                        Decode.map4 RunParams
+                            (Decode.field "index" Decode.int)
+                            (Decode.field "runs" Decode.int)
+                            (Decode.field "seed" Decode.int)
+                            (Decode.field "iterations" Decode.int)
+                            |> Decode.map Run
+
+                    _ ->
+                        Decode.fail ("unknown tag: " ++ tag)
+            )
+
+
+{-| Run the whole test `iterations` times, returning the number of expectations
+produced so the work can't be elided.
+
+Each iteration rebuilds the runners from scratch, which is what a real runner
+does per test, and keeps one iteration from warming state for the next.
+
+-}
+repeat : RunParams -> Test -> Int
+repeat params test =
+    repeatHelp params test params.iterations 0
+
+
+repeatHelp : RunParams -> Test -> Int -> Int -> Int
+repeatHelp params test remaining acc =
+    if remaining <= 0 then
+        acc
+
+    else
+        let
+            expectations : Int
+            expectations =
+                case Test.Runner.fromTest params.runs (Random.initialSeed params.seed) test of
+                    Test.Runner.Plain runners ->
+                        List.foldl (\runner sum -> sum + List.length (runner.run ())) 0 runners
+
+                    _ ->
+                        0
+        in
+        repeatHelp params test (remaining - 1) (acc + expectations)
+
+
+
+-- BENCHMARKS
+
+
+{-| Name, and the test to run.
+
+The `(passes)` cases are the interesting ones for throughput: they run the full
+`runs` budget. The `simplify/` ones stop at the first value and then simplify, so
+they measure simplification cost instead.
+
+-}
+benchmarks : List ( String, Bool, Test )
+benchmarks =
+    [ -- Small enough to enumerate exhaustively. If exhaustive checking lands,
+      -- these should collapse to a couple of runs regardless of the budget.
+      ( "small/unit", True, Snippets.unitPass )
+    , ( "small/bool", True, Snippets.boolPass )
+    , ( "small/order", True, Snippets.orderPass )
+    , ( "small/intRange-0-20", True, Snippets.intRange0To20Pass )
+    , ( "small/pair-bool", True, Snippets.pairBoolPass )
+    , ( "small/maybe-bool", True, Snippets.maybeBoolPass )
+    , ( "small/oneOfValues", True, Snippets.oneOfValuesPass )
+
+    -- Mid-size: finite, but not trivially so. These decide where a budget
+    -- boundary should sit.
+    , ( "mid/intRange-0-1000", True, Snippets.intRange0To1000Pass )
+    , ( "mid/pair-intRange-0-30", True, Snippets.pairIntRange0To30Pass )
+
+    -- Unbounded. These must not regress: they're where an enumeration probe or
+    -- deduplication bookkeeping is pure overhead.
+    , ( "large/int", True, Snippets.intPass )
+    , ( "large/float", True, Snippets.floatPass )
+    , ( "large/string", True, Snippets.stringPass )
+    , ( "large/list-int", True, Snippets.listIntPass )
+    , ( "large/record-map5", True, Snippets.map5Pass )
+
+    {- Same fuzzers, but with a test body that does real work. Coverage tracking's
+       overhead is mostly per-run and fixed, so a heavier body dilutes it; early
+       termination skips the body too, so a heavier body makes that win larger.
+    -}
+    , ( "heavy/bool", True, Snippets.boolHeavyPass )
+    , ( "heavy/pair-bool", True, Snippets.pairBoolHeavyPass )
+    , ( "heavy/string", True, Snippets.stringHeavyPass )
+    , ( "heavy/list-int", True, Snippets.listIntHeavyPass )
+
+    -- Rejection path.
+    , ( "filter/even", True, Snippets.filterPass )
+
+    -- Simplification cost, for contrast with the passing cases.
+    , ( "simplify/int", False, Snippets.intFail )
+    , ( "simplify/string", False, Snippets.stringFail )
+    , ( "simplify/list-int", False, Snippets.listIntFail )
+    ]
diff --git a/benchmarks/README.md b/benchmarks/README.md
index f4f0aa53..7b099800 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -1,34 +1,125 @@
-# Benchmarks for elm-test
+# Throughput benchmarks for elm-test
 
-These are some benchmarks of the elm-test library built using the excellent [elm-benchmark](https://github.com/BrianHicks/elm-benchmark).
+How fast elm-test gets through a test. For whether it's any *good* at finding
+bugs, see `f-metric/`.
 
-## How to run
+The two are complementary and neither substitutes for the other. The F-metric
+corpus is entirely *failing* tests, so it structurally cannot measure the case
+that dominates a real suite: a fuzz test that passes and therefore runs its whole
+budget. That's also where exhaustive checking should pay off, by stopping as soon
+as the input domain is covered.
+
+## Running
 
 ```sh
-cd ./benchmarks
-elm make Main.elm
-open index.html
+cd benchmarks
+./build.sh
+node runner.mjs --runs 100
+```
+
+`./build.sh` copies `../src` into a local `ELM_HOME` and compiles against it, so
+you always measure the working copy.
+
+### Comparing two implementations
+
+```sh
+# on master
+./build.sh && node runner.mjs --runs 1000 --label before --out /tmp/before.json
+
+# on your branch
+./build.sh && node runner.mjs --runs 1000 --label after --compare /tmp/before.json
+```
+
+Comparison is on `ms/test`, which is defined for passing and failing benchmarks
+alike, and reports a geometric mean so one slow benchmark can't dominate. Use the
+same `--runs` on both sides.
+
+Add `--markdown` for tables you can paste into a PR.
+
+## Reading the output
+
+```
+benchmark               runs/sec  ms/test  iters  spread
+small/bool                 7.48M   0.0134   4096     14%
+simplify/int                 n/a   0.0070   8192     13%
 ```
 
-## How to use
-These benchmarks can help get an idea of the performance impact of a change in the elm-test code.
-Beware however that a fifty percent performance increase in these benchmarks will most likely not translate to a fifty percent faster tests for users.
-In real word scenario's the execution of the test body will have a significant impact on the running time of the test suite, an aspect we're not testing here because it's different for every test suite.
-To get a feeling for the impact your change has on actual test run times try running some real test suites with and without your changes.
-
-## Benchmarking complete test suites
-These are some examples of test suites that contain a lot of fuzzer tests:
-- [elm-benchmark](https://github.com/BrianHicks/elm-benchmark)
-- [elm-nonempty-list](https://github.com/mgold/elm-nonempty-list)
-- [json-elm-schema](https://github.com/NoRedInk/json-elm-schema)
-
-A tool you can use for benchmarking the suite is [bench](https://github.com/Gabriel439/bench).
-
-To run the tests using your modified code (this only works if your modified version is backwards compatible with the version of elm-test currenlty in use by the test suite):
-- In your test suite directories `elm-package.json`:
-  - Remove the dependency on `elm-test`.
-  - Add dependecies of `elm-test` as dependencies of the test suite itself.
-  - Add the path to your changed elm-test src directory to your `source-directories`.
-    It will be something like `/<projects-dir>/elm-test/src`.
-- Run `elm-test` once to trigger compilation.
-- Now run `elm-test` with your benchmarking tool.
+- `runs/sec` — fuzz runs per second, so it stays comparable across `--runs`
+  settings. **`n/a` for failing benchmarks**: they stop at the first value
+  instead of executing the whole budget, so dividing by `--runs` would overstate
+  them by orders of magnitude. Read `ms/test` for those.
+- `ms/test` — wall time for one whole test, budget included.
+- `iters` — how many times the test was run per timed repetition, grown
+  automatically until a repetition clears `--min-ms` so the timer isn't what's
+  being measured. Doubles as warmup.
+- `spread` — max-to-min across repetitions, as a percentage of the median.
+  Currently 1–20%; treat anything under ~1.2x as noise.
+
+## The benchmark groups
+
+| group | why |
+| :--- | :--- |
+| `small/` | domains small enough to enumerate exhaustively. **The early-termination opportunity.** |
+| `mid/` | finite but not trivially so — these decide where a budget boundary should sit |
+| `large/` | unbounded domains. **The regression guard**: an enumeration probe or deduplication bookkeeping is pure overhead here |
+| `filter/` | the rejection path, which deduplication and enumeration both have to handle |
+| `simplify/` | failing tests, so simplification cost rather than generation throughput |
+
+## The measurement that motivates exhaustive checking
+
+Cost scales linearly with the budget even when the domain has a single element:
+
+| benchmark | domain size | ms/test @ `--runs 100` | @ `--runs 1000` | scaling |
+| :--- | ---: | ---: | ---: | ---: |
+| `small/unit` | 1 | 0.0069 | 0.0492 | 7.1x |
+| `small/bool` | 2 | 0.0134 | 0.1077 | 8.0x |
+| `small/order` | 3 | 0.0207 | 0.1972 | 9.5x |
+| `small/pair-bool` | 4 | 0.0243 | 0.2094 | 8.6x |
+| `small/intRange-0-20` | 21 | 0.0166 | 0.1341 | 8.1x |
+| `large/string` | unbounded | 0.3016 | 2.9618 | 9.8x |
+| `large/list-int` | unbounded | 0.7599 | 8.2087 | 10.8x |
+
+`Fuzz.unit` has exactly one possible input and we test it a thousand times. The
+recoverable factor is `runs / domainSize`, so it grows without bound in whatever
+`--fuzz` the user passes — and unlike deduplicating already-tested runs, stopping
+early avoids *generating* the redundant values too, which is where the cost
+actually is.
+
+The `large/` rows scale linearly for real reasons and have nothing to recover.
+They're the rows to watch for regressions.
+
+## Notes on the implementation
+
+- **Headless, not browser-based.** This used to be an
+  [elm-explorations/benchmark](https://github.com/elm-explorations/benchmark)
+  browser program, which meant it ran in CI never and produced numbers only when
+  a human clicked something. The statistics here are simple enough to do in
+  `runner.mjs`.
+- **No library internals.** It used to destructure
+  `Test.Internal.ElmTestVariant__FuzzTest`, which broke when that variant changed
+  shape. It now uses the public `Test.Runner.fromTest`, whose
+  `run : () -> List Expectation` is a plain function — which is what makes it
+  benchmarkable, since `Test.RunnerV2.runFuzzTest` returns a `Task` and a Task
+  can't be timed from inside Elm.
+- **`source-directories` can't be used to pull in `../src`.** Applications aren't
+  allowed to import `Elm.Kernel.*` modules, so that approach stopped compiling as
+  soon as `RandomRun` moved into the kernel. Hence the local `ELM_HOME`, the same
+  trick `tests/` and `f-metric/` use.
+- `build.sh` clears `elm-stuff`, because Elm caches compiled dependency artifacts
+  per package *version* and the version never changes as `../src` is edited.
+  Without that, a build silently reuses a stale copy of the library.
+
+## Benchmarking a real test suite
+
+These microbenchmarks won't tell you what a fifty percent improvement here does
+to a real suite, where the test bodies do real work. To check that, point a real
+suite at your modified `src`:
+
+- In the suite's `elm.json`, remove the `elm-explorations/test` dependency, add
+  elm-test's own dependencies, and add the path to your `src` to
+  `source-directories`.
+- Run the suite once to compile, then time it.
+
+The library's own `tests/` suite works as an independent workload too: build once
+with `bash tests/run-tests.sh`, then time `node tests/elm.js` repeatedly. Don't
+use `NOCLEANUP=1` for that — same stale-artifact trap as above.
diff --git a/benchmarks/Snippets.elm b/benchmarks/Snippets.elm
index 6b885059..3be38bdf 100644
--- a/benchmarks/Snippets.elm
+++ b/benchmarks/Snippets.elm
@@ -1,7 +1,9 @@
 module Snippets exposing (..)
 
+import Dict
 import Expect exposing (Expectation)
 import Fuzz exposing (Fuzzer)
+import Set
 import Test exposing (Test, fuzz)
 
 
@@ -208,3 +210,132 @@ sequence fuzzers =
         (Fuzz.map2 (::))
         (Fuzz.constant [])
         fuzzers
+
+
+
+{- Passing tests over small, exhaustible domains. These are the ones exhaustive
+   checking should be able to finish early: the whole input space fits in far
+   fewer values than a typical `runs` budget.
+-}
+
+
+unitPass : Test
+unitPass =
+    fuzz "(passes) unit" Fuzz.unit <|
+        \_ -> Expect.pass
+
+
+orderPass : Test
+orderPass =
+    fuzz "(passes) order" Fuzz.order <|
+        \_ -> Expect.pass
+
+
+intRange0To20Pass : Test
+intRange0To20Pass =
+    fuzz "(passes) intRange 0 20" (Fuzz.intRange 0 20) <|
+        \_ -> Expect.pass
+
+
+pairBoolPass : Test
+pairBoolPass =
+    fuzz "(passes) pair of bools" (Fuzz.pair Fuzz.bool Fuzz.bool) <|
+        \_ -> Expect.pass
+
+
+maybeBoolPass : Test
+maybeBoolPass =
+    fuzz "(passes) maybe bool" (Fuzz.maybe Fuzz.bool) <|
+        \_ -> Expect.pass
+
+
+oneOfValuesPass : Test
+oneOfValuesPass =
+    fuzz "(passes) oneOfValues" (Fuzz.oneOfValues [ 1, 2, 3, 4, 5 ]) <|
+        \_ -> Expect.pass
+
+
+
+{- Finite, but big enough that exhausting it is a real decision rather than a
+   freebie.
+-}
+
+
+intRange0To1000Pass : Test
+intRange0To1000Pass =
+    fuzz "(passes) intRange 0 1000" (Fuzz.intRange 0 1000) <|
+        \_ -> Expect.pass
+
+
+pairIntRange0To30Pass : Test
+pairIntRange0To30Pass =
+    fuzz "(passes) pair of intRange 0 30"
+        (Fuzz.pair (Fuzz.intRange 0 30) (Fuzz.intRange 0 30))
+    <|
+        \_ -> Expect.pass
+
+
+
+{- Exercises the rejection path, which deduplication and enumeration both have
+   to handle. Kept generous: `Fuzz.filter` gives up after 16 consecutive
+   rejections and fails the test, and over thousands of runs even a mildly
+   selective predicate hits that.
+-}
+
+
+filterPass : Test
+filterPass =
+    fuzz "(passes) filtered intRange"
+        (Fuzz.intRange 0 100 |> Fuzz.filter (\n -> modBy 4 n /= 0))
+    <|
+        \_ -> Expect.pass
+
+
+
+{- Varying how much work the *test body* does, holding the fuzzer fixed.
+
+   The overhead of coverage tracking is largely per-run and fixed, so a heavier
+   body should dilute it. Early termination works the other way: skipping a run
+   skips its body too, so the heavier the body the bigger the saving. These pairs
+   measure both effects, which is what a real test suite with substantial
+   assertions would exercise.
+-}
+
+
+{-| An assertion with real work in it: round-trip the list through a Dict and
+compare, which allocates and compares structures rather than checking a tag.
+-}
+heavyAssertion : List Int -> Expect.Expectation
+heavyAssertion xs =
+    xs
+        |> List.map (\x -> ( x, String.fromInt x ))
+        |> Dict.fromList
+        |> Dict.toList
+        |> List.map Tuple.first
+        |> Expect.equal (xs |> Set.fromList |> Set.toList)
+
+
+listIntHeavyPass : Test
+listIntHeavyPass =
+    fuzz "(passes) list of int, heavy assertion" (Fuzz.list Fuzz.int) heavyAssertion
+
+
+boolHeavyPass : Test
+boolHeavyPass =
+    fuzz "(passes) bool, heavy assertion" Fuzz.bool <|
+        \b ->
+            heavyAssertion (List.range 0 60 |> List.filter (\n -> modBy 2 n == 0 || b))
+
+
+pairBoolHeavyPass : Test
+pairBoolHeavyPass =
+    fuzz "(passes) pair of bools, heavy assertion" (Fuzz.pair Fuzz.bool Fuzz.bool) <|
+        \( a, b ) ->
+            heavyAssertion (List.range 0 60 |> List.filter (\n -> modBy 2 n == 0 || a || b))
+
+
+stringHeavyPass : Test
+stringHeavyPass =
+    fuzz "(passes) string, heavy assertion" Fuzz.string <|
+        \s ->
+            heavyAssertion (String.toList s |> List.map Char.toCode)
diff --git a/benchmarks/build.sh b/benchmarks/build.sh
new file mode 100755
index 00000000..c273b118
--- /dev/null
+++ b/benchmarks/build.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+# Compiles the throughput benchmarks.
+#
+# Copies the library from ../src into a local ELM_HOME so we benchmark *this*
+# working copy rather than a published release. The old approach here -- putting
+# ../src on source-directories -- cannot work: applications aren't allowed to
+# import Elm.Kernel.* modules, so it stopped compiling as soon as RandomRun
+# moved into the kernel.
+#
+# Elm caches compiled dependency artifacts per package *version*, and the
+# version never changes as we edit ../src, so elm-stuff has to go too or the
+# build silently reuses a stale library.
+
+set -euo pipefail
+
+cd "${0%/*}"
+
+PACKAGE_NAME=$(grep '"name"' ../elm.json | cut -d \" -f4)
+PACKAGE_VERSION=$(grep '"version"' ../elm.json | cut -d \" -f4)
+ELM_HOME_DIR="elm_home"
+PACKAGE_PATH="${ELM_HOME_DIR}/0.19.2/packages/${PACKAGE_NAME}/${PACKAGE_VERSION}"
+
+rm -rf "${PACKAGE_PATH}" elm-stuff
+mkdir -p "${PACKAGE_PATH}"
+cp -r ../src "${PACKAGE_PATH}/src"
+cp ../elm.json ../README.md ../LICENSE "${PACKAGE_PATH}/"
+
+ELM_HOME="${ELM_HOME_DIR}" elm make Main.elm --output elm.js
+
+echo "Built benchmarks/elm.js"
diff --git a/benchmarks/elm.json b/benchmarks/elm.json
index 1946fe98..6342bad5 100644
--- a/benchmarks/elm.json
+++ b/benchmarks/elm.json
@@ -1,28 +1,21 @@
 {
     "type": "application",
     "source-directories": [
-        ".",
-        "../src"
+        "."
     ],
     "elm-version": "0.19.2",
     "dependencies": {
         "direct": {
-            "elm/bytes": "1.0.8",
             "elm/core": "1.0.5",
-            "elm/html": "1.0.0",
             "elm/json": "1.1.3",
             "elm/random": "1.0.0",
-            "elm-explorations/benchmark": "1.0.2"
+            "elm-explorations/test": "2.2.1"
         },
         "indirect": {
-            "BrianHicks/elm-trend": "2.1.3",
-            "elm/browser": "1.0.2",
-            "elm/regex": "1.0.0",
+            "elm/bytes": "1.0.8",
+            "elm/html": "1.0.0",
             "elm/time": "1.0.0",
-            "elm/url": "1.0.0",
-            "elm/virtual-dom": "1.0.2",
-            "mdgriffith/style-elements": "5.0.2",
-            "robinheghan/murmur3": "1.0.0"
+            "elm/virtual-dom": "1.0.2"
         }
     },
     "test-dependencies": {
diff --git a/benchmarks/runner.mjs b/benchmarks/runner.mjs
new file mode 100755
index 00000000..d1034c16
--- /dev/null
+++ b/benchmarks/runner.mjs
@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+// Drives the throughput benchmarks and reports runs/second.
+//
+// Usage:
+//   ./build.sh && node runner.mjs [options]
+//
+//   --runs N           fuzz runs per test (default 100, elm-test's own default).
+//                      Try 1000 too: for a small-domain fuzzer the cost should
+//                      grow with this, and shouldn't once exhaustive checking
+//                      can stop early.
+//   --reps N           timed repetitions per benchmark (default 5); the median
+//                      is reported
+//   --min-ms N         each repetition runs the test enough times to take at
+//                      least this long, so the timer isn't the limiting factor
+//                      (default 50)
+//   --filter REGEX     only run benchmarks whose name matches
+//   --seed N           fuzz seed (default 1)
+//   --label NAME       recorded in the output
+//   --out FILE         write the results as JSON
+//   --compare FILE     diff against a saved result file
+//   --markdown         emit markdown tables
+//
+// Reported as runs/sec (fuzz runs, not test invocations) so numbers stay
+// comparable across different --runs settings. For a fuzzer whose domain is
+// smaller than --runs, a future exhaustive implementation should show runs/sec
+// going *up* with --runs, because the extra budget costs nothing.
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+function fail(message) {
+  console.error(`benchmarks: ${message}`);
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const options = {
+    runs: 100,
+    reps: 5,
+    minMs: 50,
+    filter: null,
+    seed: 1,
+    label: "current",
+    out: null,
+    compare: null,
+    markdown: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => {
+      const v = argv[++i];
+      if (v === undefined) fail(`${arg} needs a value`);
+      return v;
+    };
+    const nextInt = () => {
+      const v = Number(next());
+      if (!Number.isInteger(v) || v < 0) fail(`${arg} needs a non-negative integer`);
+      return v;
+    };
+    switch (arg) {
+      case "--runs": options.runs = nextInt(); break;
+      case "--reps": options.reps = nextInt(); break;
+      case "--min-ms": options.minMs = nextInt(); break;
+      case "--seed": options.seed = nextInt(); break;
+      case "--filter": options.filter = new RegExp(next()); break;
+      case "--label": options.label = next(); break;
+      case "--out": options.out = next(); break;
+      case "--compare": options.compare = next(); break;
+      case "--markdown": options.markdown = true; break;
+      default: fail(`unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+
+function startElm() {
+  const require = createRequire(import.meta.url);
+  const elmPath = path.join(here, "elm.js");
+  if (!fs.existsSync(elmPath)) fail("elm.js not found -- run ./build.sh first");
+  const { Elm } = require(elmPath);
+  const app = Elm.Main.init();
+
+  let pending = null;
+  app.ports.toJs.subscribe((message) => {
+    const resolve = pending;
+    pending = null;
+    if (resolve === null) fail(`unexpected message: ${JSON.stringify(message)}`);
+    resolve(message);
+  });
+
+  return (request) =>
+    new Promise((resolve) => {
+      if (pending !== null) fail("request sent while another was in flight");
+      pending = resolve;
+      app.ports.fromJs.send(request);
+    });
+}
+
+// One timed repetition: `iterations` whole test executions, returning ms elapsed.
+// The Elm work happens synchronously inside the port handler, so the round trip
+// is the work plus a microtask -- negligible once a repetition takes >= minMs.
+async function timeOnce(send, index, options, iterations) {
+  const started = performance.now();
+  const result = await send({ tag: "run", index, runs: options.runs, seed: options.seed, iterations });
+  const elapsed = performance.now() - started;
+  if (result.tag !== "done") fail(`expected done, got ${JSON.stringify(result)}`);
+  return elapsed;
+}
+
+async function measure(options) {
+  const send = startElm();
+  const manifest = await send({ tag: "manifest" });
+  if (manifest.tag !== "manifest") fail(`expected a manifest, got ${JSON.stringify(manifest)}`);
+
+  const selected = manifest.benchmarks
+    .map((b, index) => ({ ...b, index }))
+    .filter(({ name }) => options.filter === null || options.filter.test(name));
+  if (selected.length === 0) fail("no benchmarks to run");
+
+  const results = [];
+  const startedAt = Date.now();
+  for (const { name, passes, index } of selected) {
+    // Grow the iteration count until a repetition clears --min-ms, so the timer
+    // resolution isn't what we're measuring. Also serves as warmup.
+    let iterations = 1;
+    while ((await timeOnce(send, index, options, iterations)) < options.minMs) {
+      iterations *= 2;
+      if (iterations > 1 << 22) break;
+    }
+
+    const samples = [];
+    for (let r = 0; r < options.reps; r++) {
+      samples.push(await timeOnce(send, index, options, iterations));
+    }
+    samples.sort((a, b) => a - b);
+    const medianMs = samples[Math.floor(samples.length / 2)];
+
+    results.push({
+      name,
+      passes,
+      iterations,
+      medianMs,
+      msPerTest: medianMs / iterations,
+      // Fuzz runs per second, comparable across --runs settings. Null for a
+      // failing test, which never executes its whole budget.
+      runsPerSec: passes ? (iterations * options.runs) / (medianMs / 1000) : null,
+      spreadPct: ((samples[samples.length - 1] - samples[0]) / medianMs) * 100,
+    });
+  }
+
+  return {
+    meta: {
+      label: options.label,
+      runs: options.runs,
+      reps: options.reps,
+      minMs: options.minMs,
+      seed: options.seed,
+      node: process.version,
+      startedAt: new Date(startedAt).toISOString(),
+      wallMs: Date.now() - startedAt,
+    },
+    results,
+  };
+}
+
+let MARKDOWN = false;
+
+function table(rows, headers, aligns) {
+  if (MARKDOWN) {
+    const esc = (c) => String(c).replace(/\|/g, "\\|");
+    const row = (cells) => `| ${cells.map(esc).join(" | ")} |`;
+    return [row(headers), `| ${aligns.map((a) => (a === "r" ? "---:" : ":---")).join(" | ")} |`, ...rows.map(row)].join("\n");
+  }
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r[i]).length)));
+  const line = (cells) =>
+    cells.map((c, i) => (aligns[i] === "r" ? String(c).padStart(widths[i]) : String(c).padEnd(widths[i]))).join("  ");
+  return [line(headers), line(widths.map((w) => "-".repeat(w))), ...rows.map(line)].join("\n");
+}
+
+function si(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return n.toFixed(0);
+}
+
+function report(run) {
+  const lines = [];
+  lines.push(
+    MARKDOWN
+      ? `## Throughput: ${run.meta.label}\n\n--runs ${run.meta.runs}, ${run.meta.reps} reps, ${(run.meta.wallMs / 1000).toFixed(1)}s wall.`
+      : `Throughput: ${run.meta.label} -- --runs ${run.meta.runs}, ${run.meta.reps} reps, ${(run.meta.wallMs / 1000).toFixed(1)}s wall`,
+  );
+  lines.push("");
+  lines.push(
+    table(
+      run.results.map((r) => [
+        r.name,
+        r.runsPerSec === null ? "n/a" : si(r.runsPerSec),
+        r.msPerTest.toFixed(4),
+        String(r.iterations),
+        `${r.spreadPct.toFixed(0)}%`,
+      ]),
+      ["benchmark", "runs/sec", "ms/test", "iters", "spread"],
+      ["l", "r", "r", "r", "r"],
+    ),
+  );
+  return lines.join("\n");
+}
+
+function compareReport(current, baseline) {
+  const byName = new Map(baseline.results.map((r) => [r.name, r]));
+  const rows = [];
+  const ratios = [];
+  for (const r of current.results) {
+    const b = byName.get(r.name);
+    if (b === undefined) {
+      rows.push([r.name, "new", r.msPerTest.toFixed(4), "-"]);
+      continue;
+    }
+    // Compare on ms/test, which is defined for passing and failing alike.
+    const ratio = b.msPerTest / r.msPerTest;
+    ratios.push(ratio);
+    rows.push([r.name, b.msPerTest.toFixed(4), r.msPerTest.toFixed(4), `${ratio.toFixed(2)}x`]);
+  }
+  const geo = ratios.length === 0 ? null : Math.exp(ratios.reduce((s, v) => s + Math.log(v), 0) / ratios.length);
+  const lines = [];
+  lines.push(MARKDOWN ? `## Throughput: ${current.meta.label} vs ${baseline.meta.label}` : `Throughput: ${current.meta.label} vs ${baseline.meta.label}`);
+  if (current.meta.runs !== baseline.meta.runs) {
+    lines.push(`WARNING: --runs differs (${current.meta.runs} vs ${baseline.meta.runs}); runs/sec is comparable but ms/test is not.`);
+  }
+  lines.push("");
+  lines.push(table(rows, ["benchmark", "ms/test (base)", "ms/test", "speedup"], ["l", "r", "r", "r"]));
+  lines.push("");
+  lines.push(`Geometric mean throughput ratio: ${geo === null ? "-" : geo.toFixed(3) + "x"} (> 1 is faster)`);
+  return lines.join("\n");
+}
+
+const options = parseArgs(process.argv.slice(2));
+MARKDOWN = options.markdown;
+
+const run = await measure(options);
+console.log(report(run));
+if (options.out !== null) {
+  fs.mkdirSync(path.dirname(options.out), { recursive: true });
+  fs.writeFileSync(options.out, JSON.stringify(run, null, 2) + "\n");
+  console.log(`\nWrote ${path.relative(process.cwd(), options.out)}`);
+}
+if (options.compare !== null) {
+  console.log("");
+  console.log(compareReport(run, JSON.parse(fs.readFileSync(options.compare, "utf8"))));
+}
diff --git a/elm.json b/elm.json
index 68b845ca..a46cfcbc 100644
--- a/elm.json
+++ b/elm.json
@@ -7,6 +7,7 @@
     "exposed-modules": [
         "Test",
         "Test.Runner",
+        "Test.RunnerV2",
         "Test.Runner.Failure",
         "Test.Distribution",
         "Expect",
diff --git a/f-metric/.gitignore b/f-metric/.gitignore
new file mode 100644
index 00000000..baa5287d
--- /dev/null
+++ b/f-metric/.gitignore
@@ -0,0 +1,4 @@
+elm-stuff/
+elm_home/
+elm.js
+results/
diff --git a/f-metric/README.md b/f-metric/README.md
new file mode 100644
index 00000000..86f5da7a
--- /dev/null
+++ b/f-metric/README.md
@@ -0,0 +1,302 @@
+# F-metric harness
+
+Measures how good elm-test is at **finding bugs**, as opposed to how fast it runs
+(that's `benchmarks/`).
+
+The corpus is a set of fuzz tests with deliberately injected defects. For each
+one, across many seeds, we record:
+
+| metric | why |
+| --- | --- |
+| **time to a minimal counterexample** | the headline. What the developer actually waits for: detection _and_ simplification. |
+| **cases to the defect** | the F-metric in its original sense: how many values the fuzzer generated before the property broke. Exact integers, and fully deterministic given the fixed seed list, so this is the axis with no measurement noise at all. |
+| **detection rate at the budget** | whether the defect was found at all within `runs`. A strategy that finds a bug in 3 cases instead of 10 000 has won nothing if it's slower in wall-clock terms — but a strategy that stops finding the bug at all has lost something real. Only `cache/truncated-key` is tuned to sit below 100%, which is what makes this column informative. |
+| **counterexample quality** | whether the value we report is the best possible one, plus the length and sum of the underlying `RandomRun` (the two components of the shortlex order that simplifying minimises). |
+
+Time is the headline because it's what a developer actually experiences, and the
+corpus shows why the two axes can't substitute for each other:
+`needle/int-in-range` takes 370 cases but 0.12 ms, while `challenge/deletion`
+takes 4 cases but 9 ms. Cases measure how well generation searches; time measures
+what that search costs. Read them together — and prefer cases when they
+disagree, because the case count is exact and the timings are not.
+
+## Running
+
+```sh
+cd f-metric
+./build.sh
+node runner.mjs --seeds 100
+```
+
+`./build.sh` copies `../src` into a local `ELM_HOME` and compiles against it, so
+you're always measuring the working copy. (The trick `benchmarks/` uses — putting
+`../src` on `source-directories` — cannot work, because applications aren't
+allowed to import `Elm.Kernel.*` modules. That's also why `benchmarks/` currently
+doesn't compile.)
+
+A 300-seed run over the default corpus takes about 30 seconds. `npm run f-metric`
+from the repo root does the build and run in one step. Adding `--shrink-only`
+makes it minutes rather than seconds, because `challenge/length-list` spends over
+a second per measurement simplifying a 100-element list.
+
+### Comparing two implementations
+
+```sh
+# on master
+./build.sh && node runner.mjs --seeds 100 --label before --save-summary /tmp/before.json
+
+# on your branch
+./build.sh && node runner.mjs --seeds 100 --label after --compare /tmp/before.json
+```
+
+The comparison prints per-case detection-rate and time deltas, plus a geometric
+mean of the time ratios (geometric, so that one slow case can't dominate).
+
+Add `--markdown` to any report or comparison to get GitHub-flavoured tables for
+pasting into a PR or issue.
+
+`baseline/` holds committed summaries (the small per-case aggregates, not the raw
+measurements) so you can diff against a known state without rerunning the other
+side. `pr260-random.json` is today's purely-random generation, 300 seeds, budget
+10 000, measured on an M-series Mac; `pr260-random-with-shrink.json` is the same
+with `--shrink-only` included. **Absolute times depend on the machine**, so
+for a real before/after, measure both sides yourself on one machine and use the
+committed baseline only as a sanity check on the shape of the results — mainly
+`found` and `optimal`, which are machine-independent.
+
+## Reading the output
+
+```
+case                        found  med cases  p75   med ms   p75 ms  optimal  |run|  sum(run)
+needle/int-in-range          100%        370  628     0.13     0.21     100%      2        43
+```
+
+- `found` — fraction of seeds that detected the defect within the budget.
+- `med cases` / `p75` — values generated before the property broke. **The
+  noise-free axis**: for a fixed seed list this is deterministic, so a change
+  here is entirely attributable to the change under test, with no need to argue
+  about measurement error.
+- `med ms` / `p75 ms` — time to a minimal counterexample, **among the seeds that
+  detected it**. A censored seed spent the entire budget and produced no
+  counterexample; averaging that in as if it were a time-to-failure would be
+  meaningless, so it isn't. Watch `found` and `med ms` together: a change that
+  halves the time while dropping `found` from 100% to 60% is a regression.
+- `optimal` — fraction of detections that reported the best possible
+  counterexample. `-` means we haven't written that case's optimum down.
+- `|run|`, `sum(run)` — median length and sum of the reported `RandomRun`. Lower
+  is a simpler counterexample. These work even for cases with no known optimum,
+  and they're directly comparable across strategies because they're the very
+  quantities simplifying tries to minimise.
+
+A case with `med cases` of 1 or 2 was falsified by the first value or two the
+fuzzer produced, so it measures *only* simplification cost, not search quality.
+Those cases are tagged `shrinkOnly` in the corpus and **excluded by default**;
+`--shrink-only` puts them back. Removing them took the default run from 204
+seconds to about 10 (at 100 seeds), almost all of it `challenge/length-list`.
+
+## Methodology, and how much to trust a number
+
+**The noise floor is measured, not guessed**, and the two axes are in completely
+different regimes.
+
+The **case count carries no noise at all**. Re-running an identical
+configuration gives a case ratio of exactly 1.000x on every single case, at 100
+and at 500 seeds — the seed list is fixed and generation is deterministic. Any
+movement in `cases` is real, with no error bars to argue about. This is the axis
+to compare on.
+
+The **detection rate carries no run-to-run noise either**, for the same reason:
+re-running gives byte-identical `found` values. But read it with one caveat the
+case ratio doesn't need — it's a proportion over 300 seeds, so its sampling error
+as an estimate of the *true* detection rate is about ±3 percentage points
+(1 s.e.). A 2-3 point difference between two implementations is real on this seed
+list but may not generalise; a 10 point difference is a result.
+
+The **times cannot be compared across process invocations to better than about
+±7%**, and more seeds do not fix it. Two back-to-back 500-seed runs of the
+identical configuration came out uniformly 0.86x–1.03x, clustered around 0.93x:
+not per-case scatter but a systematic whole-run drift, the second process simply
+running faster than the first. Within a run the times are fine; between runs
+they carry a bias you can't average away. Treat a time change under about 1.15x
+per case, or 1.1x in aggregate, as nothing.
+
+Cases whose median is under 0.5 ms are **excluded from the aggregate time ratio**
+and flagged with `*`, because a single `performance.now()` tick is a double-digit
+percentage of them — a 0.02 ms case reading 1.29x is not information. With the
+shrink-only cases excluded that removes 11 of 18 cases from the time aggregate,
+which leaves it resting on few enough cases to be fragile. Two consequences:
+compare on `cases`, and if you specifically care about *simplification* time, run
+with `--shrink-only`, since the slow cases all live there.
+
+Things the harness does to keep comparisons honest, and which you shouldn't
+undo:
+
+- **Fixed seeds.** Seeds come from a fixed xorshift32 sequence, so every run
+  measures the same seeds. Consecutive integers would be a poor choice —
+  `Random.initialSeed` does little mixing, so nearby seeds can correlate.
+- **Warmup.** The first few measurements of each case are discarded
+  (`--warmup`), so a case isn't penalised for being the one that triggered JIT
+  compilation.
+- **Seed-major ordering.** Cases are interleaved rather than run to completion
+  one at a time, so drift over a long run (thermal throttling, GC pressure) is
+  spread across all cases instead of landing on whichever case ran last.
+- **Same everything on both sides.** `--filter`, `--seeds`, `--warmup` and the
+  budget all affect measured times — a filtered run measures each case as much as
+  2.5x slower than the same case in a full run, purely because of how much other
+  code the JIT saw. The comparison warns about mismatched budgets and seed
+  counts, but it can't detect a mismatched `--filter`.
+- **Dev mode, which is also production.** We don't compile with `--optimize`,
+  and there's no option to. That isn't a readability compromise — it's what
+  node-test-runner does: `lib/ElmCompiler.js` only ever passes `--output` and
+  `--report json`. It has to, because under `--optimize` `Debug.toString`
+  returns `"<internals>"` for _every_ value, plain `Int` included, so every
+  counterexample elm-test reports would be unreadable. Dev mode is the
+  configuration real test suites run in, so these timings are representative of
+  it.
+
+Known quirks of the current corpus:
+
+- `cache/truncated-key` sits at **55% found** by design; everything else is at
+  100%. Without it the `found` column would be a constant and tell you nothing.
+  Its mask is tuned so a run collides with probability ~`28 / 2^19`, which over a
+  10 000-run budget lands about half the seeds either side — so the axis responds
+  in both directions. One mask bit is worth roughly a factor of two in `found`
+  (18 bits measured 80%, 19 bits 55%), so retune the mask, never this case's
+  budget, if it drifts to an extreme.
+- Everything else detects on every seed at the default budget. That's deliberate
+  headroom: `found` starts at 100% and has somewhere to fall if a change makes
+  generation worse.
+- `bst/delete-two-children` reports **1% optimal**. That's not a broken
+  expectation — simplifying reliably finds the right four-node *shape* but never
+  reduces the keys, stopping at `([5,0,7,6],5)` instead of `([1,0,3,2],1)`. It's
+  the most sensitive simplification signal in the default corpus, and the 1%
+  proves the target is reachable.
+- With `--shrink-only`, `challenge/coupling` (53% optimal) and
+  `structural/adjacent-dedupe` (32%) are the other two places simplifying
+  reliably stops short.
+
+## The corpus
+
+Every case is a fuzz test with one deliberately injected defect. Cases are tagged
+with a **role**: `Search` cases need the fuzzer to work to find the defect, so
+their case counts and times mean something; `ShrinkOnly` cases are falsified by
+the first value or two and only measure simplification, so they're excluded
+unless you pass `--shrink-only`.
+
+`src/Corpus/KnownBugs.elm` — data structures with one realistic mistake, and the
+cases that carry most of the F signal. Each needs a *sequence* of operations that
+interact, so no single value falsifies them:
+
+| case | the defect | source |
+| --- | --- | --- |
+| `bst/delete-two-children` | deleting a two-child node replaces it with the right *child's* key instead of the right *subtree's minimum* — the same thing exactly when that child has no left subtree | the BST suite in John Hughes, [_How to Specify It!_](https://research.chalmers.se/publication/508940) (2019) |
+| `rbt/missing-rotation` | Okasaki's `balance` with the left-right case removed; the other three still rebalance most insertions | Okasaki's red-black tree with the `balance` mutation set from [Etna](https://dl.acm.org/doi/10.1145/3591283) (Shi et al., PLDI 2023) |
+| `intervals/touching-merge` | interval merge tests `lo < previousHi` where it needs `<=`, so intervals meeting at exactly one point aren't merged | classic bug class, not one named incident |
+| `queue/missing-invariant` | Okasaki's batched queue where `pop` forgets to restore "front is empty only if the queue is", so a non-empty queue reports itself empty | classic bug class; the textbook motivation for model-based testing |
+| `cache/truncated-key` | a cache keys entries on the low 19 bits of a 24-bit id, so two distinct ids collide and one silently overwrites the other | classic bug class. Also the corpus's **only case that isn't always found** — see below |
+
+Two of these needed their input length bounded (`listOfLengthBetween 0 6`) to be
+worth measuring. With `Fuzz.list`'s ~16 elements, a random 16-key sequence almost
+always contains the trigger somewhere and the case is falsified by the very first
+value — bounding the size makes *finding* the trigger the work, which is the
+point, and it's how Etna's suites bound their inputs too.
+
+`src/Corpus/Combined.elm` — cases where part of the domain is tiny and part is
+huge, with the defect in the huge part. This is
+[#188](https://github.com/elm-explorations/test/issues/188)'s motivating shape:
+given `oneOf [map Err string, map Ok bool]`, half of every run is spent
+re-testing `Ok True` and `Ok False`, so a defect in the `Err` branch is found at
+half the rate it could be.
+
+The three cases vary exactly one thing each, so a measurement says *which*
+mechanism paid off rather than just that something did:
+
+| case | `Err` payload | choice tree | helped by |
+| :--- | :--- | :--- | :--- |
+| `combined/open-payload` | `Fuzz.string` | infinite | duplicate rejection, or a per-subtree hybrid. **Not** all-or-nothing enumeration, which abandons an infinite tree and changes nothing. |
+| `combined/finite-payload` | uniform `0..1023` | finite, 1026 leaves | plain exhaustive checking: guaranteed detection with zero variance |
+| `combined/wide-easy-branch` | same, but `Ok` has 201 leaves | finite, 1225 leaves | separates leaf-level dedup from subtree-level exhaustion — dedup must *observe* all 201 `Ok` runs first (~`201*H(201)` ≈ 1200 draws) where an enumerator knows when the branch is covered |
+
+`finite-payload` and `wide-easy-branch` have identical baselines by construction
+(`Fuzz.bool` and `intRange 0 200` both consume exactly one draw, so the `Err`
+sequence is bit-identical). They only diverge once a mechanism lands, which makes
+them a matched pair.
+
+`src/Corpus/Synthetic.elm` — cases shaped to probe one weakness each:
+
+| category | what it rewards |
+| --- | --- |
+| `needle` | systematically covering a small domain |
+| `boundary` | trying range edges and size edges deliberately |
+| `structural` | producing a required *shape* (a repeat, a nesting) rather than a value |
+| `deep` | reaching *large* inputs. **The category to watch** — anything that biases generation towards small inputs will look wonderful everywhere else and regress here. |
+| `filter` | the rejection path in the fuzz loop |
+
+`src/Corpus/ShrinkingChallenge.elm` — the
+[shrinking-challenge](https://github.com/jlink/shrinking-challenge) suite, ported
+from `tests/src/ShrinkingChallengeTests.elm`, which already encodes each
+challenge as (fuzzer, falsifiable property, known-optimal counterexample). Keep
+the two in sync. Seven of the twelve are `shrinkOnly`: they were designed to
+stress *simplifying*, not detection, so the first generated value falsifies them.
+The five that survive as search cases are `calculator`, `deletion` and the three
+`difference` variants.
+
+### Candidates not taken
+
+Worth recording so nobody re-derives the dead ends:
+
+- **Case-folding bugs** (the Turkish dotless `i`, German `ß` changing length
+  under `toUpper`) are a famous, security-adjacent class, but unreachable here:
+  `Fuzz.char` only draws from the full Unicode range 1/10 of the time, so a
+  specific code point is about 1e-7 per character. The case would be censored
+  forever and discriminate nothing.
+- **The TimSort `mergeCollapse` bug** (de Gouw et al. 2015, which broke Java and
+  Python) needs a specific run-length pattern across 60+ elements. Faithful
+  replication is a lot of code for an input no random fuzzer will reach.
+
+### Adding a case
+
+See the docs on `Corpus.Case.fails`. Briefly: the property must be falsifiable,
+the defect should be reachable but not trivially so, and `minima` should list the
+counterexamples you'd consider optimal (as `Debug.toString` renders them). Leave
+`minima` empty, run once, and read the `given` values out of the report to fill
+it in.
+
+Two traps, both of which this corpus hit:
+
+- **Make sure the defect is reachable at all.** `Fuzz.string` is
+  `stringOfLengthBetween 0 10`, so a property that only fails for strings longer
+  than 10 characters is never falsifiable — it looks like a hard case but it's an
+  impossible one. The report calls out cases that were never detected.
+- **Keep `Fuzz.filter` predicates generous.** `Fuzz.filter` fails the whole test
+  after 16 consecutive rejections, and over thousands of runs even a mildly
+  selective predicate will hit that. A predicate rejecting 76% of values fails
+  spuriously within a couple of thousand runs. Such a failure is _not_ a
+  detection, and the harness reports it separately as "failed for the wrong
+  reason" — that's what the `F-METRIC-VIOLATION` marker is for.
+
+## Where the case count comes from
+
+Reporting cases needs one number out of the library that wasn't previously
+reachable: `Test/Fuzz.elm` tracks `runsElapsed` in its loop state, but it only
+ever escaped to a runner inside a `DistributionReport`, i.e. only for tests that
+asked for a distribution. This branch threads it through `RunResult` and
+`Test.Expectation.FuzzTestFail` and exposes it as
+`Test.RunnerV2.getFuzzTestFailRunsElapsed`.
+
+That is a change to `src/`, and an addition to PR #260's public API, so it has to
+land with or after #260. It's deliberately minimal — one field, one getter, no
+behaviour change — and the existing 727-test suite passes unchanged.
+
+Two things worth knowing about the number:
+
+- It counts values *generated*, which includes ones the fuzzer rejected, so for
+  cases using `Fuzz.filter` it's larger than the number of values the property
+  actually saw. That's the right denominator for "how much work did the test
+  system do".
+- It can exceed the configured `runs`, because an `expectDistribution` test keeps
+  generating until its statistical check settles.
+
+An obvious follow-up, not done here: expose the same count for *passing* tests.
+It's free now that `RunResult` carries it, and it would let a runner say "this
+test actually ran 3072 times" for distribution-heavy tests.
diff --git a/f-metric/baseline/pr260-random-with-shrink.json b/f-metric/baseline/pr260-random-with-shrink.json
new file mode 100644
index 00000000..e39520c9
--- /dev/null
+++ b/f-metric/baseline/pr260-random-with-shrink.json
@@ -0,0 +1,607 @@
+{
+  "tag": "summary",
+  "meta": {
+    "label": "baseline-shrink",
+    "startedAt": "2026-09-29T16:28:29.750Z",
+    "wallMs": 678922,
+    "seeds": 300,
+    "warmup": 3,
+    "budget": 10000,
+    "shrinkOnly": true,
+    "node": "v22.22.2",
+    "cases": [
+      "bst/delete-two-children",
+      "rbt/missing-rotation",
+      "intervals/touching-merge",
+      "queue/missing-invariant",
+      "cache/truncated-key",
+      "combined/open-payload",
+      "combined/finite-payload",
+      "combined/wide-easy-branch",
+      "needle/int-in-range",
+      "needle/pair-diagonal",
+      "needle/exact-list",
+      "boundary/range-top",
+      "boundary/last-chunk",
+      "structural/adjacent-dedupe",
+      "structural/just-nothing",
+      "deep/list-sum",
+      "deep/big-int",
+      "deep/long-string",
+      "filter/multiple-of-four",
+      "challenge/reverse",
+      "challenge/large-union-list",
+      "challenge/calculator",
+      "challenge/length-list",
+      "challenge/difference1",
+      "challenge/difference2",
+      "challenge/difference3",
+      "challenge/bin-heap",
+      "challenge/coupling",
+      "challenge/deletion",
+      "challenge/distinct",
+      "challenge/nested-lists"
+    ],
+    "brokenCases": []
+  },
+  "cases": [
+    {
+      "name": "boundary/last-chunk",
+      "category": "boundary",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.10829149999699439,
+      "p25Ms": 0.05500000005122274,
+      "p75Ms": 0.330989749996661,
+      "medianCases": 1,
+      "p75Cases": 2,
+      "medianRunLength": 3,
+      "medianRunSum": 1,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "boundary/range-top",
+      "category": "boundary",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.019896000012522563,
+      "p25Ms": 0.01275000003806781,
+      "p75Ms": 0.03434349998860853,
+      "medianCases": 65.5,
+      "p75Cases": 142,
+      "medianRunLength": 1,
+      "medianRunSum": 100,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "bst/delete-two-children",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 1.4057080000056885,
+      "p25Ms": 1.1893644999872777,
+      "p75Ms": 1.6764164999767672,
+      "medianCases": 19,
+      "p75Cases": 41,
+      "medianRunLength": 10,
+      "medianRunSum": 75,
+      "optimalRate": 0.013333333333333334,
+      "censoredMs": null
+    },
+    {
+      "name": "cache/truncated-key",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 164,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.5466666666666666,
+      "medianMs": 32.91060400000424,
+      "p25Ms": 16.33945774997119,
+      "p75Ms": 54.24508350001997,
+      "medianCases": 3593,
+      "p75Cases": 6393,
+      "medianRunLength": 17,
+      "medianRunSum": 76,
+      "optimalRate": null,
+      "censoredMs": 79.80529149999347
+    },
+    {
+      "name": "challenge/bin-heap",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.8875835000071675,
+      "p25Ms": 0.668082999989565,
+      "p75Ms": 1.3041980000125477,
+      "medianCases": 1,
+      "p75Cases": 1,
+      "medianRunLength": 8,
+      "medianRunSum": 3,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/calculator",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 2.145749999966938,
+      "p25Ms": 1.504322249937104,
+      "p75Ms": 3.0741349999880185,
+      "medianCases": 3,
+      "p75Cases": 5,
+      "medianRunLength": 11,
+      "medianRunSum": 3,
+      "optimalRate": 0.9833333333333333,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/coupling",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 1.630916000023717,
+      "p25Ms": 1.135999999998603,
+      "p75Ms": 2.539186999980302,
+      "medianCases": 2,
+      "p75Cases": 4,
+      "medianRunLength": 5,
+      "medianRunSum": 3,
+      "optimalRate": 0.5733333333333334,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/deletion",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 9.74204149999423,
+      "p25Ms": 4.525291500031017,
+      "p75Ms": 15.789780750001228,
+      "medianCases": 4,
+      "p75Cases": 7,
+      "medianRunLength": 8,
+      "medianRunSum": 2,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/difference1",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.2845209999995859,
+      "p25Ms": 0.16507274998002686,
+      "p75Ms": 0.7209379999840166,
+      "medianCases": 220.5,
+      "p75Cases": 452.75,
+      "medianRunLength": 4,
+      "medianRunSum": 20,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/difference2",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.10962449997896329,
+      "p25Ms": 0.08446900006674696,
+      "p75Ms": 0.4373539999942295,
+      "medianCases": 31,
+      "p75Cases": 60,
+      "medianRunLength": 4,
+      "medianRunSum": 16,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/difference3",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.2117294999989099,
+      "p25Ms": 0.11541699998997501,
+      "p75Ms": 0.5862599999309168,
+      "medianCases": 124,
+      "p75Cases": 252.25,
+      "medianRunLength": 4,
+      "medianRunSum": 19,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/distinct",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.6823335000080988,
+      "p25Ms": 0.5415517499932321,
+      "p75Ms": 1.0057497500238242,
+      "medianCases": 1,
+      "p75Cases": 1,
+      "medianRunLength": 10,
+      "medianRunSum": 8,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/large-union-list",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 22.54014600002847,
+      "p25Ms": 8.13009374999092,
+      "p75Ms": 72.0059792500142,
+      "medianCases": 1,
+      "p75Cases": 1,
+      "medianRunLength": 18,
+      "medianRunSum": 20,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/length-list",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 1813.5789580000273,
+      "p25Ms": 599.1133849999605,
+      "p75Ms": 3250.0773752500045,
+      "medianCases": 2,
+      "p75Cases": 3,
+      "medianRunLength": 5,
+      "medianRunSum": 6909,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/nested-lists",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 10.321812000009231,
+      "p25Ms": 6.771999999997206,
+      "p75Ms": 19.08112525001343,
+      "medianCases": 1,
+      "p75Cases": 1,
+      "medianRunLength": 36,
+      "medianRunSum": 12,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/reverse",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.3842084999905637,
+      "p25Ms": 0.2614994999967166,
+      "p75Ms": 0.6669687499961583,
+      "medianCases": 1,
+      "p75Cases": 1,
+      "medianRunLength": 7,
+      "medianRunSum": 4,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "combined/finite-payload",
+      "category": "combined",
+      "n": 300,
+      "detected": 299,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.9966666666666667,
+      "medianMs": 0.4442080000007991,
+      "p25Ms": 0.17650000000503496,
+      "p75Ms": 0.9336665000300854,
+      "medianCases": 1307,
+      "p75Cases": 2638,
+      "medianRunLength": 3,
+      "medianRunSum": 38,
+      "optimalRate": null,
+      "censoredMs": 3.157915999996476
+    },
+    {
+      "name": "combined/open-payload",
+      "category": "combined",
+      "n": 300,
+      "detected": 286,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.9533333333333334,
+      "medianMs": 5.609395499996026,
+      "p25Ms": 3.0134690000049886,
+      "p75Ms": 10.082718749996275,
+      "medianCases": 2358.5,
+      "p75Cases": 4392.5,
+      "medianRunLength": 8,
+      "medianRunSum": 173,
+      "optimalRate": null,
+      "censoredMs": 18.838458499958506
+    },
+    {
+      "name": "combined/wide-easy-branch",
+      "category": "combined",
+      "n": 300,
+      "detected": 299,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.9966666666666667,
+      "medianMs": 0.4612080000224523,
+      "p25Ms": 0.18147899996620254,
+      "p75Ms": 0.9178960000026564,
+      "medianCases": 1307,
+      "p75Cases": 2638,
+      "medianRunLength": 3,
+      "medianRunSum": 38,
+      "optimalRate": null,
+      "censoredMs": 3.350458000000799
+    },
+    {
+      "name": "deep/big-int",
+      "category": "deep",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.23629149999760557,
+      "p25Ms": 0.1958539999977802,
+      "p75Ms": 0.28197924996493384,
+      "medianCases": 22,
+      "p75Cases": 44,
+      "medianRunLength": 2,
+      "medianRunSum": 2000015,
+      "optimalRate": null,
+      "censoredMs": null
+    },
+    {
+      "name": "deep/list-sum",
+      "category": "deep",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 24.402458500000648,
+      "p25Ms": 17.563333749993035,
+      "p75Ms": 33.00617700000021,
+      "medianCases": 3,
+      "p75Cases": 5,
+      "medianRunLength": 25,
+      "medianRunSum": 112,
+      "optimalRate": null,
+      "censoredMs": null
+    },
+    {
+      "name": "deep/long-string",
+      "category": "deep",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 48.79222900001332,
+      "p25Ms": 39.60070824998547,
+      "p75Ms": 59.523406249998516,
+      "medianCases": 3,
+      "p75Cases": 6,
+      "medianRunLength": 64,
+      "medianRunSum": 33,
+      "optimalRate": null,
+      "censoredMs": null
+    },
+    {
+      "name": "filter/multiple-of-four",
+      "category": "filter",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.045479000018531224,
+      "p25Ms": 0.03494774999217043,
+      "p75Ms": 0.060916749978787266,
+      "medianCases": 52,
+      "p75Cases": 98.5,
+      "medianRunLength": 1,
+      "medianRunSum": 42,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "intervals/touching-merge",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 1.0286869999981718,
+      "p25Ms": 0.71524999999383,
+      "p75Ms": 1.5888642499994603,
+      "medianCases": 11,
+      "p75Cases": 22,
+      "medianRunLength": 7,
+      "medianRunSum": 2,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "needle/exact-list",
+      "category": "needle",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.4541869999957271,
+      "p25Ms": 0.25803100004122825,
+      "p75Ms": 0.741885249997722,
+      "medianCases": 481,
+      "p75Cases": 914.5,
+      "medianRunLength": 7,
+      "medianRunSum": 9,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "needle/int-in-range",
+      "category": "needle",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.10256249999292777,
+      "p25Ms": 0.049750250022043474,
+      "p75Ms": 0.1695097499905387,
+      "medianCases": 330,
+      "p75Cases": 561,
+      "medianRunLength": 2,
+      "medianRunSum": 43,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "needle/pair-diagonal",
+      "category": "needle",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.02183300000615418,
+      "p25Ms": 0.015635750081855804,
+      "p75Ms": 0.032062750004115514,
+      "medianCases": 33,
+      "p75Cases": 66.5,
+      "medianRunLength": 2,
+      "medianRunSum": 0,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "queue/missing-invariant",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.6338749999995343,
+      "p25Ms": 0.5776039999909699,
+      "p75Ms": 0.7265312500094296,
+      "medianCases": 17,
+      "p75Cases": 32.25,
+      "medianRunLength": 11,
+      "medianRunSum": 6,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "rbt/missing-rotation",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.30118800001218915,
+      "p25Ms": 0.278406499999619,
+      "p75Ms": 0.34044724999694154,
+      "medianCases": 8,
+      "p75Cases": 16,
+      "medianRunLength": 7,
+      "medianRunSum": 6,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "structural/adjacent-dedupe",
+      "category": "structural",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.3761044999992009,
+      "p25Ms": 0.29159350000554696,
+      "p75Ms": 0.5079897500254447,
+      "medianCases": 1,
+      "p75Cases": 2,
+      "medianRunLength": 7,
+      "medianRunSum": 5,
+      "optimalRate": 0.31,
+      "censoredMs": null
+    },
+    {
+      "name": "structural/just-nothing",
+      "category": "structural",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.013792000005196314,
+      "p25Ms": 0.011792000026616734,
+      "p75Ms": 0.016593499967711978,
+      "medianCases": 4,
+      "p75Cases": 7,
+      "medianRunLength": 2,
+      "medianRunSum": 1,
+      "optimalRate": 1,
+      "censoredMs": null
+    }
+  ]
+}
diff --git a/f-metric/baseline/pr260-random.json b/f-metric/baseline/pr260-random.json
new file mode 100644
index 00000000..95c3c737
--- /dev/null
+++ b/f-metric/baseline/pr260-random.json
@@ -0,0 +1,436 @@
+{
+  "tag": "summary",
+  "meta": {
+    "label": "baseline",
+    "startedAt": "2026-09-29T15:24:30.032Z",
+    "wallMs": 46372,
+    "seeds": 300,
+    "warmup": 3,
+    "budget": 10000,
+    "shrinkOnly": false,
+    "node": "v22.22.2",
+    "cases": [
+      "bst/delete-two-children",
+      "rbt/missing-rotation",
+      "intervals/touching-merge",
+      "queue/missing-invariant",
+      "cache/truncated-key",
+      "combined/open-payload",
+      "combined/finite-payload",
+      "combined/wide-easy-branch",
+      "needle/int-in-range",
+      "needle/pair-diagonal",
+      "needle/exact-list",
+      "boundary/range-top",
+      "structural/just-nothing",
+      "deep/list-sum",
+      "deep/big-int",
+      "deep/long-string",
+      "filter/multiple-of-four",
+      "challenge/calculator",
+      "challenge/difference1",
+      "challenge/difference2",
+      "challenge/difference3",
+      "challenge/deletion"
+    ],
+    "brokenCases": []
+  },
+  "cases": [
+    {
+      "name": "boundary/range-top",
+      "category": "boundary",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.018667000000050393,
+      "p25Ms": 0.012020249998386134,
+      "p75Ms": 0.032531249998100975,
+      "medianCases": 65.5,
+      "p75Cases": 142,
+      "medianRunLength": 1,
+      "medianRunSum": 100,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "bst/delete-two-children",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 1.2941249999967113,
+      "p25Ms": 1.1184379999995144,
+      "p75Ms": 1.5594167499994,
+      "medianCases": 19,
+      "p75Cases": 41,
+      "medianRunLength": 10,
+      "medianRunSum": 75,
+      "optimalRate": 0.013333333333333334,
+      "censoredMs": null
+    },
+    {
+      "name": "cache/truncated-key",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 164,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.5466666666666666,
+      "medianMs": 30.17560400000002,
+      "p25Ms": 14.107968499999515,
+      "p75Ms": 50.42684350000127,
+      "medianCases": 3593,
+      "p75Cases": 6393,
+      "medianRunLength": 17,
+      "medianRunSum": 76,
+      "optimalRate": null,
+      "censoredMs": 71.06839599999967
+    },
+    {
+      "name": "challenge/calculator",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 2.1331255000004603,
+      "p25Ms": 1.4414064999995162,
+      "p75Ms": 2.9805102499976783,
+      "medianCases": 3,
+      "p75Cases": 5,
+      "medianRunLength": 11,
+      "medianRunSum": 3,
+      "optimalRate": 0.9833333333333333,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/deletion",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 8.972979500002111,
+      "p25Ms": 4.574343499999827,
+      "p75Ms": 15.16271924999728,
+      "medianCases": 4,
+      "p75Cases": 7,
+      "medianRunLength": 8,
+      "medianRunSum": 2,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/difference1",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.25743749999855936,
+      "p25Ms": 0.14927075000105106,
+      "p75Ms": 0.6639065000008486,
+      "medianCases": 220.5,
+      "p75Cases": 452.75,
+      "medianRunLength": 4,
+      "medianRunSum": 20,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/difference2",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.10377099999914208,
+      "p25Ms": 0.078989749998982,
+      "p75Ms": 0.4573232500008544,
+      "medianCases": 31,
+      "p75Cases": 60,
+      "medianRunLength": 4,
+      "medianRunSum": 16,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "challenge/difference3",
+      "category": "challenge",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.19149999999899592,
+      "p25Ms": 0.11370825000130935,
+      "p75Ms": 0.6018850000000384,
+      "medianCases": 124,
+      "p75Cases": 252.25,
+      "medianRunLength": 4,
+      "medianRunSum": 19,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "combined/finite-payload",
+      "category": "combined",
+      "n": 300,
+      "detected": 299,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.9966666666666667,
+      "medianMs": 0.39829199999803677,
+      "p25Ms": 0.1657294999986334,
+      "p75Ms": 0.8543335000003935,
+      "medianCases": 1307,
+      "p75Cases": 2638,
+      "medianRunLength": 3,
+      "medianRunSum": 38,
+      "optimalRate": null,
+      "censoredMs": 2.864541000000827
+    },
+    {
+      "name": "combined/open-payload",
+      "category": "combined",
+      "n": 300,
+      "detected": 286,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.9533333333333334,
+      "medianMs": 5.418645999997807,
+      "p25Ms": 2.928343999999015,
+      "p75Ms": 9.561395999999604,
+      "medianCases": 2358.5,
+      "p75Cases": 4392.5,
+      "medianRunLength": 8,
+      "medianRunSum": 173,
+      "optimalRate": null,
+      "censoredMs": 18.175187999998343
+    },
+    {
+      "name": "combined/wide-easy-branch",
+      "category": "combined",
+      "n": 300,
+      "detected": 299,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 0.9966666666666667,
+      "medianMs": 0.42129100000056496,
+      "p25Ms": 0.1757290000023204,
+      "p75Ms": 0.873145999999906,
+      "medianCases": 1307,
+      "p75Cases": 2638,
+      "medianRunLength": 3,
+      "medianRunSum": 38,
+      "optimalRate": null,
+      "censoredMs": 3.0880830000005517
+    },
+    {
+      "name": "deep/big-int",
+      "category": "deep",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.21627100000023347,
+      "p25Ms": 0.18139574999986507,
+      "p75Ms": 0.2626144999994722,
+      "medianCases": 22,
+      "p75Cases": 44,
+      "medianRunLength": 2,
+      "medianRunSum": 2000015,
+      "optimalRate": null,
+      "censoredMs": null
+    },
+    {
+      "name": "deep/list-sum",
+      "category": "deep",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 21.58362500000112,
+      "p25Ms": 17.099624500000118,
+      "p75Ms": 30.159198249997644,
+      "medianCases": 3,
+      "p75Cases": 5,
+      "medianRunLength": 25,
+      "medianRunSum": 112,
+      "optimalRate": null,
+      "censoredMs": null
+    },
+    {
+      "name": "deep/long-string",
+      "category": "deep",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 48.0745205000012,
+      "p25Ms": 37.533541499999956,
+      "p75Ms": 57.70166700000118,
+      "medianCases": 3,
+      "p75Cases": 6,
+      "medianRunLength": 64,
+      "medianRunSum": 33,
+      "optimalRate": null,
+      "censoredMs": null
+    },
+    {
+      "name": "filter/multiple-of-four",
+      "category": "filter",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.038646000000426284,
+      "p25Ms": 0.028583749999597785,
+      "p75Ms": 0.052958499999704145,
+      "medianCases": 52,
+      "p75Cases": 98.5,
+      "medianRunLength": 1,
+      "medianRunSum": 42,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "intervals/touching-merge",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.9421875000005002,
+      "p25Ms": 0.5922812499993597,
+      "p75Ms": 1.4249999999974534,
+      "medianCases": 11,
+      "p75Cases": 22,
+      "medianRunLength": 7,
+      "medianRunSum": 2,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "needle/exact-list",
+      "category": "needle",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.435770500000217,
+      "p25Ms": 0.24083300000256713,
+      "p75Ms": 0.7221567500009769,
+      "medianCases": 481,
+      "p75Cases": 914.5,
+      "medianRunLength": 7,
+      "medianRunSum": 9,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "needle/int-in-range",
+      "category": "needle",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.10043749999977081,
+      "p25Ms": 0.048583499999040214,
+      "p75Ms": 0.1642705000017486,
+      "medianCases": 330,
+      "p75Cases": 561,
+      "medianRunLength": 2,
+      "medianRunSum": 43,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "needle/pair-diagonal",
+      "category": "needle",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.02087500000197906,
+      "p25Ms": 0.014593750000130967,
+      "p75Ms": 0.03214575000038167,
+      "medianCases": 33,
+      "p75Cases": 66.5,
+      "medianRunLength": 2,
+      "medianRunSum": 0,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "queue/missing-invariant",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.5632704999989073,
+      "p25Ms": 0.5084167499999239,
+      "p75Ms": 0.6514377499979673,
+      "medianCases": 17,
+      "p75Cases": 32.25,
+      "medianRunLength": 11,
+      "medianRunSum": 6,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "rbt/missing-rotation",
+      "category": "known-bug",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.2899790000010398,
+      "p25Ms": 0.26837475000002087,
+      "p75Ms": 0.3357192500025121,
+      "medianCases": 8,
+      "p75Cases": 16,
+      "medianRunLength": 7,
+      "medianRunSum": 6,
+      "optimalRate": 1,
+      "censoredMs": null
+    },
+    {
+      "name": "structural/just-nothing",
+      "category": "structural",
+      "n": 300,
+      "detected": 300,
+      "errors": 0,
+      "errorDescription": null,
+      "detectionRate": 1,
+      "medianMs": 0.012145499998950982,
+      "p25Ms": 0.01074999999946158,
+      "p75Ms": 0.014500000000282398,
+      "medianCases": 4,
+      "p75Cases": 7,
+      "medianRunLength": 2,
+      "medianRunSum": 1,
+      "optimalRate": 1,
+      "censoredMs": null
+    }
+  ]
+}
diff --git a/f-metric/build.sh b/f-metric/build.sh
new file mode 100755
index 00000000..d38857ea
--- /dev/null
+++ b/f-metric/build.sh
@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# Compiles the F-metric harness.
+#
+# Like tests/run-tests.sh, this copies the library from ../src into a local
+# ELM_HOME so that the harness compiles against *this working copy* of
+# elm-explorations/test rather than a published release. (The trick
+# benchmarks/ uses -- putting ../src on source-directories -- can't work,
+# because applications aren't allowed to import Elm.Kernel.* modules.)
+#
+# Compiles in dev mode, deliberately and with no option to change it: that is
+# what node-test-runner does (lib/ElmCompiler.js only ever passes --output and
+# --report), and it has to, because under --optimize Debug.toString returns
+# "<internals>" for everything, so every counterexample elm-test reports would
+# be unreadable. Dev mode is the production configuration here, not a
+# compromise.
+#
+# With NOCLEANUP=1, keeps elm-stuff between builds. Faster, but only safe when
+# ../src hasn't changed.
+#
+# The local ELM_HOME is reused across builds. Delete f-metric/elm_home to
+# force a clean one (needs network access to repopulate).
+
+set -euo pipefail
+
+cd "${0%/*}"
+
+PACKAGE_NAME=$(grep '"name"' ../elm.json | cut -d \" -f4)
+PACKAGE_VERSION=$(grep '"version"' ../elm.json | cut -d \" -f4)
+ELM_HOME_DIR="elm_home"
+PACKAGE_PATH="${ELM_HOME_DIR}/0.19.2/packages/${PACKAGE_NAME}/${PACKAGE_VERSION}"
+
+echo "Copying the library from ../src to ${PACKAGE_PATH}"
+rm -rf "${PACKAGE_PATH}"
+# Elm caches compiled dependency artifacts per package *version*, and the
+# version never changes as we edit ../src, so without this the build silently
+# reuses a stale copy of the library.
+if [ -z "${NOCLEANUP+x}" ]; then
+  rm -rf elm-stuff
+fi
+mkdir -p "${PACKAGE_PATH}"
+cp -r ../src "${PACKAGE_PATH}/src"
+cp ../elm.json ../README.md ../LICENSE "${PACKAGE_PATH}/"
+
+echo "Compiling the harness"
+ELM_HOME="${ELM_HOME_DIR}" elm make src/Main.elm --output elm.js
+
+echo "Built f-metric/elm.js"
diff --git a/f-metric/elm.json b/f-metric/elm.json
new file mode 100644
index 00000000..4652309c
--- /dev/null
+++ b/f-metric/elm.json
@@ -0,0 +1,25 @@
+{
+    "type": "application",
+    "source-directories": [
+        "src"
+    ],
+    "elm-version": "0.19.2",
+    "dependencies": {
+        "direct": {
+            "elm/core": "1.0.5",
+            "elm/json": "1.1.3",
+            "elm/random": "1.0.0",
+            "elm-explorations/test": "2.2.1"
+        },
+        "indirect": {
+            "elm/bytes": "1.0.8",
+            "elm/html": "1.0.0",
+            "elm/time": "1.0.0",
+            "elm/virtual-dom": "1.0.2"
+        }
+    },
+    "test-dependencies": {
+        "direct": {},
+        "indirect": {}
+    }
+}
diff --git a/f-metric/runner.mjs b/f-metric/runner.mjs
new file mode 100755
index 00000000..8af80ddc
--- /dev/null
+++ b/f-metric/runner.mjs
@@ -0,0 +1,633 @@
+#!/usr/bin/env node
+
+// Drives the compiled Elm harness (elm.js) and turns raw measurements into a
+// report. All statistics live here rather than in Elm, so re-analysing a saved
+// run never needs a recompile.
+//
+// Usage:
+//   ./build.sh && node runner.mjs [options]
+//
+//   --seeds N          measurements per case (default 300)
+//   --budget N         max fuzz runs per measurement (default 10000).
+//                      A case can raise this for itself; both sides of a
+//                      comparison must use the same value.
+//   --filter REGEX     only run cases whose name matches
+//   --shrink-only      also run the cases that measure only simplification
+//                      (falsified by the first generated value, so they say
+//                      nothing about search quality and are off by default)
+//   --warmup N         discarded measurements per case, to let the JIT settle
+//                      (default 3)
+//   --label NAME       recorded in the output, shown in comparisons
+//   --out FILE         write JSONL here (default results/<label>-<timestamp>.jsonl)
+//   --save-summary F   also write the per-case aggregates as JSON. This is what
+//                      a committed baseline should be -- it's small, and
+//                      --compare accepts it.
+//   --summarize FILE   don't measure, just report on a saved JSONL or summary
+//   --compare FILE     report on this run and diff it against a saved
+//                      JSONL or summary
+//   --markdown         emit the report as GitHub-flavoured markdown tables,
+//                      for pasting into a PR or issue
+//   --quiet            no progress output
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+// ---------------------------------------------------------------- CLI
+
+function parseArgs(argv) {
+  const options = {
+    seeds: 300,
+    budget: 10000,
+    warmup: 3,
+    filter: null,
+    shrinkOnly: false,
+    label: "current",
+    out: null,
+    saveSummary: null,
+    summarize: null,
+    compare: null,
+    markdown: false,
+    quiet: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => {
+      const value = argv[++i];
+      if (value === undefined) {
+        fail(`${arg} needs a value`);
+      }
+      return value;
+    };
+    const nextInt = () => {
+      const value = Number(next());
+      if (!Number.isInteger(value) || value < 0) {
+        fail(`${arg} needs a non-negative integer`);
+      }
+      return value;
+    };
+    switch (arg) {
+      case "--seeds":
+        options.seeds = nextInt();
+        break;
+      case "--budget":
+        options.budget = nextInt();
+        break;
+      case "--warmup":
+        options.warmup = nextInt();
+        break;
+      case "--filter":
+        options.filter = new RegExp(next());
+        break;
+      case "--shrink-only":
+        options.shrinkOnly = true;
+        break;
+      case "--label":
+        options.label = next();
+        break;
+      case "--out":
+        options.out = next();
+        break;
+      case "--save-summary":
+        options.saveSummary = next();
+        break;
+      case "--summarize":
+        options.summarize = next();
+        break;
+      case "--compare":
+        options.compare = next();
+        break;
+      case "--markdown":
+        options.markdown = true;
+        break;
+      case "--quiet":
+        options.quiet = true;
+        break;
+      case "--help":
+      case "-h":
+        console.log(usage());
+        process.exit(0);
+        break;
+      default:
+        fail(`unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+
+function fail(message) {
+  console.error(`f-metric: ${message}`);
+  process.exit(1);
+}
+
+// The header comment block of this file (skipping the shebang).
+function usage() {
+  const body = [];
+  for (const line of fs.readFileSync(fileURLToPath(import.meta.url), "utf8").split("\n")) {
+    if (line.startsWith("#!")) continue;
+    if (line.startsWith("//")) {
+      body.push(line.replace(/^\/\/ ?/, ""));
+    } else if (body.length > 0) {
+      break;
+    }
+  }
+  return body.join("\n").trim();
+}
+
+// ---------------------------------------------------------------- seeds
+
+// A fixed xorshift32 sequence, so every run measures the same seeds and two
+// runs are directly comparable. Consecutive integers would be a bad choice:
+// elm/random's initialSeed does little mixing, so nearby seeds can correlate.
+function seedList(count) {
+  let state = 0x9e3779b9;
+  const seeds = [];
+  for (let i = 0; i < count; i++) {
+    state ^= state << 13;
+    state >>>= 0;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    state >>>= 0;
+    seeds.push(state);
+  }
+  return seeds;
+}
+
+// ---------------------------------------------------------------- Elm bridge
+
+function startElm() {
+  const require = createRequire(import.meta.url);
+  const elmPath = path.join(here, "elm.js");
+  if (!fs.existsSync(elmPath)) {
+    fail("elm.js not found -- run ./build.sh first");
+  }
+  const { Elm } = require(elmPath);
+  const app = Elm.Main.init();
+
+  let pending = null;
+  app.ports.toJs.subscribe((message) => {
+    const resolve = pending;
+    pending = null;
+    if (resolve === null) {
+      fail(`unexpected message from Elm: ${JSON.stringify(message)}`);
+    }
+    resolve(message);
+  });
+
+  return (request) =>
+    new Promise((resolve) => {
+      if (pending !== null) {
+        fail("sent a request while another was still in flight");
+      }
+      pending = resolve;
+      app.ports.fromJs.send(request);
+    });
+}
+
+// ---------------------------------------------------------------- measuring
+
+async function measureAll(options) {
+  const send = startElm();
+
+  const manifest = await send({ tag: "manifest" });
+  if (manifest.tag !== "manifest") {
+    fail(`expected a manifest, got ${JSON.stringify(manifest)}`);
+  }
+
+  const broken = manifest.cases.filter((c) => c.error !== null);
+  for (const c of broken) {
+    console.error(`f-metric: corpus case "${c.name}" is broken: ${c.error}`);
+  }
+
+  const cases = manifest.cases.filter(
+    (c) =>
+      c.error === null &&
+      (options.filter === null || options.filter.test(c.name)) &&
+      (options.shrinkOnly || c.role !== "shrinkOnly"),
+  );
+  const skipped = manifest.cases.filter((c) => c.error === null && c.role === "shrinkOnly").length;
+  if (!options.shrinkOnly && skipped > 0) {
+    console.error(
+      `f-metric: skipping ${skipped} shrink-only case(s); pass --shrink-only to include them`,
+    );
+  }
+  if (cases.length === 0) {
+    fail("no cases to measure");
+  }
+
+  const budgetFor = (c) => c.budget ?? options.budget;
+  const seeds = seedList(options.seeds);
+  const warmupSeeds = seedList(options.warmup + options.seeds).slice(options.seeds);
+
+  const total = cases.length * (options.seeds + options.warmup);
+  const showProgress = !options.quiet && process.stderr.isTTY;
+  let done = 0;
+  const progress = (what) => {
+    done++;
+    if (showProgress) {
+      process.stderr.write(`\r\u001b[Kf-metric: ${done}/${total} ${what}`);
+    }
+  };
+
+  // Warm up case by case, so each case's JIT state is settled before it is
+  // measured. Discard the results.
+  for (const c of cases) {
+    for (const seed of warmupSeeds) {
+      await send({ tag: "measure", index: c.index, seed, budget: budgetFor(c) });
+      progress(`warmup ${c.name}`);
+    }
+  }
+
+  // Measure seed-major, so that any drift over the run (thermal throttling, GC
+  // pressure) is spread across all cases instead of penalising whichever case
+  // happens to run last.
+  const measurements = [];
+  const startedAt = Date.now();
+  for (const seed of seeds) {
+    for (const c of cases) {
+      const result = await send({
+        tag: "measure",
+        index: c.index,
+        seed,
+        budget: budgetFor(c),
+      });
+      if (result.tag !== "measurement") {
+        fail(`expected a measurement, got ${JSON.stringify(result)}`);
+      }
+      measurements.push(result);
+      progress(c.name);
+    }
+  }
+  if (showProgress) process.stderr.write("\r\u001b[K");
+
+  return {
+    meta: {
+      label: options.label,
+      startedAt: new Date(startedAt).toISOString(),
+      wallMs: Date.now() - startedAt,
+      seeds: options.seeds,
+      warmup: options.warmup,
+      budget: options.budget,
+      shrinkOnly: options.shrinkOnly,
+      node: process.version,
+      cases: cases.map((c) => c.name),
+      brokenCases: broken.map((c) => ({ name: c.name, error: c.error })),
+    },
+    measurements,
+  };
+}
+
+// ---------------------------------------------------------------- statistics
+
+function quantile(sorted, q) {
+  if (sorted.length === 0) return null;
+  const position = (sorted.length - 1) * q;
+  const low = Math.floor(position);
+  const high = Math.ceil(position);
+  if (low === high) return sorted[low];
+  return sorted[low] + (sorted[high] - sorted[low]) * (position - low);
+}
+
+function summarize(run) {
+  const byCase = new Map();
+  for (const m of run.measurements) {
+    if (!byCase.has(m.name)) {
+      byCase.set(m.name, { name: m.name, category: m.category, all: [] });
+    }
+    byCase.get(m.name).all.push(m);
+  }
+
+  const cases = [...byCase.values()].map((entry) => {
+    const detected = entry.all.filter((m) => m.status === "detected");
+    const errors = entry.all.filter((m) => m.status === "error");
+    const times = detected.map((m) => m.durationMs).sort((a, b) => a - b);
+    const caseCounts = detected.map((m) => m.cases).sort((a, b) => a - b);
+    const lengths = detected.map((m) => m.runLength).sort((a, b) => a - b);
+    const sums = detected.map((m) => m.runSum).sort((a, b) => a - b);
+    const scored = detected.filter((m) => m.optimal !== null && m.optimal !== undefined);
+    return {
+      name: entry.name,
+      category: entry.category,
+      n: entry.all.length,
+      detected: detected.length,
+      errors: errors.length,
+      errorDescription: errors.length > 0 ? errors[0].description : null,
+      detectionRate: detected.length / entry.all.length,
+      // Only among detections: the time a censored run took is the budget, not
+      // a time-to-failure, so averaging it in would be meaningless.
+      medianMs: quantile(times, 0.5),
+      p25Ms: quantile(times, 0.25),
+      p75Ms: quantile(times, 0.75),
+      // The F-metric proper: values generated before the defect surfaced.
+      // Exact integers, so unlike the times these carry no timer noise.
+      medianCases: quantile(caseCounts, 0.5),
+      p75Cases: quantile(caseCounts, 0.75),
+      medianRunLength: quantile(lengths, 0.5),
+      medianRunSum: quantile(sums, 0.5),
+      optimalRate: scored.length === 0 ? null : scored.filter((m) => m.optimal).length / scored.length,
+      // What a censored run costs the developer: the full budget, spent for nothing.
+      censoredMs: quantile(
+        entry.all.filter((m) => m.status === "notDetected").map((m) => m.durationMs).sort((a, b) => a - b),
+        0.5,
+      ),
+    };
+  });
+
+  cases.sort((a, b) => a.name.localeCompare(b.name));
+
+  return withCategories({ meta: run.meta, cases });
+}
+
+function withCategories(summary) {
+  const byCategory = new Map();
+  for (const c of summary.cases) {
+    if (!byCategory.has(c.category)) byCategory.set(c.category, []);
+    byCategory.get(c.category).push(c);
+  }
+  return { ...summary, byCategory };
+}
+
+function geometricMean(values) {
+  const usable = values.filter((v) => Number.isFinite(v) && v > 0);
+  if (usable.length === 0) return null;
+  return Math.exp(usable.reduce((sum, v) => sum + Math.log(v), 0) / usable.length);
+}
+
+// ---------------------------------------------------------------- reporting
+
+function fmt(value, digits = 2) {
+  if (value === null || value === undefined) return "-";
+  return value.toFixed(digits);
+}
+
+function pct(value) {
+  if (value === null || value === undefined) return "-";
+  return `${(value * 100).toFixed(0)}%`;
+}
+
+// Set by --markdown. Affects table rendering and section headings only; the
+// numbers are identical either way.
+let MARKDOWN = false;
+
+function table(rows, headers, aligns) {
+  if (MARKDOWN) {
+    // `|run|` as a header would otherwise end the cell early.
+    const escape = (cell) => String(cell).replace(/\|/g, "\\|");
+    const row = (cells) => `| ${cells.map(escape).join(" | ")} |`;
+    return [
+      row(headers),
+      `| ${aligns.map((a) => (a === "r" ? "---:" : ":---")).join(" | ")} |`,
+      ...rows.map(row),
+    ].join("\n");
+  }
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => String(r[i]).length)),
+  );
+  const line = (cells) =>
+    cells
+      .map((cell, i) => (aligns[i] === "r" ? String(cell).padStart(widths[i]) : String(cell).padEnd(widths[i])))
+      .join("  ");
+  return [line(headers), line(widths.map((w) => "-".repeat(w))), ...rows.map(line)].join("\n");
+}
+
+function heading(text) {
+  return MARKDOWN ? `### ${text}` : `${text}:`;
+}
+
+function note(text) {
+  return MARKDOWN ? `> ${text}` : text;
+}
+
+function report(summary) {
+  const lines = [];
+  lines.push(
+    MARKDOWN
+      ? `## F-metric: ${summary.meta.label}\n\n${summary.meta.seeds} seeds/case, budget ${summary.meta.budget}, ${(summary.meta.wallMs / 1000).toFixed(1)}s wall${summary.meta.shrinkOnly ? ", shrink-only cases included" : ""}.`
+      : `F-metric: ${summary.meta.label} -- ${summary.meta.seeds} seeds/case, budget ${summary.meta.budget}, ${(summary.meta.wallMs / 1000).toFixed(1)}s wall`,
+  );
+  lines.push("");
+  lines.push(
+    table(
+      summary.cases.map((c) => [
+        c.name,
+        pct(c.detectionRate),
+        fmt(c.medianCases, 0),
+        fmt(c.p75Cases, 0),
+        fmt(c.medianMs),
+        fmt(c.p75Ms),
+        c.optimalRate === null ? "-" : pct(c.optimalRate),
+        fmt(c.medianRunLength, 0),
+        fmt(c.medianRunSum, 0),
+      ]),
+      ["case", "found", "med cases", "p75", "med ms", "p75 ms", "optimal", "|run|", "sum(run)"],
+      ["l", "r", "r", "r", "r", "r", "r", "r", "r"],
+    ),
+  );
+  lines.push("");
+  lines.push(heading("By category"));
+  lines.push(
+    table(
+      [...summary.byCategory.entries()].map(([category, cases]) => [
+        category,
+        String(cases.length),
+        pct(cases.reduce((sum, c) => sum + c.detectionRate, 0) / cases.length),
+        fmt(geometricMean(cases.map((c) => c.medianCases)), 0),
+        fmt(geometricMean(cases.map((c) => c.medianMs))),
+      ]),
+      ["category", "cases", "mean found", "geomean cases", "geomean med ms"],
+      ["l", "r", "r", "r", "r"],
+    ),
+  );
+
+  const useless = summary.cases.filter((c) => c.detected === 0);
+  if (useless.length > 0) {
+    lines.push("");
+    lines.push(
+      note(
+        `Never detected at this budget (these cases can't distinguish anything -- raise the budget or make them easier): ${useless.map((c) => c.name).join(", ")}`,
+      ),
+    );
+  }
+  const errored = summary.cases.filter((c) => c.errors > 0);
+  if (errored.length > 0) {
+    lines.push("");
+    lines.push(heading("Cases that failed for the wrong reason (not a detection -- fix the case)"));
+    for (const c of errored) {
+      lines.push(`  ${c.name}: ${c.errors}/${c.n} -- ${c.errorDescription}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// Medians below this are at the resolution limit of performance.now(): a single
+// timer tick is a double-digit percentage of them, so they get excluded from the
+// aggregate time ratio (and flagged in the table) rather than being allowed to
+// masquerade as signal. Their case-count ratios are still exact and still count.
+//
+// The test is on the *baseline* median alone, deliberately. Gating on either side
+// would let the excluded set shift as the variant's own timings move, and then
+// two variants measured against the same baseline would have their geomeans
+// computed over different sets of cases -- which is not a comparison.
+const TIME_FLOOR_MS = 0.5;
+
+function compareReport(current, baseline) {
+  const baselineByName = new Map(baseline.cases.map((c) => [c.name, c]));
+  const rows = [];
+  const timeRatios = [];
+  const caseRatios = [];
+  let belowFloor = 0;
+  for (const c of current.cases) {
+    const b = baselineByName.get(c.name);
+    if (b === undefined) {
+      rows.push([c.name, "new", "-", "-", "-", "-", "-", "-"]);
+      continue;
+    }
+    const comparable = c.detected > 0 && b.detected > 0;
+    const ratioOf = (now, before) => (before !== null && now !== null && before > 0 ? now / before : null);
+
+    const caseRatio = ratioOf(c.medianCases, b.medianCases);
+    if (caseRatio !== null && comparable) caseRatios.push(caseRatio);
+
+    const timeRatio = ratioOf(c.medianMs, b.medianMs);
+    const atFloor = (b.medianMs ?? 0) < TIME_FLOOR_MS;
+    if (timeRatio !== null && comparable) {
+      if (atFloor) belowFloor++;
+      else timeRatios.push(timeRatio);
+    }
+
+    rows.push([
+      c.name,
+      pct(b.detectionRate),
+      pct(c.detectionRate),
+      fmt(b.medianCases, 0),
+      fmt(c.medianCases, 0),
+      caseRatio === null ? "-" : `${caseRatio.toFixed(2)}x`,
+      `${fmt(b.medianMs)} -> ${fmt(c.medianMs)}`,
+      timeRatio === null ? "-" : `${timeRatio.toFixed(2)}x${atFloor ? " *" : ""}`,
+    ]);
+  }
+
+  const currentNames = new Set(current.cases.map((c) => c.name));
+  const gone = baseline.cases.filter((c) => !currentNames.has(c.name)).map((c) => c.name);
+
+  const lines = [];
+  lines.push(
+    MARKDOWN
+      ? `## Comparison: ${current.meta.label} vs ${baseline.meta.label}`
+      : `Comparison: ${current.meta.label} vs ${baseline.meta.label}`,
+  );
+  if (current.meta.budget !== baseline.meta.budget) {
+    lines.push(
+      `WARNING: budgets differ (${current.meta.budget} vs ${baseline.meta.budget}). Detection rates are not comparable.`,
+    );
+  }
+  if (current.meta.seeds !== baseline.meta.seeds) {
+    lines.push(`NOTE: seed counts differ (${current.meta.seeds} vs ${baseline.meta.seeds}).`);
+  }
+  if (gone.length > 0) {
+    lines.push(`NOTE: in the baseline but not measured here: ${gone.join(", ")}`);
+  }
+  lines.push("");
+  lines.push(
+    table(
+      rows,
+      ["case", "found (base)", "found", "cases (base)", "cases", "cases ratio", "ms (base -> now)", "time"],
+      ["l", "r", "r", "r", "r", "r", "r", "r"],
+    ),
+  );
+  lines.push("");
+
+  const caseGeo = geometricMean(caseRatios);
+  lines.push(
+    `Geometric mean CASE ratio over ${caseRatios.length} comparable cases: ${caseGeo === null ? "-" : caseGeo.toFixed(3) + "x"} (< 1 means fewer values generated to find the bug)`,
+  );
+  const geo = geometricMean(timeRatios);
+  lines.push(
+    `Geometric mean TIME ratio over ${timeRatios.length} comparable cases: ${geo === null ? "-" : geo.toFixed(3) + "x"} (< 1 is faster)`,
+  );
+  if (belowFloor > 0) {
+    lines.push(
+      `  (* ${belowFloor} case(s) excluded from the time ratio: median under ${TIME_FLOOR_MS}ms is at the timer's resolution limit. Their case ratios are still included.)`,
+    );
+  }
+  const detectionDelta =
+    current.cases.reduce((sum, c) => sum + c.detectionRate, 0) / current.cases.length -
+    baseline.cases.reduce((sum, c) => sum + c.detectionRate, 0) / baseline.cases.length;
+  lines.push(`Mean detection rate change: ${(detectionDelta * 100).toFixed(1)} percentage points (> 0 is better)`);
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------- JSONL
+
+function writeJsonl(file, run) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const lines = [JSON.stringify({ tag: "meta", ...run.meta })];
+  for (const m of run.measurements) lines.push(JSON.stringify(m));
+  fs.writeFileSync(file, lines.join("\n") + "\n");
+}
+
+function readJsonl(file) {
+  const parsed = fs
+    .readFileSync(file, "utf8")
+    .split("\n")
+    .filter((line) => line.trim() !== "")
+    .map((line) => JSON.parse(line));
+  const meta = parsed.find((entry) => entry.tag === "meta");
+  if (meta === undefined) fail(`${file} has no meta line`);
+  return { meta, measurements: parsed.filter((entry) => entry.tag === "measurement") };
+}
+
+function writeSummary(file, summary) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(
+    file,
+    JSON.stringify({ tag: "summary", meta: summary.meta, cases: summary.cases }, null, 2) + "\n",
+  );
+}
+
+// Accepts either a raw JSONL run or a saved summary, so a committed baseline can
+// be the small summary rather than thousands of measurement lines.
+function loadSummary(file) {
+  const text = fs.readFileSync(file, "utf8");
+  if (text.trimStart().startsWith("{") && text.includes('"tag": "summary"')) {
+    return withCategories(JSON.parse(text));
+  }
+  return summarize(readJsonl(file));
+}
+
+// ---------------------------------------------------------------- main
+
+const options = parseArgs(process.argv.slice(2));
+MARKDOWN = options.markdown;
+
+if (options.summarize !== null) {
+  const summary = loadSummary(options.summarize);
+  console.log(report(summary));
+  if (options.saveSummary !== null) writeSummary(options.saveSummary, summary);
+  if (options.compare !== null) {
+    console.log("");
+    console.log(compareReport(summary, loadSummary(options.compare)));
+  }
+} else {
+  const run = await measureAll(options);
+  const out =
+    options.out ??
+    path.join(here, "results", `${options.label}-${run.meta.startedAt.replace(/[:.]/g, "-")}.jsonl`);
+  writeJsonl(out, run);
+  const summary = summarize(run);
+  console.log(report(summary));
+  console.log("");
+  console.log(`Wrote ${path.relative(process.cwd(), out)}`);
+  if (options.saveSummary !== null) {
+    writeSummary(options.saveSummary, summary);
+    console.log(`Wrote ${path.relative(process.cwd(), options.saveSummary)}`);
+  }
+  if (options.compare !== null) {
+    console.log("");
+    console.log(compareReport(summary, loadSummary(options.compare)));
+  }
+}
diff --git a/f-metric/src/Corpus.elm b/f-metric/src/Corpus.elm
new file mode 100644
index 00000000..fff83312
--- /dev/null
+++ b/f-metric/src/Corpus.elm
@@ -0,0 +1,19 @@
+module Corpus exposing (all)
+
+{-| The whole F-metric corpus. See `Corpus.Case` for what an entry is and how to
+add one.
+-}
+
+import Corpus.Case exposing (Case)
+import Corpus.Combined
+import Corpus.KnownBugs
+import Corpus.ShrinkingChallenge
+import Corpus.Synthetic
+
+
+all : List Case
+all =
+    Corpus.KnownBugs.cases
+        ++ Corpus.Combined.cases
+        ++ Corpus.Synthetic.cases
+        ++ Corpus.ShrinkingChallenge.cases
diff --git a/f-metric/src/Corpus/Case.elm b/f-metric/src/Corpus/Case.elm
new file mode 100644
index 00000000..73aaf86d
--- /dev/null
+++ b/f-metric/src/Corpus/Case.elm
@@ -0,0 +1,110 @@
+module Corpus.Case exposing (Case, Role(..), fails, shrinkOnly, violation)
+
+{-| A single F-metric corpus entry: a fuzz test that is _known to fail_, because
+a defect has been deliberately injected into the property.
+
+For each case we measure how long the test system takes to uncover the defect,
+and how good the counterexample it reports is. See `README.md`.
+
+
+## Adding a case
+
+Use [`fails`](#fails). Three things matter:
+
+1.  The property must genuinely fail for _some_ inputs, otherwise the case is
+    only ever recorded as "not detected" and tells us nothing.
+2.  The defect should be reachable but not trivial. If every seed finds it on
+    the first run, the case can't distinguish two generation strategies.
+3.  `minima` should list every acceptable "best possible" counterexample, as
+    rendered by `Debug.toString`. Leave it empty if you don't know them — you
+    lose the counterexample-quality score for that case but nothing else.
+
+Then run the tool and look at `med cases`. If it's 1 or 2, the very first values
+the fuzzer produced already falsify the property, so the case says nothing about
+how well generation searches — mark it [`shrinkOnly`](#shrinkOnly).
+
+The easiest way to fill in `minima` is to leave it empty, run the tool once and
+look at the `given` values it reports.
+
+-}
+
+import Expect
+import Fuzz exposing (Fuzzer)
+import Test exposing (Test)
+
+
+{-| What a case is actually able to measure.
+
+`Search` cases need the fuzzer to work to find the defect, so their case counts
+and times mean something. `ShrinkOnly` cases are falsified by the first value or
+two; all their cost is simplification, so including them in an F aggregate just
+dilutes it. They're still worth keeping for the `optimal` score — that's the only
+place we measure simplification quality across many seeds rather than one — but
+they're excluded from runs by default.
+
+-}
+type Role
+    = Search
+    | ShrinkOnly
+
+
+type alias Case =
+    { name : String
+    , category : String
+    , role : Role
+
+    {- `Debug.toString` renderings of the counterexamples we'd consider optimal.
+       Empty means "we don't know", which disables the quality score for this case.
+    -}
+    , minima : List String
+
+    {- Overrides the harness-wide budget. Only for cases that are hopeless at
+       the default budget; both sides of a comparison must use the same value.
+    -}
+    , budget : Maybe Int
+    , test : Test
+    }
+
+
+{-| The marker we fail with, so that the harness can tell "the property was
+violated, as intended" apart from "this case is broken" (an invalid fuzzer, too
+many filtered values, a runtime exception, ...).
+-}
+violation : String
+violation =
+    "F-METRIC-VIOLATION"
+
+
+{-| Build a corpus case out of a fuzzer and a property that it can falsify.
+-}
+fails :
+    { name : String
+    , category : String
+    , minima : List String
+    , budget : Maybe Int
+    }
+    -> Fuzzer a
+    -> (a -> Bool)
+    -> Case
+fails config fuzzer property =
+    { name = config.name
+    , category = config.category
+    , role = Search
+    , minima = config.minima
+    , budget = config.budget
+    , test =
+        Test.fuzz config.name fuzzer <|
+            \value ->
+                if property value then
+                    Expect.pass
+
+                else
+                    Expect.fail violation
+    }
+
+
+{-| Mark a case as measuring only simplification, not search. See [`Role`](#Role).
+-}
+shrinkOnly : Case -> Case
+shrinkOnly case_ =
+    { case_ | role = ShrinkOnly }
diff --git a/f-metric/src/Corpus/Combined.elm b/f-metric/src/Corpus/Combined.elm
new file mode 100644
index 00000000..5ff4a099
--- /dev/null
+++ b/f-metric/src/Corpus/Combined.elm
@@ -0,0 +1,164 @@
+module Corpus.Combined exposing (cases)
+
+{-| Cases where part of the input domain is tiny and part of it is huge, and the
+defect lives in the huge part.
+
+This is the shape that makes exhaustive checking and duplicate rejection worth
+having, and it's the motivating example from
+<https://github.com/elm-explorations/test/issues/188>: given
+
+    Fuzz.oneOf
+        [ Fuzz.map Err Fuzz.string
+        , Fuzz.map Ok Fuzz.bool
+        ]
+
+`oneOf` splits its runs evenly, so half of them go on re-testing `Ok True` and
+`Ok False` over and over. A defect confined to the `Err` branch is therefore
+found at half the rate it could be, and getting the `Ok` side out of the way
+should roughly halve F.
+
+The three cases below differ in exactly the way that separates the candidate
+implementations, so the numbers say _which_ mechanism paid off:
+
+  - `combined/open-payload` — the `Err` payload is `Fuzz.string`, so the choice
+    tree is **infinite**. All-or-nothing enumeration can't help: it hits its node
+    budget and falls back to sampling. Only per-run duplicate rejection (#207) or
+    a per-subtree hybrid can win here.
+  - `combined/finite-payload` — the `Err` payload is a bounded uniform int, so
+    the whole tree is **finite and enumerable**. Plain exhaustive checking should
+    win outright, and by more than 2x: it never repeats an input at all.
+  - `combined/wide-easy-branch` — like `finite-payload`, but the easy branch has
+    201 leaves instead of 2. This is the case where leaf-level dedup and
+    subtree-level reasoning should come apart. Dedup has to _observe_ all 201
+    distinct `Ok` runs before it stops wasting work, which by coupon-collector is
+    about `201 * H(201)` ~ 1200 `Ok` draws; an enumerator that tracks exhausted
+    subtrees knows the branch is finished as soon as it has covered it.
+
+All three share the same `Err` payload size, so their baseline F is comparable
+and a change can be read across the row.
+
+-}
+
+import Corpus.Case as Case exposing (Case)
+import Fuzz exposing (Fuzzer)
+
+
+cases : List Case
+cases =
+    [ openPayload
+    , finitePayload
+    , wideEasyBranch
+    ]
+
+
+{-| A uniform integer in `0..1023`.
+
+Built from two sub-255 draws so it stays uniform: `Fuzz.intRange` buckets above
+255 and the odds of hitting a particular value stop being analytic. With 1024
+equally likely payloads and `oneOf` giving the `Err` branch half the runs, the
+per-run detection probability is `0.5 / 1024`, so F should sit around 2048 --
+comfortably inside a 10 000 budget, and far enough above the noise that a 2x
+improvement is unmistakable.
+
+-}
+uniform1024 : Fuzzer Int
+uniform1024 =
+    Fuzz.map2 (\hi lo -> hi * 32 + lo)
+        (Fuzz.intRange 0 31)
+        (Fuzz.intRange 0 31)
+
+
+{-| The needle in the `Err` branch. Arbitrary, but fixed: what matters is that
+it's one value out of 1024.
+-}
+errNeedle : Int
+errNeedle =
+    999
+
+
+{-| The issue's example as written: `Result String Bool`, with the defect in the
+`Err` branch.
+
+The payload is `Fuzz.string`, so the tree is infinite and exhaustive checking has
+nothing to bite on. Requiring two separate rare characters keeps F in the same
+range as the finite cases: `Fuzz.char` draws printable ASCII half the time and
+uniformly over 95 characters when it does, so a given character appears in a
+given string with probability around 2.6%, and needing two of them lands the
+per-`Err` rate near 1e-3.
+
+-}
+openPayload : Case
+openPayload =
+    Case.fails
+        { name = "combined/open-payload"
+        , category = "combined"
+        , minima = []
+        , budget = Nothing
+        }
+        (Fuzz.oneOf
+            [ Fuzz.map Err Fuzz.string
+            , Fuzz.map Ok Fuzz.bool
+            ]
+        )
+        (\result ->
+            case result of
+                Ok _ ->
+                    True
+
+                Err payload ->
+                    not (String.contains "z" payload && String.contains "q" payload)
+        )
+
+
+{-| The same shape, but with a bounded payload so the entire choice tree is
+finite: 1024 `Err` leaves plus 2 `Ok` leaves. Exhaustive checking should find the
+defect within about 1026 generated values, guaranteed, rather than ~2048 on
+average.
+-}
+finitePayload : Case
+finitePayload =
+    Case.fails
+        { name = "combined/finite-payload"
+        , category = "combined"
+        , minima = []
+        , budget = Nothing
+        }
+        (Fuzz.oneOf
+            [ Fuzz.map Err uniform1024
+            , Fuzz.map Ok Fuzz.bool
+            ]
+        )
+        (\result ->
+            case result of
+                Ok _ ->
+                    True
+
+                Err payload ->
+                    payload /= errNeedle
+        )
+
+
+{-| An easy branch with 201 leaves rather than 2, to separate leaf-level dedup
+from subtree-level exhaustion. See the module docs.
+-}
+wideEasyBranch : Case
+wideEasyBranch =
+    Case.fails
+        { name = "combined/wide-easy-branch"
+        , category = "combined"
+        , minima = []
+        , budget = Nothing
+        }
+        (Fuzz.oneOf
+            [ Fuzz.map Err uniform1024
+            , Fuzz.map Ok (Fuzz.intRange 0 200)
+            ]
+        )
+        (\result ->
+            case result of
+                Ok _ ->
+                    True
+
+                Err payload ->
+                    payload /= errNeedle
+        )
diff --git a/f-metric/src/Corpus/KnownBugs.elm b/f-metric/src/Corpus/KnownBugs.elm
new file mode 100644
index 00000000..5c87d366
--- /dev/null
+++ b/f-metric/src/Corpus/KnownBugs.elm
@@ -0,0 +1,533 @@
+module Corpus.KnownBugs exposing (cases)
+
+{-| Replications of defects that property-based testing is known for catching:
+data structure implementations with one realistic mistake in them.
+
+These are the cases that carry the F signal. Each needs the fuzzer to produce a
+_sequence_ of operations or keys that interact in a particular way, so no single
+value falsifies them and the case count actually measures how well generation
+searches.
+
+Each case says where its bug comes from. Two are faithful to named, documented
+mutations; two are classic bug _classes_ rather than one famous incident, and are
+labelled as such.
+
+-}
+
+import Bitwise
+import Corpus.Case as Case exposing (Case)
+import Dict
+import Fuzz exposing (Fuzzer)
+import Set
+
+
+cases : List Case
+cases =
+    [ bstDeleteTwoChildren
+    , rbtMissingRotation
+    , intervalsTouchingMerge
+    , queueMissingInvariant
+    , cacheTruncatedKey
+    ]
+
+
+
+-- BINARY SEARCH TREE
+
+
+type Tree
+    = Leaf
+    | Node Tree Int Tree
+
+
+treeInsert : Int -> Tree -> Tree
+treeInsert key tree =
+    case tree of
+        Leaf ->
+            Node Leaf key Leaf
+
+        Node left k right ->
+            if key < k then
+                Node (treeInsert key left) k right
+
+            else if key > k then
+                Node left k (treeInsert key right)
+
+            else
+                tree
+
+
+treeToList : Tree -> List Int
+treeToList tree =
+    case tree of
+        Leaf ->
+            []
+
+        Node left k right ->
+            treeToList left ++ (k :: treeToList right)
+
+
+{-| Deleting a node with two children requires replacing it with the _minimum of
+its right subtree_. This implementation uses the right child's key instead, which
+is the same thing exactly when that child has no left subtree — so it is correct
+for most trees and wrong for the rest.
+
+From the BST suite in John Hughes, _How to Specify It! A Guide to Writing
+Properties of Pure Functions_ (2019), where `delete` is the operation whose bugs
+need several keys in a specific arrangement before they show.
+
+-}
+treeDelete : Int -> Tree -> Tree
+treeDelete key tree =
+    case tree of
+        Leaf ->
+            Leaf
+
+        Node left k right ->
+            if key < k then
+                Node (treeDelete key left) k right
+
+            else if key > k then
+                Node left k (treeDelete key right)
+
+            else
+                case ( left, right ) of
+                    ( Leaf, _ ) ->
+                        right
+
+                    ( _, Leaf ) ->
+                        left
+
+                    ( _, Node _ rightKey _ ) ->
+                        -- The bug.
+                        Node left rightKey (treeDelete rightKey right)
+
+
+bstDeleteTwoChildren : Case
+bstDeleteTwoChildren =
+    Case.fails
+        { name = "bst/delete-two-children"
+        , category = "known-bug"
+
+        {- Exposing the bug needs four nodes: a root with two children whose
+           right child has a left child. With distinct keys the smallest such
+           set is {0,1,2,3} with 1 at the root, and 3 has to be inserted before
+           2 (otherwise 2 becomes 3's parent, the right child's left subtree is
+           empty, and the buggy replacement happens to be the correct one). That
+           leaves three insertion orders, all building the same tree.
+
+           Simplifying currently reaches the right *shape* every time but never
+           reduces the keys, stopping at things like `([5,0,7,6],5)` -- so this
+           case reports 0% optimal today. That's a real shortfall, not a broken
+           expectation.
+        -}
+        , minima =
+            [ "([1,0,3,2],1)"
+            , "([1,3,0,2],1)"
+            , "([1,3,2,0],1)"
+            ]
+        , budget = Nothing
+        }
+        (Fuzz.pair
+            (Fuzz.list (Fuzz.intRange 0 40))
+            (Fuzz.intRange 0 40)
+        )
+        (\( keys, target ) ->
+            let
+                tree : Tree
+                tree =
+                    List.foldl treeInsert Leaf keys
+            in
+            -- Model-based: deleting a key should do to the in-order traversal
+            -- exactly what filtering it out of the traversal does.
+            treeToList (treeDelete target tree)
+                == List.filter (\k -> k /= target) (treeToList tree)
+        )
+
+
+
+-- RED-BLACK TREE
+
+
+type Color
+    = R
+    | B
+
+
+type RBTree
+    = E
+    | T Color RBTree Int RBTree
+
+
+{-| Okasaki's `balance` has four rebalancing cases. This one is missing the
+left-right case: a black node whose red left child has a red _right_ child. The
+three remaining cases still rebalance most insertions, so the invariant only
+breaks for particular insertion orders.
+
+This is one of the documented `balance` mutations from the red-black tree suite
+used to benchmark property-based testing tools (Okasaki's implementation; the
+mutation set is the one in Etna, Shi et al., PLDI 2023).
+
+-}
+balance : Color -> RBTree -> Int -> RBTree -> RBTree
+balance color left key right =
+    case ( color, left, right ) of
+        ( B, T R (T R a x b) y c, _ ) ->
+            T R (T B a x b) y (T B c key right)
+
+        -- Missing: ( B, T R a x (T R b y c), _ ) -> T R (T B a x b) y (T B c key right)
+        ( B, _, T R (T R b y c) z d ) ->
+            T R (T B left key b) y (T B c z d)
+
+        ( B, _, T R b y (T R c z d) ) ->
+            T R (T B left key b) y (T B c z d)
+
+        _ ->
+            T color left key right
+
+
+rbInsert : Int -> RBTree -> RBTree
+rbInsert x tree =
+    case ins x tree of
+        T _ a y b ->
+            T B a y b
+
+        E ->
+            E
+
+
+ins : Int -> RBTree -> RBTree
+ins x tree =
+    case tree of
+        E ->
+            T R E x E
+
+        T color a y b ->
+            if x < y then
+                balance color (ins x a) y b
+
+            else if x > y then
+                balance color a y (ins x b)
+
+            else
+                tree
+
+
+{-| No red node may have a red child.
+-}
+noRedRed : RBTree -> Bool
+noRedRed tree =
+    case tree of
+        E ->
+            True
+
+        T R (T R _ _ _) _ _ ->
+            False
+
+        T R _ _ (T R _ _ _) ->
+            False
+
+        T _ a _ b ->
+            noRedRed a && noRedRed b
+
+
+{-| Every path from the root to a leaf passes the same number of black nodes.
+`Nothing` means it doesn't hold.
+-}
+blackHeight : RBTree -> Maybe Int
+blackHeight tree =
+    case tree of
+        E ->
+            Just 0
+
+        T color a _ b ->
+            Maybe.andThen
+                (\heightA ->
+                    Maybe.andThen
+                        (\heightB ->
+                            if heightA == heightB then
+                                Just
+                                    (heightA
+                                        + (if color == B then
+                                            1
+
+                                           else
+                                            0
+                                          )
+                                    )
+
+                            else
+                                Nothing
+                        )
+                        (blackHeight b)
+                )
+                (blackHeight a)
+
+
+rbtMissingRotation : Case
+rbtMissingRotation =
+    Case.fails
+        { name = "rbt/missing-rotation"
+        , category = "known-bug"
+
+        -- The minimal left-right trigger: insert 2, then 0, then 1.
+        , minima = [ "[2,0,1]" ]
+        , budget = Nothing
+        }
+        {- Bounded length on purpose. With `Fuzz.list`'s ~16 elements a random
+           key sequence almost always contains a left-right trigger somewhere, and
+           the case is falsified by the first value it ever sees. Short sequences
+           make finding the trigger the actual work, which is what we're here to
+           measure -- and it's how the Etna suites bound their inputs too.
+        -}
+        (Fuzz.listOfLengthBetween 0 6 (Fuzz.intRange 0 9))
+        (\keys ->
+            let
+                tree : RBTree
+                tree =
+                    List.foldl rbInsert E keys
+            in
+            noRedRed tree && blackHeight tree /= Nothing
+        )
+
+
+
+-- INTERVAL MERGING
+
+
+{-| Merging a list of closed integer intervals. The fold treats two intervals as
+overlapping when `lo < previousHi`, where it should be `<=`: intervals that meet
+at exactly one point, like `(1,2)` and `(2,3)`, are left unmerged.
+
+A bug class rather than one famous incident, but a persistent one — off-by-one at
+the boundary of a range comparison, where the defect needs two intervals to share
+an endpoint _exactly_.
+
+-}
+mergeIntervals : List ( Int, Int ) -> List ( Int, Int )
+mergeIntervals intervals =
+    let
+        step : ( Int, Int ) -> List ( Int, Int ) -> List ( Int, Int )
+        step ( lo, hi ) acc =
+            case acc of
+                ( previousLo, previousHi ) :: rest ->
+                    if lo < previousHi then
+                        -- The bug: should be `lo <= previousHi`.
+                        ( previousLo, max previousHi hi ) :: rest
+
+                    else
+                        ( lo, hi ) :: acc
+
+                [] ->
+                    [ ( lo, hi ) ]
+    in
+    intervals
+        |> List.map
+            (\( lo, hi ) ->
+                if lo <= hi then
+                    ( lo, hi )
+
+                else
+                    ( hi, lo )
+            )
+        |> List.sortBy Tuple.first
+        |> List.foldl step []
+        |> List.reverse
+
+
+intervalsTouchingMerge : Case
+intervalsTouchingMerge =
+    Case.fails
+        { name = "intervals/touching-merge"
+        , category = "known-bug"
+
+        -- Two degenerate intervals that touch at a point and aren't merged.
+        , minima = [ "[(0,0),(0,0)]" ]
+        , budget = Nothing
+        }
+        (Fuzz.list (Fuzz.pair (Fuzz.intRange 0 30) (Fuzz.intRange 0 30)))
+        (\intervals ->
+            -- No two intervals in the result may overlap or touch.
+            let
+                merged : List ( Int, Int )
+                merged =
+                    mergeIntervals intervals
+            in
+            List.map2 (\( _, previousHi ) ( lo, _ ) -> lo > previousHi)
+                merged
+                (List.drop 1 merged)
+                |> List.all identity
+        )
+
+
+
+-- BATCHED QUEUE
+
+
+type Queue
+    = Queue (List Int) (List Int)
+
+
+type QueueOp
+    = Push Int
+    | Pop
+
+
+{-| Okasaki's batched queue keeps a front list and a reversed back list, with the
+invariant "the front is empty only if the whole queue is". `push` restores it,
+`pop` forgets to — so a queue that still holds elements reports itself empty.
+
+A bug class rather than one famous incident, and the textbook motivation for
+model-based/stateful property testing: no single operation exposes it, you need
+push, push, pop, pop.
+
+-}
+queuePush : Int -> Queue -> Queue
+queuePush x (Queue front back) =
+    checkQueue (Queue front (x :: back))
+
+
+queuePop : Queue -> Maybe ( Int, Queue )
+queuePop (Queue front back) =
+    case front of
+        x :: rest ->
+            -- The bug: should be `Just ( x, checkQueue (Queue rest back) )`.
+            Just ( x, Queue rest back )
+
+        [] ->
+            Nothing
+
+
+checkQueue : Queue -> Queue
+checkQueue (Queue front back) =
+    case front of
+        [] ->
+            Queue (List.reverse back) []
+
+        _ ->
+            Queue front back
+
+
+queueMissingInvariant : Case
+queueMissingInvariant =
+    Case.fails
+        { name = "queue/missing-invariant"
+        , category = "known-bug"
+
+        -- The textbook trigger: two pushes, then two pops.
+        , minima = [ "[Push 0,Push 0,Pop,Pop]" ]
+        , budget = Nothing
+        }
+        -- Bounded for the same reason as `rbt/missing-rotation`.
+        (Fuzz.listOfLengthBetween 0
+            6
+            (Fuzz.oneOf
+                [ Fuzz.map Push (Fuzz.intRange 0 9)
+                , Fuzz.constant Pop
+                ]
+            )
+        )
+        (\ops ->
+            -- Model-based: run the same operations against a plain list and
+            -- require the same sequence of popped values.
+            let
+                run : List QueueOp -> Queue -> List Int -> Bool
+                run remaining queue model =
+                    case remaining of
+                        [] ->
+                            True
+
+                        (Push x) :: rest ->
+                            run rest (queuePush x queue) (model ++ [ x ])
+
+                        Pop :: rest ->
+                            case ( queuePop queue, model ) of
+                                ( Just ( x, newQueue ), expected :: newModel ) ->
+                                    (x == expected) && run rest newQueue newModel
+
+                                ( Nothing, [] ) ->
+                                    run rest queue model
+
+                                _ ->
+                                    False
+            in
+            run ops (Queue [] []) []
+        )
+
+
+
+-- TRUNCATED CACHE KEY
+
+
+{-| A uniform 24-bit integer.
+
+`Fuzz.intRange` buckets above 255 (it draws 4-, 8-, 16- or 32-bit values with
+weights 4, 8, 2, 1 and folds them into the range), so the probability of hitting
+any particular value in a wide range is awkward to reason about. Composing three
+uniform byte draws avoids that: every value in `0..2^24-1` is equally likely, so
+the detection probability below is analytic rather than guessed.
+
+-}
+uniform24 : Fuzzer Int
+uniform24 =
+    let
+        byte : Fuzzer Int
+        byte =
+            Fuzz.intRange 0 255
+    in
+    Fuzz.map3 (\a b c -> a * 65536 + b * 256 + c) byte byte byte
+
+
+{-| A cache that keys entries on the low 19 bits of a 24-bit id, so two distinct
+ids sharing those bits collide and one silently overwrites the other.
+
+Truncating an identifier to fit a narrower field is a real and recurring bug
+class. It's here for a second reason too: it's the one case in the corpus tuned so
+that **random generation does not always find it**, which is what keeps `found`
+from being a constant 100% across the whole corpus.
+
+With ids uniform over 2^24, a key space of 2^19 and 4..12 ids per run, a single
+run collides with probability on the order of `28 / 2^19`, so a 10 000-run budget
+finds the defect about half the time. Measured at 300 seeds: **55% found**, median
+3600 runs when it does. (The 18-bit version of this mask measured 80%, so the knob
+is roughly a factor of two in `found` per bit.)
+
+The axis is two-sided from there: a change that searches a wide domain better
+pushes `found` up, one that searches worse pushes it down, and either direction is
+visible. If it drifts to an extreme, retune the mask rather than this case's
+budget -- the budget has to stay comparable across cases for detection rates to
+mean anything.
+
+-}
+truncatedCacheKey : Int -> Int
+truncatedCacheKey id =
+    -- The bug: should be the whole id.
+    Bitwise.and 0x0007FFFF id
+
+
+cacheEntryCount : List Int -> Int
+cacheEntryCount ids =
+    ids
+        |> List.foldl (\id acc -> Dict.insert (truncatedCacheKey id) id acc) Dict.empty
+        |> Dict.size
+
+
+cacheTruncatedKey : Case
+cacheTruncatedKey =
+    Case.fails
+        { name = "cache/truncated-key"
+        , category = "known-bug"
+
+        {- Left empty on purpose. The optimum is a pair of ids differing only
+           above bit 18, and which pair simplifying can reach depends on the run
+           it found; `|run|` and `sum(run)` carry the quality signal instead.
+        -}
+        , minima = []
+        , budget = Nothing
+        }
+        (Fuzz.listOfLengthBetween 4 12 uniform24)
+        (\ids ->
+            -- Distinct ids must occupy distinct cache slots. Repeated ids are
+            -- fine: they drop out of both sides.
+            cacheEntryCount ids == Set.size (Set.fromList ids)
+        )
diff --git a/f-metric/src/Corpus/ShrinkingChallenge.elm b/f-metric/src/Corpus/ShrinkingChallenge.elm
new file mode 100644
index 00000000..56fb9449
--- /dev/null
+++ b/f-metric/src/Corpus/ShrinkingChallenge.elm
@@ -0,0 +1,396 @@
+module Corpus.ShrinkingChallenge exposing (cases)
+
+{-| The <https://github.com/jlink/shrinking-challenge> suite, as corpus cases.
+
+These are ported from `tests/src/ShrinkingChallengeTests.elm`, which already
+encodes each challenge as (fuzzer, falsifiable property, known-optimal
+counterexample) — exactly what an F-metric case needs. Keep the two in sync:
+if the expected minima change there, they should change here.
+
+The challenges were designed to stress _simplifying_, not _detection_, so
+several of them are falsified on the first few runs. They still earn their place
+here because of the counterexample-quality score, and because a few of them
+(`difference*`, `coupling`) are genuinely hard to even detect.
+
+One deliberate divergence from the test suite: where `simplifiesTowardsMany`
+lists extra values with a "TODO check why this didn't get shrunk further"
+comment, we leave those out of `minima`. They document where simplifying
+currently falls short, and the point of the quality score is to notice when that
+changes — so scoring against them would hide exactly what we want to see.
+`challenge/coupling` therefore sits well below 100% optimal today, on purpose.
+
+-}
+
+import Corpus.Case as Case exposing (Case)
+import Fuzz exposing (Fuzzer)
+import Set
+
+
+cases : List Case
+cases =
+    -- `Case.shrinkOnly` marks the challenges that the very first generated
+    -- value or two already falsifies: they measure simplifying, not search.
+    [ Case.shrinkOnly reverse
+    , Case.shrinkOnly largeUnionList
+    , calculator
+    , Case.shrinkOnly lengthList
+    , difference1
+    , difference2
+    , difference3
+    , Case.shrinkOnly binHeap
+    , Case.shrinkOnly coupling
+    , deletion
+    , Case.shrinkOnly distinct
+    , Case.shrinkOnly nestedLists
+    ]
+
+
+reverse : Case
+reverse =
+    Case.fails
+        { name = "challenge/reverse"
+        , category = "challenge"
+        , minima = [ "[0,1]" ]
+        , budget = Nothing
+        }
+        (Fuzz.list Fuzz.int)
+        (\list -> list == List.reverse list)
+
+
+largeUnionList : Case
+largeUnionList =
+    Case.fails
+        { name = "challenge/large-union-list"
+        , category = "challenge"
+        , minima = [ "[[0,1,-1,2,-2]]" ]
+        , budget = Nothing
+        }
+        (Fuzz.list (Fuzz.list Fuzz.int))
+        (\lists -> Set.size (Set.fromList (List.concat lists)) <= 4)
+
+
+type CalcExpr
+    = Int Int
+    | Add CalcExpr CalcExpr
+    | Div CalcExpr CalcExpr
+
+
+calculator : Case
+calculator =
+    let
+        exprFuzzer : Int -> Fuzzer CalcExpr
+        exprFuzzer maxDepth =
+            if maxDepth <= 0 then
+                Fuzz.map Int Fuzz.int
+
+            else
+                let
+                    subExprFuzzer =
+                        exprFuzzer (maxDepth - 1)
+                in
+                Fuzz.oneOf
+                    [ Fuzz.map Int Fuzz.int
+                    , Fuzz.map2 Add subExprFuzzer subExprFuzzer
+                    , Fuzz.map2 Div subExprFuzzer subExprFuzzer
+                    ]
+
+        noDivisionByLiteralZero : CalcExpr -> Bool
+        noDivisionByLiteralZero expr =
+            case expr of
+                Div _ (Int 0) ->
+                    False
+
+                Int _ ->
+                    True
+
+                Add a b ->
+                    noDivisionByLiteralZero a
+                        && noDivisionByLiteralZero b
+
+                Div a b ->
+                    noDivisionByLiteralZero a
+                        && noDivisionByLiteralZero b
+
+        eval : CalcExpr -> Maybe Int
+        eval expr =
+            case expr of
+                Int i ->
+                    Just i
+
+                Add a b ->
+                    Maybe.map2 (+)
+                        (eval a)
+                        (eval b)
+
+                Div a b ->
+                    Maybe.map2
+                        (\a_ b_ ->
+                            if b_ == 0 then
+                                Nothing
+
+                            else
+                                Just <| a_ // b_
+                        )
+                        (eval a)
+                        (eval b)
+                        |> Maybe.andThen identity
+    in
+    Case.fails
+        { name = "challenge/calculator"
+        , category = "challenge"
+        , minima =
+            [ "Div (Int 0) (Add (Int 0) (Int 0))"
+            , "Div (Int 0) (Div (Int 0) (Int 1))"
+            ]
+        , budget = Nothing
+        }
+        (exprFuzzer 5 |> Fuzz.filter noDivisionByLiteralZero)
+        (\expr -> eval expr /= Nothing)
+
+
+lengthList : Case
+lengthList =
+    Case.fails
+        { name = "challenge/length-list"
+        , category = "challenge"
+        , minima = [ "[900]" ]
+        , budget = Nothing
+        }
+        (Fuzz.intRange 1 100
+            |> Fuzz.andThen
+                (\len -> Fuzz.listOfLength len (Fuzz.intRange 0 1000))
+        )
+        -- The fuzzer never produces an empty list, so the default is unreachable.
+        (\list -> Maybe.withDefault 0 (List.maximum list) < 900)
+
+
+difference1 : Case
+difference1 =
+    Case.fails
+        { name = "challenge/difference1"
+        , category = "challenge"
+        , minima = [ "(10,10)" ]
+        , budget = Just 10000
+        }
+        (Fuzz.pair (Fuzz.intAtLeast 0) (Fuzz.intAtLeast 0))
+        (\( x, y ) -> x < 10 || x /= y)
+
+
+difference2 : Case
+difference2 =
+    Case.fails
+        { name = "challenge/difference2"
+        , category = "challenge"
+        , minima = [ "(10,6)" ]
+        , budget = Just 5000
+        }
+        (Fuzz.pair (Fuzz.intAtLeast 0) (Fuzz.intAtLeast 0))
+        (\( x, y ) ->
+            let
+                absDiff =
+                    abs (x - y)
+            in
+            x < 10 || absDiff < 1 || absDiff > 4
+        )
+
+
+difference3 : Case
+difference3 =
+    Case.fails
+        { name = "challenge/difference3"
+        , category = "challenge"
+        , minima = [ "(10,9)" ]
+        , budget = Just 5000
+        }
+        (Fuzz.pair (Fuzz.intAtLeast 0) (Fuzz.intAtLeast 0))
+        (\( x, y ) -> x < 10 || abs (x - y) /= 1)
+
+
+type Heap
+    = Heap Int (Maybe Heap) (Maybe Heap)
+
+
+binHeap : Case
+binHeap =
+    let
+        heapFuzzer : Int -> Fuzzer Heap
+        heapFuzzer depth =
+            if depth <= 0 then
+                Fuzz.map (\i -> Heap i Nothing Nothing) Fuzz.int
+
+            else
+                Fuzz.map3 Heap
+                    Fuzz.int
+                    (Fuzz.maybe (heapFuzzer (depth - 1)))
+                    (Fuzz.maybe (heapFuzzer (depth - 1)))
+
+        toList : Heap -> List Int
+        toList heap =
+            let
+                go : List Int -> List Heap -> List Int
+                go acc stack =
+                    case stack of
+                        [] ->
+                            List.reverse acc
+
+                        (Heap n left right) :: hs ->
+                            go
+                                (n :: acc)
+                                (List.filterMap identity [ left, right ] ++ hs)
+            in
+            go [] [ heap ]
+
+        mergeHeaps : Maybe Heap -> Maybe Heap -> Maybe Heap
+        mergeHeaps left right =
+            case ( left, right ) of
+                ( Nothing, _ ) ->
+                    right
+
+                ( _, Nothing ) ->
+                    left
+
+                ( Just (Heap ln lleft lright), Just (Heap rn rleft rright) ) ->
+                    Just <|
+                        if ln <= rn then
+                            Heap ln (mergeHeaps lright right) lleft
+
+                        else
+                            Heap rn (mergeHeaps rright left) rleft
+
+        wrongToSortedList : Heap -> List Int
+        wrongToSortedList (Heap n left right) =
+            n
+                :: (mergeHeaps left right
+                        |> Maybe.map toList
+                        |> Maybe.withDefault []
+                   )
+    in
+    Case.fails
+        { name = "challenge/bin-heap"
+        , category = "challenge"
+        , minima =
+            [ "Heap 1 Nothing (Just (Heap 0 Nothing Nothing))"
+            , "Heap 0 Nothing (Just (Heap -1 Nothing Nothing))"
+            , "Heap 0 (Just (Heap -1 Nothing Nothing)) Nothing"
+            ]
+        , budget = Nothing
+        }
+        (heapFuzzer 4)
+        (\heap ->
+            let
+                l1 =
+                    toList heap
+
+                l2 =
+                    wrongToSortedList heap
+            in
+            (l2 == List.sort l2) && (List.sort l1 == l2)
+        )
+
+
+coupling : Case
+coupling =
+    let
+        getAt : Int -> List a -> Maybe a
+        getAt index list =
+            if index < 0 then
+                Nothing
+
+            else
+                list
+                    |> List.drop index
+                    |> List.head
+    in
+    Case.fails
+        { name = "challenge/coupling"
+        , category = "challenge"
+        , minima = [ "[1,0]" ]
+        , budget = Nothing
+        }
+        (Fuzz.list (Fuzz.intRange 0 10)
+            |> Fuzz.filter
+                (\l ->
+                    let
+                        length =
+                            List.length l
+                    in
+                    List.all (\i -> i < length) l
+                )
+        )
+        (\list ->
+            list
+                |> List.indexedMap
+                    (\i x ->
+                        if i /= x then
+                            getAt x list /= Just i
+
+                        else
+                            True
+                    )
+                |> List.all identity
+        )
+
+
+deletion : Case
+deletion =
+    let
+        go : a -> List a -> List a -> List a -> List a
+        go badX next prev orig =
+            case next of
+                [] ->
+                    orig
+
+                x :: rest ->
+                    if x == badX then
+                        List.reverse prev ++ rest
+
+                    else
+                        go badX rest (x :: prev) orig
+
+        removeFirst : a -> List a -> List a
+        removeFirst badX xs =
+            go badX xs [] xs
+    in
+    Case.fails
+        { name = "challenge/deletion"
+        , category = "challenge"
+        , minima = [ "([0,0],0)" ]
+        , budget = Nothing
+        }
+        (Fuzz.listOfLengthBetween 1 100 Fuzz.int
+            |> Fuzz.andThen
+                (\list ->
+                    Fuzz.pair
+                        (Fuzz.constant list)
+                        (Fuzz.oneOfValues list)
+                )
+        )
+        (\( list, el ) -> not (List.member el (removeFirst el list)))
+
+
+distinct : Case
+distinct =
+    Case.fails
+        { name = "challenge/distinct"
+        , category = "challenge"
+        , minima =
+            [ "[0,1,2]"
+            , "[0,1,-1]"
+            , "[0,-1,1]"
+            ]
+        , budget = Nothing
+        }
+        (Fuzz.list Fuzz.int)
+        (\list -> Set.size (Set.fromList list) < 3)
+
+
+nestedLists : Case
+nestedLists =
+    Case.fails
+        { name = "challenge/nested-lists"
+        , category = "challenge"
+        , minima = [ "[[0,0,0,0,0,0,0,0,0,0,0]]" ]
+        , budget = Nothing
+        }
+        (Fuzz.listOfLengthBetween 0 20 (Fuzz.listOfLengthBetween 0 20 Fuzz.int))
+        (\lists -> List.sum (List.map List.length lists) <= 10)
diff --git a/f-metric/src/Corpus/Synthetic.elm b/f-metric/src/Corpus/Synthetic.elm
new file mode 100644
index 00000000..af5ab46d
--- /dev/null
+++ b/f-metric/src/Corpus/Synthetic.elm
@@ -0,0 +1,242 @@
+module Corpus.Synthetic exposing (cases)
+
+{-| Synthetic corpus cases, each shaped to probe a different weakness a
+generation strategy can have.
+
+  - `needle` — exactly one input (out of many) violates the property. Rewards
+    strategies that cover a small domain systematically.
+  - `boundary` — the defect sits at the edge of a range or at a size boundary.
+    Rewards strategies that try edges deliberately rather than uniformly.
+  - `structural` — the input has to have a particular _shape_ (a repeat, a
+    nesting) rather than a particular value.
+  - `deep` — only _large_ inputs violate the property. This is the category that
+    punishes any strategy biased towards small inputs, so it's the one to watch
+    when a change makes the small cases look great.
+  - `filter` — the fuzzer rejects values, which exercises a separate code path
+    in the fuzz loop.
+
+-}
+
+import Corpus.Case as Case exposing (Case)
+import Fuzz
+import Set
+
+
+cases : List Case
+cases =
+    [ needleInRange
+    , needlePairDiagonal
+    , needleExactList
+    , boundaryRangeTop
+
+    -- Falsified by the first value: measures simplifying, not search.
+    , Case.shrinkOnly boundaryLastChunk
+    , Case.shrinkOnly structuralAdjacentDedupe
+    , structuralJustNothing
+    , deepListSum
+    , deepBigInt
+    , deepLongString
+    , filterMultipleOfFour
+    ]
+
+
+
+-- NEEDLE
+
+
+needleInRange : Case
+needleInRange =
+    Case.fails
+        { name = "needle/int-in-range"
+        , category = "needle"
+        , minima = [ "42" ]
+        , budget = Nothing
+        }
+        (Fuzz.intRange 0 1000)
+        (\n -> n /= 42)
+
+
+needlePairDiagonal : Case
+needlePairDiagonal =
+    Case.fails
+        { name = "needle/pair-diagonal"
+        , category = "needle"
+        , minima = [ "(0,0)" ]
+        , budget = Nothing
+        }
+        (Fuzz.pair (Fuzz.intRange 0 50) (Fuzz.intRange 0 50))
+        (\( a, b ) -> a /= b)
+
+
+needleExactList : Case
+needleExactList =
+    Case.fails
+        { name = "needle/exact-list"
+        , category = "needle"
+        , minima = [ "[1,2,3]" ]
+        , budget = Nothing
+        }
+        (Fuzz.listOfLengthBetween 0 4 (Fuzz.intRange 0 3))
+        (\xs -> xs /= [ 1, 2, 3 ])
+
+
+
+-- BOUNDARY
+
+
+{-| The defect sits at the very top of the range, where uniform sampling spends
+1/101 of its runs.
+-}
+boundaryRangeTop : Case
+boundaryRangeTop =
+    Case.fails
+        { name = "boundary/range-top"
+        , category = "boundary"
+        , minima = [ "100" ]
+        , budget = Nothing
+        }
+        (Fuzz.intRange 0 100)
+        (\n -> n /= 100)
+
+
+{-| A `chunk` that silently drops the final, partial chunk. Any input whose
+length isn't a multiple of the chunk size falsifies "chunking preserves
+elements", so `[0]` is the optimal counterexample and every strategy should find
+it almost immediately. Included as a control: if this case ever regresses,
+something is badly wrong.
+-}
+boundaryLastChunk : Case
+boundaryLastChunk =
+    let
+        chunkDroppingRemainder : Int -> List Int -> List (List Int)
+        chunkDroppingRemainder size xs =
+            if List.length xs < size then
+                []
+
+            else
+                List.take size xs :: chunkDroppingRemainder size (List.drop size xs)
+    in
+    Case.fails
+        { name = "boundary/last-chunk"
+        , category = "boundary"
+        , minima = [ "[0]" ]
+        , budget = Nothing
+        }
+        (Fuzz.list (Fuzz.intRange 0 9))
+        (\xs -> List.length (List.concat (chunkDroppingRemainder 3 xs)) == List.length xs)
+
+
+
+-- STRUCTURAL
+
+
+{-| A deduplicating function that only removes _adjacent_ duplicates. Needs a
+list where equal elements are separated by a different one, so no single value
+and no sorted list can expose it.
+-}
+structuralAdjacentDedupe : Case
+structuralAdjacentDedupe =
+    let
+        dedupeAdjacent : List Int -> List Int
+        dedupeAdjacent xs =
+            case xs of
+                a :: b :: rest ->
+                    if a == b then
+                        dedupeAdjacent (b :: rest)
+
+                    else
+                        a :: dedupeAdjacent (b :: rest)
+
+                _ ->
+                    xs
+    in
+    Case.fails
+        { name = "structural/adjacent-dedupe"
+        , category = "structural"
+
+        {- Simplifying often stops at `[1,0,1]`, which is shortlex-larger. That's
+           a real shortfall, so we score against the actual optimum rather than
+           accepting what we currently produce.
+        -}
+        , minima = [ "[0,1,0]" ]
+        , budget = Nothing
+        }
+        (Fuzz.list (Fuzz.intRange 0 3))
+        (\xs -> List.length (dedupeAdjacent xs) == Set.size (Set.fromList xs))
+
+
+structuralJustNothing : Case
+structuralJustNothing =
+    Case.fails
+        { name = "structural/just-nothing"
+        , category = "structural"
+        , minima = [ "Just Nothing" ]
+        , budget = Nothing
+        }
+        (Fuzz.maybe (Fuzz.maybe Fuzz.bool))
+        (\m -> m /= Just Nothing)
+
+
+
+-- DEEP
+
+
+deepListSum : Case
+deepListSum =
+    Case.fails
+        { name = "deep/list-sum"
+        , category = "deep"
+        , minima = []
+        , budget = Nothing
+        }
+        (Fuzz.list (Fuzz.intRange 0 9))
+        (\xs -> List.sum xs < 100)
+
+
+deepBigInt : Case
+deepBigInt =
+    Case.fails
+        { name = "deep/big-int"
+        , category = "deep"
+        , minima = []
+        , budget = Nothing
+        }
+        Fuzz.int
+        (\n -> n < 1000000)
+
+
+{-| Note the explicit length range: `Fuzz.string` is `stringOfLengthBetween 0 10`,
+so a threshold above 10 would make this case impossible rather than merely hard.
+-}
+deepLongString : Case
+deepLongString =
+    Case.fails
+        { name = "deep/long-string"
+        , category = "deep"
+        , minima = []
+        , budget = Nothing
+        }
+        (Fuzz.stringOfLengthBetween 0 40)
+        (\s -> String.length s < 25)
+
+
+
+-- FILTER
+
+
+{-| Keep the predicate generous. `Fuzz.filter` gives up after 16 consecutive
+rejections and fails the whole test, and over thousands of runs even a mildly
+selective predicate hits that. A 25%-rejection predicate makes a spurious
+failure vanishingly unlikely; `\n -> n > 15` over `intRange 0 20` (76%
+rejection) fails spuriously within a couple of thousand runs.
+-}
+filterMultipleOfFour : Case
+filterMultipleOfFour =
+    Case.fails
+        { name = "filter/multiple-of-four"
+        , category = "filter"
+        , minima = [ "42" ]
+        , budget = Nothing
+        }
+        (Fuzz.intRange 0 100 |> Fuzz.filter (\n -> modBy 4 n /= 0))
+        (\n -> n /= 42)
diff --git a/f-metric/src/Main.elm b/f-metric/src/Main.elm
new file mode 100644
index 00000000..e30ba13d
--- /dev/null
+++ b/f-metric/src/Main.elm
@@ -0,0 +1,335 @@
+port module Main exposing (main)
+
+{-| The measurement half of the F-metric harness.
+
+This is a dumb, one-measurement-per-message worker: `runner.mjs` decides what to
+measure and does all the statistics, this module only runs a single fuzz test and
+reports what happened. Keeping it this way means
+
+  - re-analysing results never requires recompiling Elm,
+  - each measurement lands in its own JS tick, so we don't build a deep chain of
+    `Task`s or grow the stack over a long run,
+  - the JS side can stream results to disk and show progress.
+
+Everything here goes through the public `Test.RunnerV2` API, so this survives
+changes to elm-test internals.
+
+-}
+
+import Array exposing (Array)
+import Corpus
+import Corpus.Case as Case exposing (Case, Role(..))
+import Json.Decode as Decode
+import Json.Encode as Encode
+import Platform
+import Random
+import Task
+import Test.RunnerV2 as Runner exposing (FuzzTestExpectation(..))
+
+
+port toJs : Encode.Value -> Cmd msg
+
+
+port fromJs : (Decode.Value -> msg) -> Sub msg
+
+
+main : Program () Model Msg
+main =
+    Platform.worker
+        { init = \_ -> ( Array.fromList (List.map prepare Corpus.all), Cmd.none )
+        , update = update
+        , subscriptions = \_ -> fromJs FromJs
+        }
+
+
+
+-- MODEL
+
+
+type alias Model =
+    Array Entry
+
+
+type alias Entry =
+    { name : String
+    , category : String
+    , role : Role
+    , minima : List String
+    , budget : Maybe Int
+
+    {- A corpus case is supposed to be exactly one fuzz test. If someone writes
+       one that isn't, we want to say so rather than measure nonsense.
+    -}
+    , fuzzTest : Result String Runner.FuzzTest
+    }
+
+
+prepare : Case -> Entry
+prepare case_ =
+    let
+        fuzzTests : Array Runner.FuzzTest
+        fuzzTests =
+            Runner.toTests case_.test
+                |> Runner.getFuzzTests
+    in
+    { name = case_.name
+    , category = case_.category
+    , role = case_.role
+    , minima = case_.minima
+    , budget = case_.budget
+    , fuzzTest =
+        case Array.toList fuzzTests of
+            [ fuzzTest ] ->
+                Ok fuzzTest
+
+            other ->
+                Err
+                    ("expected the case to be exactly one fuzz test, got "
+                        ++ String.fromInt (List.length other)
+                    )
+    }
+
+
+
+-- UPDATE
+
+
+type Msg
+    = FromJs Decode.Value
+    | Measured Entry MeasureParams ( FuzzTestExpectation, Float, String )
+
+
+type Request
+    = Manifest
+    | Measure MeasureParams
+
+
+type alias MeasureParams =
+    { index : Int
+    , seed : Int
+    , budget : Int
+    }
+
+
+update : Msg -> Model -> ( Model, Cmd Msg )
+update msg model =
+    case msg of
+        FromJs raw ->
+            case Decode.decodeValue requestDecoder raw of
+                Err error ->
+                    ( model, toJs (encodeProtocolError (Decode.errorToString error)) )
+
+                Ok Manifest ->
+                    ( model, toJs (encodeManifest model) )
+
+                Ok (Measure params) ->
+                    case Array.get params.index model of
+                        Nothing ->
+                            ( model
+                            , toJs
+                                (encodeProtocolError
+                                    ("no corpus case at index " ++ String.fromInt params.index)
+                                )
+                            )
+
+                        Just entry ->
+                            case entry.fuzzTest of
+                                Err error ->
+                                    ( model, toJs (encodeBroken entry params error) )
+
+                                Ok fuzzTest ->
+                                    ( model
+                                    , Runner.runFuzzTest fuzzTest
+                                        (Random.initialSeed params.seed)
+                                        params.budget
+                                        {- No "fuzzer ints" to replay: we want to
+                                           measure finding the defect from scratch.
+                                        -}
+                                        []
+                                        |> Task.perform (Measured entry params)
+                                    )
+
+        Measured entry params result ->
+            ( model, toJs (encodeMeasurement entry params result) )
+
+
+
+-- PROTOCOL: DECODING
+
+
+requestDecoder : Decode.Decoder Request
+requestDecoder =
+    Decode.field "tag" Decode.string
+        |> Decode.andThen
+            (\tag ->
+                case tag of
+                    "manifest" ->
+                        Decode.succeed Manifest
+
+                    "measure" ->
+                        Decode.map3 MeasureParams
+                            (Decode.field "index" Decode.int)
+                            (Decode.field "seed" Decode.int)
+                            (Decode.field "budget" Decode.int)
+                            |> Decode.map Measure
+
+                    _ ->
+                        Decode.fail ("unknown request tag: " ++ tag)
+            )
+
+
+
+-- PROTOCOL: ENCODING
+
+
+encodeManifest : Model -> Encode.Value
+encodeManifest model =
+    Encode.object
+        [ ( "tag", Encode.string "manifest" )
+        , ( "cases"
+          , model
+                |> Array.toList
+                |> List.indexedMap
+                    (\index entry ->
+                        Encode.object
+                            [ ( "index", Encode.int index )
+                            , ( "name", Encode.string entry.name )
+                            , ( "category", Encode.string entry.category )
+                            , ( "role"
+                              , Encode.string
+                                    (case entry.role of
+                                        Search ->
+                                            "search"
+
+                                        ShrinkOnly ->
+                                            "shrinkOnly"
+                                    )
+                              )
+                            , ( "minima", Encode.list Encode.string entry.minima )
+                            , ( "budget", encodeMaybe Encode.int entry.budget )
+                            , ( "error"
+                              , case entry.fuzzTest of
+                                    Ok _ ->
+                                        Encode.null
+
+                                    Err error ->
+                                        Encode.string error
+                              )
+                            ]
+                    )
+                |> Encode.list identity
+          )
+        ]
+
+
+encodeMeasurement : Entry -> MeasureParams -> ( FuzzTestExpectation, Float, String ) -> Encode.Value
+encodeMeasurement entry params ( expectation, durationMs, _ ) =
+    let
+        details : List ( String, Encode.Value )
+        details =
+            case expectation of
+                FuzzTestPass _ ->
+                    [ ( "status", Encode.string "notDetected" ) ]
+
+                FuzzTestFail failData ->
+                    let
+                        description : String
+                        description =
+                            Runner.getFuzzTestFailDescription failData
+
+                        given : Maybe String
+                        given =
+                            Runner.getFuzzTestFailGiven failData
+
+                        fuzzerInts : List Int
+                        fuzzerInts =
+                            Runner.getFuzzTestFailFuzzerInts failData
+                    in
+                    [ {- The count of values the fuzzer generated before it found
+                         the defect: the F-metric in its original sense. Unlike
+                         the duration it's an exact integer with no timer noise,
+                         so it stays meaningful for cases that finish in
+                         microseconds.
+                      -}
+                      ( "cases", Encode.int (Runner.getFuzzTestFailRunsElapsed failData) )
+                    , ( "status"
+                      , Encode.string
+                            (if String.contains Case.violation description then
+                                "detected"
+
+                             else
+                                {- The test failed for a reason other than the defect
+                                   we injected: an invalid fuzzer, too many filtered
+                                   values, a runtime exception. Not a detection.
+                                -}
+                                "error"
+                            )
+                      )
+                    , ( "description", Encode.string description )
+                    , ( "given", encodeMaybe Encode.string given )
+                    , ( "fuzzerInts", Encode.list Encode.int fuzzerInts )
+
+                    {- The length and sum of the fuzzer ints are the two components
+                       of the shortlex order that simplifying minimises, so they give
+                       us a numeric counterexample-quality score even for cases whose
+                       optimum we haven't written down.
+                    -}
+                    , ( "runLength", Encode.int (List.length fuzzerInts) )
+                    , ( "runSum", Encode.int (List.sum fuzzerInts) )
+                    , ( "optimal"
+                      , if List.isEmpty entry.minima then
+                            Encode.null
+
+                        else
+                            case given of
+                                Nothing ->
+                                    Encode.bool False
+
+                                Just g ->
+                                    Encode.bool (List.member g entry.minima)
+                      )
+                    ]
+    in
+    Encode.object
+        (( "tag", Encode.string "measurement" )
+            :: ( "index", Encode.int params.index )
+            :: ( "name", Encode.string entry.name )
+            :: ( "category", Encode.string entry.category )
+            :: ( "seed", Encode.int params.seed )
+            :: ( "budget", Encode.int params.budget )
+            :: ( "durationMs", Encode.float durationMs )
+            :: details
+        )
+
+
+encodeBroken : Entry -> MeasureParams -> String -> Encode.Value
+encodeBroken entry params error =
+    Encode.object
+        [ ( "tag", Encode.string "measurement" )
+        , ( "index", Encode.int params.index )
+        , ( "name", Encode.string entry.name )
+        , ( "category", Encode.string entry.category )
+        , ( "seed", Encode.int params.seed )
+        , ( "budget", Encode.int params.budget )
+        , ( "durationMs", Encode.float 0 )
+        , ( "status", Encode.string "error" )
+        , ( "description", Encode.string error )
+        ]
+
+
+encodeProtocolError : String -> Encode.Value
+encodeProtocolError error =
+    Encode.object
+        [ ( "tag", Encode.string "protocolError" )
+        , ( "error", Encode.string error )
+        ]
+
+
+encodeMaybe : (a -> Encode.Value) -> Maybe a -> Encode.Value
+encodeMaybe encode maybe =
+    case maybe of
+        Just value ->
+            encode value
+
+        Nothing ->
+            Encode.null
diff --git a/package.json b/package.json
index 8a450fce..3fb5d4b7 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,9 @@
   "scripts": {
     "test": "bash tests/run-tests.sh",
     "test:random": "RANDOMIZED=1 bash tests/run-tests.sh",
-    "format": "elm-format --validate src tests/src benchmarks",
+    "format": "elm-format --validate src tests/src benchmarks/*.elm f-metric/src",
+    "f-metric": "bash f-metric/build.sh && node f-metric/runner.mjs",
+    "benchmarks": "bash benchmarks/build.sh && node benchmarks/runner.mjs",
     "review": "rm -rf tests/elm_home && elm-review",
     "install-local": "rm -rf ~/.elm/0.19.2/packages/elm-explorations/test/2.2.1/ && mkdir -p ~/.elm/0.19.2/packages/elm-explorations/test/2.2.1/ && cp -r ./{src,elm.json,LICENSE,README.md} ~/.elm/0.19.2/packages/elm-explorations/test/2.2.1/"
   },
diff --git a/review/suppressed/NoUnused.CustomTypeConstructors.json b/review/suppressed/NoUnused.CustomTypeConstructors.json
new file mode 100644
index 00000000..b815c913
--- /dev/null
+++ b/review/suppressed/NoUnused.CustomTypeConstructors.json
@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "automatically created by": "elm-review suppress",
+  "learn more": "elm-review suppress --help",
+  "suppressions": [
+    { "count": 1, "filePath": "src/Test/Internal/DebugLogs.elm" }
+  ]
+}
diff --git a/src/Elm/Kernel/DebugLogs.js b/src/Elm/Kernel/DebugLogs.js
new file mode 100644
index 00000000..7250acb7
--- /dev/null
+++ b/src/Elm/Kernel/DebugLogs.js
@@ -0,0 +1,75 @@
+/*
+
+import Elm.Kernel.Debug exposing (toString)
+import Elm.Kernel.Json exposing (wrap)
+import Elm.Kernel.Scheduler exposing (binding, succeed)
+import Elm.Kernel.Utils exposing (Tuple0)
+
+*/
+
+var _DebugLogs_modeConsoleLog = __1_CONSOLE_LOG;
+var _DebugLogs_modeCollect = __1_COLLECT;
+var _DebugLogs_modeIgnore = __1_IGNORE;
+
+var _DebugLogs_logs = '';
+var _DebugLogs_used = false;
+var _DebugLogs_mode = globalThis.elmTestPrintDebugLogsBeforeFirstTestToConsole ? __1_CONSOLE_LOG : __1_COLLECT;
+// Note: Always reset the mode to __1_CONSOLE_LOG, so that `Debug.log` used to debug a test runner
+// has a higher chance of showing up out of the box.
+
+var _DebugLogs_logsBeforeFirstTestRun = undefined;
+
+var _DebugLogs_getDebugLogsBeforeFirstTestRun = __Scheduler_binding(function(callback)
+{
+  if (_DebugLogs_logsBeforeFirstTestRun === undefined) {
+    _DebugLogs_logsBeforeFirstTestRun = _DebugLogs_logs;
+    _DebugLogs_logs = '';
+    _DebugLogs_used = false;
+    _DebugLogs_mode = __1_CONSOLE_LOG;
+  }
+  callback(__Scheduler_succeed(_DebugLogs_logsBeforeFirstTestRun));
+});
+
+var _DebugLogs_runTestWithDurationAndCollectDebugLogs = F3(function(mode, thunk, mapper)
+{
+  return __Scheduler_binding(function(callback)
+  {
+    if (_DebugLogs_logsBeforeFirstTestRun === undefined) {
+      _DebugLogs_logsBeforeFirstTestRun = _DebugLogs_logs;
+    }
+    _DebugLogs_logs = '';
+    _DebugLogs_used = false;
+    _DebugLogs_mode = mode;
+    var start = performance.now();
+    var value = thunk(__Utils_Tuple0);
+    var duration = performance.now() - start;
+    _DebugLogs_mode = __1_CONSOLE_LOG;
+    callback(__Scheduler_succeed(A4(mapper, value, duration, _DebugLogs_logs, _DebugLogs_used)));
+  });
+});
+
+function _DebugLogs_rerunFailureToCollectDebugLogs(rerunFailure)
+{
+  _DebugLogs_logs = '';
+  _DebugLogs_used = false;
+  _DebugLogs_mode = __1_COLLECT;
+  rerunFailure(__Utils_Tuple0);
+  _DebugLogs_mode = __1_CONSOLE_LOG;
+  return _DebugLogs_logs;
+}
+
+var _Debug_log = F2(function(tag, value)
+{
+  _DebugLogs_used = true;
+  switch (_DebugLogs_mode) {
+    case __1_CONSOLE_LOG:
+      console.error(tag + ': ' + __Debug_toString(value));
+      break;
+    case __1_COLLECT:
+      _DebugLogs_logs += tag + ': ' + __Debug_toString(value) + '\n';
+      break;
+    default:
+      // __1_IGNORE: Do nothing.
+  }
+  return value;
+});
diff --git a/src/Elm/Kernel/RandomRun.js b/src/Elm/Kernel/RandomRun.js
index 9d940bd8..be7fa030 100644
--- a/src/Elm/Kernel/RandomRun.js
+++ b/src/Elm/Kernel/RandomRun.js
@@ -2,7 +2,7 @@
 
 import Basics exposing (EQ, LT, GT)
 import Maybe exposing (Just, Nothing)
-import Elm.Kernel.List exposing (Nil, Cons)
+import Elm.Kernel.List exposing (Nil, Cons, toArray)
 
 */
 
@@ -56,6 +56,10 @@ function _RandomRun_toList(rr) {
   return out;
 }
 
+function _RandomRun_fromList(list) {
+  return new Uint32Array(__List_toArray(list));
+}
+
 var _RandomRun_get = F2(function _RandomRun_get_(index, rr) {
   var item = rr[index];
   if (item === undefined) {
@@ -179,15 +183,15 @@ var _RandomRun_swapIfOutOfOrder = F2(function _RandomRun_swapIfOutOfOrder_(indic
 
   if (left > right) { // out of order
     return __Maybe_Just({
-      newRun: rr.with(indices.__$leftIndex, right).with(indices.__$rightIndex, left),
-      newLeftValue: right,
-      newRightValue: left,
+      __$newRun: rr.with(indices.__$leftIndex, right).with(indices.__$rightIndex, left),
+      __$newLeftValue: right,
+      __$newRightValue: left,
     });
   } else { // left <= right, they weren't out of order
     return __Maybe_Just({
-      newRun: rr,
-      newLeftValue: left,
-      newRightValue: right,
+      __$newRun: rr,
+      __$newLeftValue: left,
+      __$newRightValue: right,
     });
   }
 });
diff --git a/src/Elm/Kernel/Test.js b/src/Elm/Kernel/Test.js
index 1ef03633..6cea5787 100644
--- a/src/Elm/Kernel/Test.js
+++ b/src/Elm/Kernel/Test.js
@@ -1,18 +1,30 @@
 /*
 
-import Elm.Kernel.Utils exposing (Tuple0)
+import Maybe exposing (Just, Nothing)
 import Result exposing (Err, Ok)
 
 */
 
-
-function _Test_runThunk(thunk)
+var _Test_runWithTryCatch = F2(function(thunk, a)
 {
   try {
     // Attempt to run the thunk as normal.
-    return __Result_Ok(thunk(__Utils_Tuple0));
+    return __Result_Ok(thunk(a));
   } catch (err) {
     // If it throws, return an error instead of crashing.
     return __Result_Err(err.toString());
   }
+});
+
+var _Test_symbol = Symbol("_Test_symbol");
+
+function _Test_tagTest(test)
+{
+  test[_Test_symbol] = true;
+  return test;
+}
+
+function _Test_identifyTest(value)
+{
+  return value && value[_Test_symbol] ? __Maybe_Just(value) : __Maybe_Nothing;
 }
diff --git a/src/Fuzz.elm b/src/Fuzz.elm
index 237b7ff1..40874a74 100644
--- a/src/Fuzz.elm
+++ b/src/Fuzz.elm
@@ -90,6 +90,7 @@ import GenResult exposing (GenResult(..))
 import MicroArrayExtra
 import MicroDictExtra as Dict
 import MicroListExtra as List
+import Occupancy
 import PRNG exposing (PRNG(..))
 import Random
 import RandomRun
@@ -1339,7 +1340,11 @@ intFrequency fuzzers =
                     weightSum =
                         List.foldl (\( w, _ ) acc -> w + acc) n rest
                 in
-                rollDice (weightSum - 1) (intFrequencyGenerator n (List.map Tuple.first rest))
+                {- Sparse: `maxValue` here is the sum of the weights, but the
+                   generator only ever produces valid indices, so most values in
+                   the range are never drawn.
+                -}
+                rollDice Sparse (weightSum - 1) (intFrequencyGenerator n (List.map Tuple.first rest))
                     |> andThen
                         (\i ->
                             case List.getAt i fuzzers of
@@ -1663,7 +1668,7 @@ Max supported value is 2^32 - 1.
 -}
 uniformInt : Int -> Fuzzer Int
 uniformInt n =
-    rollDice n (Random.int 0 n)
+    rollDice Dense n (Random.int 0 n)
 
 
 {-| A fuzzer for boolean values, generating True with the given probability
@@ -1683,11 +1688,41 @@ weightedBool p =
         forcedChoice 1
 
      else
-        rollDice 1 (weightedBoolGenerator p)
+        rollDice Dense 1 (weightedBoolGenerator p)
     )
         |> map intToBool
 
 
+{-| Whether a draw can produce every value in `0..maxValue`.
+
+`maxValue` is an upper bound on what the generator might return, not a description
+of its support: `intFrequency` passes the sum of its weights while only ever
+producing valid indices. Anything reasoning about the _set_ of values a draw can
+take -- `Occupancy`, deciding a node is fully covered -- has to know the
+difference, because handing a fuzzer a number its generator would never have
+produced is interpreted as garbage. `intFrequency` reports it as
+`elm-test bug: intFrequency index out of range`.
+
+-}
+type Density
+    = Dense
+    | Sparse
+
+
+{-| The bound recorded for `Occupancy`. A sparse draw reports no usable bound, so
+its node is never tracked and never claimed to be covered.
+-}
+boundFor : Density -> Int -> Int
+boundFor density maxValue =
+    case density of
+        Dense ->
+            maxValue
+
+        Sparse ->
+            -- No node can be this wide, so Occupancy treats it as untrackable.
+            -1
+
+
 {-| This is the only place that accepts Random.Generators.
 And only Int ones at that!
 
@@ -1701,8 +1736,8 @@ Based on the PRNG value, this function:
   - or picks a number from the hardcoded list. (PRNG.Hardcoded)
 
 -}
-rollDice : Int -> Random.Generator Int -> Fuzzer Int
-rollDice maxValue diceGenerator =
+rollDice : Density -> Int -> Random.Generator Int -> Fuzzer Int
+rollDice density maxValue diceGenerator =
     Fuzzer <|
         \prng ->
             case prng of
@@ -1759,6 +1794,155 @@ rollDice maxValue diceGenerator =
                                     , prng = Hardcoded wholeRun restOfChoices
                                     }
 
+                Tracked hereOnwards run reversedMaxes seed ->
+                    let
+                        covered : Set Int
+                        covered =
+                            Occupancy.exhaustedChildren hereOnwards
+
+                        ( diceRoll, newSeed ) =
+                            {- The generator carries the fuzzer's intended bias,
+                               so keep drawing from it and reject values whose
+                               subtree is already covered. Rejection is what makes
+                               the remaining distribution the correct conditional
+                               one rather than a uniform pick over what's left.
+
+                               The common case is that nothing is covered, and
+                               then this is exactly the draw Random would make.
+                            -}
+                            drawAvoiding covered maxValue diceGenerator seed
+                    in
+                    if diceRoll < 0 || diceRoll > maxValue then
+                        Rejected
+                            { reason = "elm-test bug: generated a choice outside 0..maxChoice"
+                            , prng = prng
+                            }
+
+                    else
+                        let
+                            next : Occupancy.Occupancy
+                            next =
+                                Occupancy.childOf diceRoll maxValue hereOnwards
+                        in
+                        Generated
+                            { value = diceRoll
+                            , prng =
+                                if Occupancy.isOpen next then
+                                    {- Nothing below here is tracked, so there is
+                                       nothing left for a tracked draw to consult.
+                                       Dropping back to a plain random draw skips
+                                       the occupancy lookup, the covered-set check
+                                       and the bound bookkeeping for the rest of
+                                       the run -- which for a fuzzer with a large
+                                       domain is the whole run.
+
+                                       The run itself keeps accumulating, so
+                                       simplification is unaffected. Bounds stop
+                                       being recorded, which is exactly right:
+                                       `markCovered` walks until it reaches the
+                                       Open node and stops there anyway.
+                                    -}
+                                    Random (RandomRun.append diceRoll run) newSeed
+
+                                else
+                                    Tracked
+                                        next
+                                        (RandomRun.append diceRoll run)
+                                        (boundFor density maxValue :: reversedMaxes)
+                                        newSeed
+                            }
+
+
+{-| Draw from the generator, avoiding values whose subtree is already covered.
+
+Rejection sampling, and it has to be: `maxValue` is an upper bound on what the
+generator _could_ return, not its support. `intFrequency` passes the sum of its
+weights while only ever producing valid indices, so anything that picks a value
+from `0..maxValue` directly can hand the fuzzer a number it cannot interpret --
+which shows up as `elm-test bug: intFrequency index out of range`. Only values the
+generator itself produced are safe to return.
+
+The attempt limit matters because rejection gets expensive exactly when it's doing
+the most good: a node that is 90% covered rejects nine draws in ten. On running out
+of attempts we accept the covered value and re-test an input we've already seen.
+That costs a redundant run and can never be wrong, which is the right way round --
+substituting a different value instead is what broke.
+
+While nothing is covered, this is just the generator's own draw: identical values
+for a given seed, no conditioning, nothing to pay. For a fuzzer with a large domain
+that is every draw.
+
+-}
+drawAvoiding : Set Int -> Int -> Random.Generator Int -> Random.Seed -> ( Int, Random.Seed )
+drawAvoiding covered maxValue generator seed =
+    if Set.isEmpty covered then
+        Random.step generator seed
+
+    else
+        drawAvoidingHelp covered maxValue generator seed maxRedrawAttempts
+
+
+{-| Generous, because it can afford to be: only narrow nodes are tracked, so with
+`c` of `w` values covered a draw succeeds with probability `(w - c) / w` and the
+expected number of attempts stays in single digits.
+
+It has to be generous. Cutting this to 4 made the last uncovered value of a small
+domain unreachable in practice, so coverage never completed and early termination
+never fired -- `maybe bool` went from 49x baseline to 0.44x. What bounds the cost
+here is the width limit on tracked nodes, not this number.
+
+-}
+maxRedrawAttempts : Int
+maxRedrawAttempts =
+    32
+
+
+drawAvoidingHelp : Set Int -> Int -> Random.Generator Int -> Random.Seed -> Int -> ( Int, Random.Seed )
+drawAvoidingHelp covered maxValue generator seed attemptsLeft =
+    let
+        ( value, newSeed ) =
+            Random.step generator seed
+    in
+    if not (Set.member value covered) then
+        ( value, newSeed )
+
+    else if attemptsLeft <= 0 then
+        {- Out of attempts. Take the next value that isn't covered, wrapping.
+           Safe only because a node is tracked only when its draw is `Dense`, so
+           every value in range is one the generator could have produced -- doing
+           this for a sparse draw hands the fuzzer a number it cannot interpret.
+
+           Needed, not merely nice: without it the last uncovered value of a small
+           domain is rarely reached by chance, coverage never completes and the
+           early exit never fires. Accepting the duplicate instead measured
+           `maybe bool` at 0.16x baseline where substituting gives 49x.
+        -}
+        ( nextAvailable covered maxValue value (maxValue + 1), newSeed )
+
+    else
+        drawAvoidingHelp covered maxValue generator newSeed (attemptsLeft - 1)
+
+
+nextAvailable : Set Int -> Int -> Int -> Int -> Int
+nextAvailable covered maxValue candidate stepsLeft =
+    if stepsLeft <= 0 then
+        -- Every value covered; the caller is about to collapse this node anyway.
+        candidate
+
+    else if Set.member candidate covered then
+        nextAvailable covered
+            maxValue
+            (if candidate >= maxValue then
+                0
+
+             else
+                candidate + 1
+            )
+            (stepsLeft - 1)
+
+    else
+        candidate
+
 
 forcedChoice : Int -> Fuzzer Int
 forcedChoice n =
@@ -1800,6 +1984,18 @@ forcedChoice n =
                                         , prng = Hardcoded wholeRun restOfChoices
                                         }
 
+                    Tracked hereOnwards run reversedMaxes seed ->
+                        -- A forced choice has no alternatives, so nothing to avoid.
+                        Generated
+                            { value = n
+                            , prng =
+                                Tracked
+                                    (Occupancy.childOf n n hereOnwards)
+                                    (RandomRun.append n run)
+                                    (n :: reversedMaxes)
+                                    seed
+                            }
+
 
 {-| We could golf this to ((/=) 0) but this is perhaps more readable.
 -}
diff --git a/src/Occupancy.elm b/src/Occupancy.elm
new file mode 100644
index 00000000..efc5559f
--- /dev/null
+++ b/src/Occupancy.elm
@@ -0,0 +1,366 @@
+module Occupancy exposing
+    ( Occupancy
+    , childOf
+    , empty
+    , exhaustedChildren
+    , isExhausted
+    , isOpen
+    , markCovered
+    )
+
+{-| What part of a fuzzer's input space has already been covered.
+
+Every fuzzer bottoms out in `rollDice maxValue _`, so the inputs it can produce
+form a tree with `maxValue + 1` children per node. This records which subtrees of
+that tree have been completely explored, so a draw can decline them.
+
+That one idea does the work of three separate mechanisms:
+
+  - **No duplicates.** A covered leaf is never offered again, so no input is ever
+    tested twice — without hashing runs or keeping a set of them.
+
+  - **Early termination.** When the root is covered there is provably nothing
+    left to test, whatever run count was requested.
+
+  - **Partial coverage.** The interesting case. Given
+
+        Fuzz.oneOf
+            [ Fuzz.map Err Fuzz.string
+            , Fuzz.map Ok Fuzz.bool
+            ]
+
+    `oneOf` spends half its runs re-testing `Ok True` and `Ok False`. Here the
+    `Ok` subtree is covered after two draws and then stops being offered, so its
+    share redistributes to `Err` and a defect in the `Err` branch is found about
+    twice as fast. Neither whole-tree enumeration nor per-run deduplication gets
+    this: the tree is infinite, so there is nothing to enumerate, and the runs
+    aren't duplicates until they have already been generated.
+
+The important property is that **conditioning only happens once something is
+actually covered**. Until then the draw is exactly the draw that would have
+happened anyway, so fuzzers with large domains behave identically — same seed,
+same values, no probe, no mode switch.
+
+
+## Bounding the cost
+
+Tracking everything would cost memory and time proportional to the number of
+runs, for fuzzers that can never exhaust anything. Three bounds prevent that: a
+limit on how deep coverage is recorded, on how wide a node may be to be worth
+recording, and on how many nodes are recorded in total. All three are deliberately
+**shape-agnostic** — none may depend on which path through the tree happened to be
+drawn first. See [`markCovered`](#markCovered) and [`maxDepth`](#maxDepth).
+
+-}
+
+import Dict exposing (Dict)
+import RandomRun exposing (RandomRun)
+import Set exposing (Set)
+
+
+type Occupancy
+    = {- Partly covered, and worth tracking. The set of covered children is
+         maintained as we go rather than derived on demand: it's read on every
+         draw, and folding the whole child dict each time makes a wide node cost
+         O(width) per draw.
+      -}
+      Partial Int (Dict Int Occupancy) (Set Int)
+    | {- Not worth tracking. Never exhausts, children never recorded. -} Open
+    | {- Every input reachable from here has been tested. -} Covered
+
+
+empty : Occupancy
+empty =
+    Partial 0 Dict.empty Set.empty
+
+
+{-| Whether this part of the tree is untracked, so a draw need not consult it.
+-}
+isOpen : Occupancy -> Bool
+isOpen occupancy =
+    case occupancy of
+        Open ->
+            True
+
+        _ ->
+            False
+
+
+isExhausted : Occupancy -> Bool
+isExhausted occupancy =
+    case occupancy of
+        Covered ->
+            True
+
+        _ ->
+            False
+
+
+{-| The child values at this node that are fully covered, and so must not be
+drawn again.
+
+Empty for `Open` and for anything not yet visited, which is the common case —
+that's what keeps the cost near zero until coverage actually happens.
+
+-}
+exhaustedChildren : Occupancy -> Set Int
+exhaustedChildren occupancy =
+    case occupancy of
+        Partial _ _ covered ->
+            covered
+
+        Open ->
+            Set.empty
+
+        Covered ->
+            Set.empty
+
+
+{-| Descend to a child, so a draw can carry its position in the tree along with
+it instead of walking from the root every time.
+-}
+childOf : Int -> Int -> Occupancy -> Occupancy
+childOf value maxValue occupancy =
+    case occupancy of
+        Partial _ children _ ->
+            case Dict.get value children of
+                Just child ->
+                    child
+
+                Nothing ->
+                    {- Transient: never stored, and has no covered children, so it
+                       declines nothing. `markCovered` makes the real decision.
+                    -}
+                    Partial maxValue Dict.empty Set.empty
+
+        Open ->
+            Open
+
+        Covered ->
+            Covered
+
+
+{-| Record that the input described by this run has been tested, and report how
+much of the node budget is left.
+
+`maxes` carries the branching factor at each position, which is what lets a node
+know when all of its children are accounted for and it can collapse to `Covered`.
+
+-}
+markCovered : Int -> RandomRun -> List Int -> Occupancy -> Occupancy
+markCovered runs run maxes occupancy =
+    case markCoveredHelp runs 1 maxDepth 0 run maxes occupancy of
+        Nothing ->
+            -- Unchanged, so hand back the same value rather than a copy.
+            occupancy
+
+        Just updated ->
+            updated
+
+
+{-| How far down a run coverage is recorded.
+
+Without this the cost of recording a run grows with its length: `Fuzz.string` runs
+are tens of draws long and `Fuzz.filter` multiplies that by its retries.
+
+Shallow is enough for what this is for. The coverable parts of a fuzzer are near
+the root -- `bool` is one draw, `pair bool bool` two, and the `Ok bool` branch of a
+`oneOf` is two. Anything deeper is treated as never exhausting, which is the safe
+direction: we decline nothing we shouldn't.
+
+Three also replaces an explicit budget on tracked nodes. That budget existed to
+bound products of narrow choices, but with nodes wider than
+[`maxTrackedWidth`](#worthTracking) refused outright, depth alone bounds the
+structure: at most `8 + 8^2 + 8^3` nodes, and in practice far fewer since nodes are
+only created along runs that actually happen. Dropping the counter removes a tuple
+allocated on every single run, which measured as a real cost for fuzzers whose runs
+are cheap.
+
+-}
+maxDepth : Int
+maxDepth =
+    3
+
+
+{-| `Nothing` means nothing changed.
+
+This is what keeps the cost flat rather than growing with the number of runs. A
+child that is already `Open` or `Covered` cannot change, so recursing into it and
+then reinserting it would copy a path through the dictionary on every single run
+for no reason -- and for a fuzzer that can never exhaust anything, _every_ run is
+that case. Benchmarking put the whole mechanism at 0.16x of baseline on
+`filter/even` with this missing, essentially all of it here.
+
+-}
+markCoveredHelp : Int -> Int -> Int -> Int -> RandomRun -> List Int -> Occupancy -> Maybe Occupancy
+markCoveredHelp runs productSoFar depthLeft index run maxes occupancy =
+    case maxes of
+        [] ->
+            {- Out of bounds to walk. Two different situations, and they mean
+               opposite things:
+
+                 - the run ended here too, so this is a leaf and it's now covered;
+                 - the run continues, which means recording stopped partway
+                   because the draw entered an untracked region. Nothing to record.
+            -}
+            if index >= RandomRun.length run then
+                case occupancy of
+                    Covered ->
+                        Nothing
+
+                    _ ->
+                        Just Covered
+
+            else
+                Nothing
+
+        maxValue :: restOfMaxes ->
+            case ( RandomRun.get index run, occupancy ) of
+                ( Nothing, _ ) ->
+                    -- Shouldn't happen: bounds are recorded alongside the run.
+                    Nothing
+
+                ( Just _, Open ) ->
+                    Nothing
+
+                ( Just _, Covered ) ->
+                    Nothing
+
+                ( Just value, Partial _ children covered ) ->
+                    if depthLeft <= 0 then
+                        -- Too deep to be worth recording.
+                        Just Open
+
+                    else if not (worthTracking runs productSoFar (maxValue + 1)) then
+                        {- Checked on the width of *this* node, not of the child
+                           we're about to create. This node is the one that
+                           accumulates a child per distinct value, so this is
+                           where the cost lives. Testing the child instead left a
+                           wide node recording a leaf for every value it saw,
+                           which measured as a quarter of baseline throughput.
+                        -}
+                        Just Open
+
+                    else
+                        let
+                            existing : Occupancy
+                            existing =
+                                case Dict.get value children of
+                                    Just child ->
+                                        child
+
+                                    Nothing ->
+                                        newChild runs (productSoFar * (maxValue + 1)) restOfMaxes
+                        in
+                        case markCoveredHelp runs (productSoFar * (maxValue + 1)) (depthLeft - 1) (index + 1) run restOfMaxes existing of
+                            Nothing ->
+                                -- Nothing below changed, so nothing here did.
+                                Nothing
+
+                            Just updatedChild ->
+                                let
+                                    updatedCovered : Set Int
+                                    updatedCovered =
+                                        if isExhausted updatedChild then
+                                            Set.insert value covered
+
+                                        else
+                                            covered
+                                in
+                                if Set.size updatedCovered == maxValue + 1 then
+                                    {- Collapsing keeps the structure small, and is
+                                       what propagates coverage up to the root.
+                                    -}
+                                    Just Covered
+
+                                else
+                                    Just (Partial maxValue (Dict.insert value updatedChild children) updatedCovered)
+
+
+{-| Whether a newly discovered node is worth tracking, and what that costs.
+
+Two bounds, both shape-agnostic:
+
+  - **Its own branching factor** has to be coverable within the run count. A
+    `uniformInt 0 1000` node needs around `1001 * ln 1001` draws to fill, so
+    tracking it means paying for a thousand runs and never collapsing.
+  - **A budget on tracked nodes overall**, because branching factor alone says
+    nothing about a _product_: `pair (intRange 0 30) (intRange 0 30)` is two
+    perfectly narrow nodes with 961 leaves between them.
+
+The obvious third measure — the size of the subtree below the node — is better
+than either and unusable as a rule. The subtree below a choice depends on the
+choice, so the answer changes with whichever run reaches the node first. For
+`oneOf [ Err string, Ok bool ]` an `Err` run would mark the root untracked and
+lose the `Ok` branch, which is the one case this mechanism exists for.
+
+-}
+newChild : Int -> Int -> List Int -> Occupancy
+newChild runs productSoFar restOfMaxes =
+    case restOfMaxes of
+        [] ->
+            {- A leaf, created empty rather than already covered so that the step
+               to `Covered` is a real change and propagates: reporting it covered
+               on creation makes the parent see "nothing changed" and never add it
+               to its covered set, so nothing ever collapses.
+            -}
+            Partial 0 Dict.empty Set.empty
+
+        childMax :: _ ->
+            if worthTracking runs productSoFar (childMax + 1) then
+                Partial childMax Dict.empty Set.empty
+
+            else
+                Open
+
+
+{-| Whether a node is worth keeping coverage records for, given how much of the
+tree already lies above it.
+
+Three things have to hold, and the third is the one that was missing.
+
+_Coverable._ Random draws repeat, so covering `n` distinct values takes about
+`n * ln n` draws (the coupon collector's problem), not `n`. There is no point
+tracking a node that cannot fill within the run count.
+
+_Worth it._ Recording coverage updates a persistent tree, which allocates. The
+margin is what makes this a cost/benefit test rather than a feasibility one: a
+node that spends the entire budget covering itself has no budget left to save.
+
+_Bounded in aggregate._ `productSoFar` is the number of distinct paths that can
+reach this node, so `productSoFar * size` bounds the nodes its level can hold. A
+per-node test alone says nothing about this, and the consequence was severe: with
+the width limit relaxed by the margin, `Fuzz.filter` retries append to the same
+run, so each retry is a deeper position, and a 101-wide node at depth three
+permits on the order of a million nodes. `filter/even` ran at 0.09x of baseline.
+Threading the product down costs nothing — no counter to return, no tuple to
+allocate — where the explicit node budget it replaces cost both.
+
+-}
+worthTracking : Int -> Int -> Int -> Bool
+worthTracking runs productSoFar size =
+    {- `size < 1` is the sentinel a sparse draw records: its generator doesn't
+       produce every value in range, so the set of children isn't knowable from the
+       bound and the node must never be tracked or declared covered.
+    -}
+    (size >= 1)
+        && (productSoFar * size * bitsNeeded size * trackingMargin <= runs)
+
+
+trackingMargin : Int
+trackingMargin =
+    8
+
+
+bitsNeeded : Int -> Int
+bitsNeeded n =
+    bitsNeededHelp n 1
+
+
+bitsNeededHelp : Int -> Int -> Int
+bitsNeededHelp n acc =
+    if n <= 1 then
+        acc
+
+    else
+        bitsNeededHelp ((n + 1) // 2) (acc + 1)
diff --git a/src/PRNG.elm b/src/PRNG.elm
index 46863dfb..380e5ebe 100644
--- a/src/PRNG.elm
+++ b/src/PRNG.elm
@@ -1,4 +1,4 @@
-module PRNG exposing (PRNG(..), getRun, getSeed, hardcoded, random)
+module PRNG exposing (PRNG(..), getMaxes, getRun, getSeed, hardcoded, random, tracked)
 
 {-| A way to draw values. There are two ways:
 
@@ -9,8 +9,17 @@ module PRNG exposing (PRNG(..), getRun, getSeed, hardcoded, random)
     when reproducing a failure. This can run out of values to draw, but that
     shouldn't happen during the normal execution.
 
+3.  Tracked: like Random, but carrying a record of which parts of the input
+    space have already been covered, so a draw can decline them. Also records
+    the upper bound of every draw, which is what tells `Occupancy` how many
+    children a node has and therefore when it's complete.
+
+    Until something is actually covered this behaves exactly like Random: the
+    same seed produces the same values.
+
 -}
 
+import Occupancy exposing (Occupancy)
 import Random
 import RandomRun exposing (RandomRun)
 
@@ -19,6 +28,7 @@ type PRNG
     = -- PERF: optimized from record to custom type arguments to skip _Utils_update:
       Random RandomRun Random.Seed
     | Hardcoded {- wholeRun: -} RandomRun {- unusedPart: -} RandomRun
+    | Tracked {- hereOnwards: -} Occupancy {- run: -} RandomRun {- reversedMaxes: -} (List Int) Random.Seed
 
 
 random : Random.Seed -> PRNG
@@ -31,6 +41,13 @@ hardcoded run =
     Hardcoded run run
 
 
+{-| Draw randomly, declining inputs already covered.
+-}
+tracked : Occupancy -> Random.Seed -> PRNG
+tracked occupancy seed =
+    Tracked occupancy RandomRun.empty [] seed
+
+
 getRun : PRNG -> RandomRun
 getRun prng =
     case prng of
@@ -40,6 +57,9 @@ getRun prng =
         Hardcoded wholeRun _ ->
             wholeRun
 
+        Tracked _ run _ _ ->
+            run
+
 
 getSeed : PRNG -> Maybe Random.Seed
 getSeed prng =
@@ -49,3 +69,28 @@ getSeed prng =
 
         Hardcoded _ _ ->
             Nothing
+
+        Tracked _ _ _ seed ->
+            Just seed
+
+
+{-| The upper bound of every draw made, in order. Only a tracked draw records
+these.
+
+Accumulated as a reversed list rather than a `RandomRun`, because `RandomRun`
+appends copy the underlying array: recording bounds that way makes every draw pay
+a second O(length) copy, which turns into O(length^2) per run for no reason. The
+bounds are only read once, when the run finishes.
+
+-}
+getMaxes : PRNG -> List Int
+getMaxes prng =
+    case prng of
+        Random _ _ ->
+            []
+
+        Hardcoded _ _ ->
+            []
+
+        Tracked _ _ reversedMaxes _ ->
+            List.reverse reversedMaxes
diff --git a/src/RandomRun.elm b/src/RandomRun.elm
index 805afe38..63d657ac 100644
--- a/src/RandomRun.elm
+++ b/src/RandomRun.elm
@@ -6,6 +6,7 @@ module RandomRun exposing
     , deleteChunk
     , empty
     , equal
+    , fromList
     , get
     , isEmpty
     , length
@@ -121,6 +122,11 @@ toList =
     Elm.Kernel.RandomRun.toList
 
 
+fromList : List Int -> RandomRun
+fromList =
+    Elm.Kernel.RandomRun.fromList
+
+
 update : Int -> (Int -> Int) -> RandomRun -> RandomRun
 update =
     Elm.Kernel.RandomRun.update
diff --git a/src/Test.elm b/src/Test.elm
index a3364011..376fb610 100644
--- a/src/Test.elm
+++ b/src/Test.elm
@@ -32,8 +32,8 @@ import Test.Internal as Internal
 import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
 
 
-{-| A test which has yet to be evaluated. When evaluated, it produces one
-or more [`Expectation`](Expect#Expectation)s.
+{-| A test which has yet to be evaluated. When evaluated, it produces an
+[`Expectation`](Expect#Expectation).
 
 See [`test`](#test) and [`fuzz`](#fuzz) for some ways to create a `Test`.
 
@@ -69,6 +69,7 @@ concat tests =
 
             Ok _ ->
                 Internal.ElmTestVariant__Batch tests
+                    |> Internal.wrapTestVariant
 
 
 {-| Apply a description to a list of tests.
@@ -114,13 +115,18 @@ describe untrimmedDesc tests =
             }
 
     else
+        let
+            labeled test_ =
+                Internal.ElmTestVariant__Labeled desc test_
+                    |> Internal.wrapTestVariant
+        in
         case Internal.duplicatedName tests of
             Err dups ->
                 let
                     dupDescription duped =
                         "Contains multiple tests named '" ++ duped ++ "'. Let's rename them so we know which is which."
                 in
-                Internal.ElmTestVariant__Labeled desc <|
+                labeled <|
                     Internal.failNow
                         { description = String.join "\n" (List.map dupDescription <| Set.toList dups)
                         , reason = Invalid DuplicatedName
@@ -128,14 +134,14 @@ describe untrimmedDesc tests =
 
             Ok childrenNames ->
                 if Set.member desc childrenNames then
-                    Internal.ElmTestVariant__Labeled desc <|
+                    labeled <|
                         Internal.failNow
                             { description = "The test '" ++ desc ++ "' contains a child test of the same name. Let's rename them so we know which is which."
                             , reason = Invalid DuplicatedName
                             }
 
                 else
-                    Internal.ElmTestVariant__Labeled desc (Internal.ElmTestVariant__Batch tests)
+                    labeled (Internal.wrapTestVariant (Internal.ElmTestVariant__Batch tests))
 
 
 {-| Create a group of tests from a list of input-output cases (also called "parameterized tests").
@@ -202,7 +208,8 @@ test untrimmedDesc thunk =
         Internal.blankDescriptionFailure
 
     else
-        Internal.ElmTestVariant__Labeled desc (Internal.ElmTestVariant__UnitTest (\() -> thunk ()))
+        Internal.ElmTestVariant__Labeled desc (Internal.wrapTestVariant (Internal.ElmTestVariant__UnitTest (Internal.wrapWithTryCatch thunk)))
+            |> Internal.wrapTestVariant
 
 
 {-| Returns a [`Test`](#Test) that is "TODO" (not yet implemented). These tests
@@ -270,8 +277,9 @@ an `only` inside a `skip`, it will also get skipped.
 
 -}
 only : Test -> Test
-only =
-    Internal.ElmTestVariant__Only
+only test_ =
+    Internal.ElmTestVariant__Only test_
+        |> Internal.wrapTestVariant
 
 
 {-| Returns a [`Test`](#Test) that gets skipped.
@@ -306,8 +314,9 @@ an `only` inside a `skip`, it will also get skipped.
 
 -}
 skip : Test -> Test
-skip =
-    Internal.ElmTestVariant__Skipped
+skip test_ =
+    Internal.ElmTestVariant__Skipped test_
+        |> Internal.wrapTestVariant
 
 
 {-| Options [`fuzzWith`](#fuzzWith) accepts.
@@ -392,35 +401,7 @@ fuzzWith desc options fuzzer getTest =
             }
 
     else
-        fuzzWithHelp options (Test.Fuzz.fuzzTest desc options.distribution fuzzer getTest)
-
-
-fuzzWithHelp : FuzzOptions a -> Test -> Test
-fuzzWithHelp options aTest =
-    case aTest of
-        Internal.ElmTestVariant__UnitTest _ ->
-            aTest
-
-        Internal.ElmTestVariant__FuzzTest run ->
-            Internal.ElmTestVariant__FuzzTest (\seed _ -> run seed options.runs)
-
-        Internal.ElmTestVariant__Labeled label subTest ->
-            Internal.ElmTestVariant__Labeled label (fuzzWithHelp options subTest)
-
-        Internal.ElmTestVariant__Skipped subTest ->
-            -- It's important to treat skipped tests exactly the same as normal,
-            -- until after seed distribution has completed.
-            fuzzWithHelp options subTest
-                |> Internal.ElmTestVariant__Only
-
-        Internal.ElmTestVariant__Only subTest ->
-            fuzzWithHelp options subTest
-                |> Internal.ElmTestVariant__Only
-
-        Internal.ElmTestVariant__Batch tests ->
-            tests
-                |> List.map (fuzzWithHelp options)
-                |> Internal.ElmTestVariant__Batch
+        Test.Fuzz.fuzzTest desc (Just options.runs) options.distribution fuzzer getTest
 
 
 {-| Specify hardcoded example inputs for your fuzz test. They will be run
@@ -499,7 +480,7 @@ fuzz :
     -> (a -> Expectation)
     -> Test
 fuzz desc fuzzer getExpectation =
-    Test.Fuzz.fuzzTest desc Test.Distribution.Internal.NoDistributionNeeded fuzzer getExpectation
+    Test.Fuzz.fuzzTest desc Nothing Test.Distribution.Internal.NoDistributionNeeded fuzzer getExpectation
 
 
 {-| Run a [fuzz test](#fuzz) using two random inputs.
diff --git a/src/Test/Distribution.elm b/src/Test/Distribution.elm
index 48ef0ebd..a0aeaf9a 100644
--- a/src/Test/Distribution.elm
+++ b/src/Test/Distribution.elm
@@ -64,9 +64,6 @@ atLeast =
 
 
 {-| A result of a distribution check.
-
-Get it from your `Expectation` with `Test.Runner.getDistributionReport`.
-
 -}
 type DistributionReport
     = -- Adding a () so that all variants have the same number of arguments
diff --git a/src/Test/Expectation.elm b/src/Test/Expectation.elm
index 5d5f77dd..ed7e457b 100644
--- a/src/Test/Expectation.elm
+++ b/src/Test/Expectation.elm
@@ -1,20 +1,31 @@
 module Test.Expectation exposing
     ( Expectation(..)
     , FailData
+    , FuzzTestExpectation(..)
     , fail
+    , fromFuzzTestExpectation
     )
 
+import RandomRun exposing (RandomRun)
 import Test.Distribution exposing (DistributionReport(..))
 import Test.Runner.Failure exposing (Reason)
 
 
 type Expectation
-    = Pass DistributionReport
-    | Fail
-        { given : Maybe String
-        , failData : FailData
-        , distributionReport : DistributionReport
-        }
+    = -- `Pass` is not supposed to contain anything, but to avoid a breaking change
+      -- we have to be able to store a `DistributionReport` as well.
+      Pass DistributionReport
+    | Fail BreakingChangeWorkaround
+
+
+{-| This is supposed to _only_ contain `FailData`, but to avoid a breaking change
+we have to be able to store data from `FuzzTestFail` as well.
+-}
+type alias BreakingChangeWorkaround =
+    { failData : FailData
+    , given : Maybe String
+    , distributionReport : DistributionReport
+    }
 
 
 {-| The data the `Expect` module can set for failing expectations.
@@ -25,6 +36,27 @@ type alias FailData =
     }
 
 
+type FuzzTestExpectation
+    = FuzzTestPass DistributionReport
+    | FuzzTestFail
+        { given : Maybe String
+        , randomRun : RandomRun
+        , description : String
+        , reason : Reason
+        , distributionReport : DistributionReport
+
+        -- How many values the fuzzer generated before uncovering this failure.
+        , runsElapsed : Int
+
+        -- This function runs the fuzzer and the fuzz test again,
+        -- with the input that caused this specific failure, and
+        -- throws away the result. This is used in `Test.RunnerV2.runFuzzTest`
+        -- to capture `Debug.log`s only from the execution that caused
+        -- the failure, drastically reducing noise.
+        , rerunFailure : () -> ()
+        }
+
+
 fail : FailData -> Expectation
 fail failData =
     Fail
@@ -32,3 +64,23 @@ fail failData =
         , given = Nothing
         , distributionReport = NoDistribution ()
         }
+
+
+{-| Due to backwards compatibility, we are forced to do this type conversion,
+without losing data – see `BreakingChangeWorkaround`.
+-}
+fromFuzzTestExpectation : FuzzTestExpectation -> Expectation
+fromFuzzTestExpectation fuzzTestExpectation =
+    case fuzzTestExpectation of
+        FuzzTestPass distributionReport ->
+            Pass distributionReport
+
+        FuzzTestFail record ->
+            Fail
+                { failData =
+                    { description = record.description
+                    , reason = record.reason
+                    }
+                , given = record.given
+                , distributionReport = record.distributionReport
+                }
diff --git a/src/Test/Fuzz.elm b/src/Test/Fuzz.elm
index 4d01f8dd..008fd8ab 100644
--- a/src/Test/Fuzz.elm
+++ b/src/Test/Fuzz.elm
@@ -6,20 +6,22 @@ import Fuzz.Internal exposing (Fuzzer)
 import GenResult exposing (GenResult(..))
 import MicroDictExtra as Dict
 import MicroListExtra as List
+import Occupancy exposing (Occupancy)
 import PRNG
 import Random
+import RandomRun exposing (RandomRun)
 import Simplify
 import Test.Distribution exposing (DistributionReport(..))
 import Test.Distribution.Internal exposing (Distribution(..), ExpectedDistribution(..))
-import Test.Expectation exposing (Expectation(..), FailData)
-import Test.Internal exposing (Test(..), blankDescriptionFailure)
+import Test.Expectation exposing (Expectation(..), FailData, FuzzTestExpectation(..))
+import Test.Internal exposing (Test, TestVariant(..), blankDescriptionFailure)
 import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
 
 
-{-| Reject always-failing tests because of bad names or invalid fuzzers.
+{-| Reject always-failing tests because of bad names.
 -}
-fuzzTest : String -> Distribution a -> Fuzzer a -> (a -> Expectation) -> Test
-fuzzTest untrimmedDesc distribution fuzzer getExpectation =
+fuzzTest : String -> Maybe Int -> Distribution a -> Fuzzer a -> (a -> Expectation) -> Test
+fuzzTest untrimmedDesc maybeRuns distribution fuzzer getExpectation =
     let
         desc =
             String.trim untrimmedDesc
@@ -28,15 +30,18 @@ fuzzTest untrimmedDesc distribution fuzzer getExpectation =
         blankDescriptionFailure
 
     else
-        ElmTestVariant__Labeled desc <| validatedFuzzTest desc fuzzer getExpectation distribution
+        validatedFuzzTest desc fuzzer (Test.Internal.wrapWithTryCatch getExpectation) maybeRuns distribution
+            |> ElmTestVariant__Labeled desc
+            |> Test.Internal.wrapTestVariant
 
 
 {-| Knowing that the fuzz test isn't obviously invalid, run the test and package up the results.
 -}
-validatedFuzzTest : String -> Fuzzer a -> (a -> Expectation) -> Distribution a -> Test
-validatedFuzzTest desc fuzzer getExpectation distribution =
+validatedFuzzTest : String -> Fuzzer a -> (a -> Expectation) -> Maybe Int -> Distribution a -> Test
+validatedFuzzTest desc fuzzer getExpectation maybeRuns distribution =
     ElmTestVariant__FuzzTest
-        (\seed runs ->
+        maybeRuns
+        (\seed runs fuzzerInts ->
             let
                 _ =
                     if DebugConfig.shouldLogFuzzTests then
@@ -44,34 +49,96 @@ validatedFuzzTest desc fuzzer getExpectation distribution =
 
                     else
                         desc
+
+                { failure, distributionReport, runsElapsed } =
+                    case tryReproduceFailureFromFuzzerInts fuzzer getExpectation fuzzerInts of
+                        Just runResult ->
+                            runResult
+
+                        Nothing ->
+                            fuzzLoop
+                                { fuzzer = fuzzer
+                                , testFn = getExpectation
+                                , initialSeed = seed
+                                , runsNeeded = runs
+                                , distribution = distribution
+                                }
+                                (initLoopState seed distribution)
             in
-            let
-                runResult : RunResult
-                runResult =
-                    fuzzLoop
-                        { fuzzer = fuzzer
-                        , testFn = getExpectation
-                        , initialSeed = seed
-                        , runsNeeded = runs
-                        , distribution = distribution
-                        }
-                        (initLoopState seed distribution)
-            in
-            case runResult.failure of
+            case failure of
                 Nothing ->
-                    Pass runResult.distributionReport
-
-                Just failure ->
-                    Fail
-                        { given = failure.given
-                        , failData = failure.failData
-                        , distributionReport = runResult.distributionReport
+                    FuzzTestPass distributionReport
+
+                Just failure_ ->
+                    FuzzTestFail
+                        { given = failure_.given
+                        , randomRun = failure_.randomRun
+                        , description = failure_.failData.description
+                        , reason = failure_.failData.reason
+                        , distributionReport = distributionReport
+                        , runsElapsed = runsElapsed
+                        , rerunFailure =
+                            \() ->
+                                case Fuzz.Internal.generate (PRNG.hardcoded failure_.randomRun) fuzzer of
+                                    Generated { value } ->
+                                        getExpectation value
+                                            |> (\_ -> ())
+
+                                    Rejected _ ->
+                                        ()
                         }
         )
+        |> Test.Internal.wrapTestVariant
+
+
+tryReproduceFailureFromFuzzerInts : Fuzzer a -> (a -> Expectation) -> List Int -> Maybe RunResult
+tryReproduceFailureFromFuzzerInts fuzzer getExpectation fuzzerInts =
+    if List.isEmpty fuzzerInts then
+        -- No fuzzer ints were passed – continue with a regular fuzz run.
+        Nothing
+
+    else
+        -- When a fuzz test fails, we expose the list of integers in the
+        -- `RandomRun` that caused the failure (after shrinking) to the
+        -- runner. The runner can then store those integers, and pass them
+        -- when running the tests again. This way, a previous failure can
+        -- be reproduced quickly (no need to go through many runs plus
+        -- shrinking again).
+        let
+            randomRun =
+                RandomRun.fromList fuzzerInts
+        in
+        case Fuzz.Internal.generate (PRNG.hardcoded randomRun) fuzzer of
+            Generated { value } ->
+                case getExpectation value of
+                    Pass _ ->
+                        -- The saved `RandomRun` now passes – continue with
+                        -- a regular fuzz run.
+                        Nothing
+
+                    Fail { failData } ->
+                        Just
+                            { failure =
+                                Just
+                                    { given = Just <| Test.Internal.toString value
+                                    , randomRun = randomRun
+                                    , failData = failData
+                                    }
+
+                            -- In this mode we can't do a distribution report, because we ran just once.
+                            , distributionReport = NoDistribution ()
+                            , runsElapsed = 1
+                            }
+
+            Rejected _ ->
+                -- If the code of the test has changed, a saved `RandomRun` might
+                -- not be usable anymore. If so, just ignore it and start a regular run.
+                Nothing
 
 
 type alias Failure =
     { given : Maybe String
+    , randomRun : RandomRun
     , failData : FailData
     }
 
@@ -91,6 +158,11 @@ type alias LoopState =
     , nextPowerOfTwo : Int
     , failure : Maybe Failure
     , currentSeed : Random.Seed
+
+    {- Which parts of the input space have been covered. Carried across runs:
+       that's what makes a covered subtree stay declined.
+    -}
+    , occupancy : Occupancy
     }
 
 
@@ -113,6 +185,7 @@ initLoopState initialSeed distribution =
     , nextPowerOfTwo = 1
     , failure = Nothing
     , currentSeed = initialSeed
+    , occupancy = Occupancy.empty
     }
 
 
@@ -160,10 +233,18 @@ fuzzLoop c state =
                             , runsElapsed = state.runsElapsed
                             }
             , failure = Just failure
+            , runsElapsed = state.runsElapsed
             }
 
         Nothing ->
-            if state.runsElapsed < c.runsNeeded then
+            if Occupancy.isExhausted state.occupancy then
+                -- Proved for every input the fuzzer can produce.
+                { distributionReport = Fuzz.Internal.noDistribution
+                , failure = Nothing
+                , runsElapsed = state.runsElapsed
+                }
+
+            else if state.runsElapsed < c.runsNeeded then
                 let
                     newState : LoopState
                     newState =
@@ -176,6 +257,7 @@ fuzzLoop c state =
                     NoDistributionNeeded ->
                         { distributionReport = Fuzz.Internal.noDistribution
                         , failure = Nothing
+                        , runsElapsed = state.runsElapsed
                         }
 
                     ReportDistribution _ ->
@@ -191,6 +273,7 @@ fuzzLoop c state =
                                         , runsElapsed = state.runsElapsed
                                         }
                                 , failure = Nothing
+                                , runsElapsed = state.runsElapsed
                                 }
 
                     ExpectDistribution _ ->
@@ -219,6 +302,7 @@ fuzzLoop c state =
                                                     , runsElapsed = state.runsElapsed
                                                     }
                                             , failure = Nothing
+                                            , runsElapsed = state.runsElapsed
                                             }
 
                                 Just failedLabel ->
@@ -238,6 +322,7 @@ fuzzLoop c state =
                                         , nextPowerOfTwo = newState.nextPowerOfTwo + 1
                                         , failure = newState.failure
                                         , currentSeed = newState.currentSeed
+                                        , occupancy = newState.occupancy
                                         }
 
                                 Just failedLabel ->
@@ -408,6 +493,7 @@ distributionFailRunResult normalizedDistributionCount failedLabel =
                     , expectedDistribution = Test.Distribution.Internal.expectedDistributionToString failedLabel.expectedDistribution
                     }
             , failure = Just <| distributionInsufficientFailure failedLabel
+            , runsElapsed = failedLabel.runsElapsed
             }
 
 
@@ -417,17 +503,20 @@ distributionBugRunResult =
     , failure =
         Just
             { given = Nothing
+            , randomRun = RandomRun.empty
             , failData =
                 { description = "elm-test distribution collection bug"
                 , reason = Invalid DistributionBug
                 }
             }
+    , runsElapsed = 0
     }
 
 
 distributionInsufficientFailure : DistributionFailure -> Failure
 distributionInsufficientFailure failure =
     { given = Nothing
+    , randomRun = RandomRun.empty
     , failData =
         { description =
             """Distribution of label "{LABEL}" was insufficient:
@@ -448,7 +537,12 @@ distributionInsufficientFailure failure =
 -}
 runNTimes : Int -> LoopConstants a -> LoopState -> LoopState
 runNTimes times c state =
-    if times <= 0 || state.failure /= Nothing then
+    if times <= 0 || state.failure /= Nothing || Occupancy.isExhausted state.occupancy then
+        {- A covered root means every input this fuzzer can produce has been
+           tested, so there is nothing left to do however many runs were asked
+           for. Checking here and not only in `fuzzLoop` is what makes the saving
+           real: otherwise the batch runs to completion first.
+        -}
         state
 
     else
@@ -464,7 +558,7 @@ runOnce c state =
         genResult : GenResult a
         genResult =
             Fuzz.Internal.generate
-                (PRNG.random state.currentSeed)
+                (PRNG.tracked state.occupancy state.currentSeed)
                 c.fuzzer
 
         maybeNextSeed : Maybe Random.Seed
@@ -482,11 +576,19 @@ runOnce c state =
                 Nothing ->
                     stepSeed state.currentSeed
 
+        newOccupancy : Occupancy
+        newOccupancy =
+            Occupancy.markCovered c.runsNeeded
+                (PRNG.getRun (GenResult.getPrng genResult))
+                (PRNG.getMaxes (GenResult.getPrng genResult))
+                state.occupancy
+
         ( maybeFailure, newDistributionCounter ) =
             case genResult of
                 Rejected { reason } ->
                     ( Just
                         { given = Nothing
+                        , randomRun = RandomRun.empty
                         , failData =
                             { description = reason
                             , reason = Invalid InvalidFuzzer
@@ -542,6 +644,7 @@ runOnce c state =
     , currentSeed = nextSeed
     , runsElapsed = state.runsElapsed + 1
     , nextPowerOfTwo = state.nextPowerOfTwo
+    , occupancy = newOccupancy
     }
 
 
@@ -584,6 +687,16 @@ formatExpectedDistribution expected =
 type alias RunResult =
     { distributionReport : DistributionReport
     , failure : Maybe Failure
+
+    {- How many values the fuzzer generated. Note this can be *more* than the
+       configured `runs`: an `ExpectDistribution` test keeps going until the
+       statistical check settles.
+
+       This is reported to runners for failures, where it says how much work it
+       took to uncover the defect. `DistributionReport` carries the same number,
+       but only for tests that asked for a distribution report.
+    -}
+    , runsElapsed : Int
     }
 
 
@@ -599,9 +712,10 @@ stepSeed seed =
 findSimplestFailure : Simplify.State a -> Failure
 findSimplestFailure state =
     let
-        ( simplestValue, _, failData ) =
+        ( simplestValue, randomRun, failData ) =
             Simplify.simplify state
     in
     { given = Just <| Test.Internal.toString simplestValue
+    , randomRun = randomRun
     , failData = failData
     }
diff --git a/src/Test/Internal.elm b/src/Test/Internal.elm
index 949decfb..548af967 100644
--- a/src/Test/Internal.elm
+++ b/src/Test/Internal.elm
@@ -1,27 +1,58 @@
-module Test.Internal exposing (Test(..), blankDescriptionFailure, duplicatedName, failNow, toString)
+module Test.Internal exposing (Test, TestVariant(..), blankDescriptionFailure, duplicatedName, failNow, identifyTest, toString, unwrapTestVariant, wrapTestVariant, wrapWithTryCatch)
 
+import Elm.Kernel.Test
 import Random
 import Set exposing (Set)
-import Test.Expectation exposing (Expectation)
+import Test.Expectation exposing (Expectation, FuzzTestExpectation)
 import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
 
 
-{-| All variants of this type has the `ElmTestVariant__` prefix so that
-node-test-runner can recognize them in the compiled JavaScript. This lets us
-add more variants here without having to update the runner.
+{-| Opaque type around tests. Use `wrapTestVariant` to create a `Test`
+from a `TestVariant`. It tags the test (using Kernel code) so that
+`identifyTest` can recognize it later. This allows test runners to
+find exposed values of type `Test` without having to implement type
+inference.
+-}
+type Test
+    = Test TestVariant
+
+
+{-| All variants of this type have the `ElmTestVariant__` prefix for
+backwards compatibility with test runners. Test runners use the prefix
+to recognize tests in the compiled JavaScript.
 
 For more information, see <https://github.com/elm-explorations/test/pull/153>
 
+The new way of recognizing tests is using the `identifyTest` function, as
+explained in the `Test` type. The prefix can be removed in a major version
+if we want to clean up the code internally.
+
 -}
-type Test
+type TestVariant
     = ElmTestVariant__UnitTest (() -> Expectation)
-    | ElmTestVariant__FuzzTest (Random.Seed -> Int -> Expectation)
+    | ElmTestVariant__FuzzTest (Maybe Int) (Random.Seed -> Int -> List Int -> FuzzTestExpectation)
     | ElmTestVariant__Labeled String Test
+    | ElmTestVariant__Tagged String Test
     | ElmTestVariant__Skipped Test
     | ElmTestVariant__Only Test
     | ElmTestVariant__Batch (List Test)
 
 
+wrapTestVariant : TestVariant -> Test
+wrapTestVariant testVariant =
+    Elm.Kernel.Test.tagTest (Test testVariant)
+
+
+unwrapTestVariant : Test -> TestVariant
+unwrapTestVariant (Test testVariant) =
+    testVariant
+
+
+identifyTest : a -> Maybe Test
+identifyTest =
+    Elm.Kernel.Test.identifyTest
+
+
 {-| Create a test that always fails for the given reason and description.
 -}
 failNow : { description : String, reason : Reason } -> Test
@@ -33,6 +64,7 @@ failNow { description, reason } =
                 , reason = reason
                 }
         )
+        |> wrapTestVariant
 
 
 blankDescriptionFailure : Test
@@ -47,18 +79,21 @@ duplicatedName : List Test -> Result (Set String) (Set String)
 duplicatedName tests =
     let
         names : Test -> List String
-        names test =
+        names (Test test) =
             case test of
                 ElmTestVariant__Labeled str _ ->
                     [ str ]
 
+                ElmTestVariant__Tagged _ _ ->
+                    []
+
                 ElmTestVariant__Batch subtests ->
                     List.concatMap names subtests
 
                 ElmTestVariant__UnitTest _ ->
                     []
 
-                ElmTestVariant__FuzzTest _ ->
+                ElmTestVariant__FuzzTest _ _ ->
                     []
 
                 ElmTestVariant__Skipped subTest ->
@@ -89,3 +124,22 @@ duplicatedName tests =
 toString : a -> String
 toString =
     Elm.Kernel.Debug.toString
+
+
+runWithTryCatch : (a -> b) -> a -> Result String b
+runWithTryCatch =
+    Elm.Kernel.Test.runWithTryCatch
+
+
+wrapWithTryCatch : (a -> Expectation) -> (a -> Expectation)
+wrapWithTryCatch getExpectation =
+    \a ->
+        case runWithTryCatch getExpectation a of
+            Ok expectation ->
+                expectation
+
+            Err message ->
+                Test.Expectation.fail
+                    { description = "This test failed because it threw an exception: \"" ++ message ++ "\""
+                    , reason = Custom
+                    }
diff --git a/src/Test/Internal/DebugLogs.elm b/src/Test/Internal/DebugLogs.elm
new file mode 100644
index 00000000..e2a25bd3
--- /dev/null
+++ b/src/Test/Internal/DebugLogs.elm
@@ -0,0 +1,43 @@
+module Test.Internal.DebugLogs exposing (Mode, getDebugLogsBeforeFirstTestRun, modeCollect, modeConsoleLog, modeIgnore, noDebugLogsForPassingFuzzTests, rerunFailureToCollectDebugLogs, runTestWithDurationAndCollectDebugLogs)
+
+import Elm.Kernel.DebugLogs
+import Task exposing (Task)
+
+
+type Mode
+    = Mode
+
+
+modeConsoleLog : Mode
+modeConsoleLog =
+    Elm.Kernel.DebugLogs.modeConsoleLog
+
+
+modeCollect : Mode
+modeCollect =
+    Elm.Kernel.DebugLogs.modeCollect
+
+
+modeIgnore : Mode
+modeIgnore =
+    Elm.Kernel.DebugLogs.modeIgnore
+
+
+getDebugLogsBeforeFirstTestRun : Task x String
+getDebugLogsBeforeFirstTestRun =
+    Elm.Kernel.DebugLogs.getDebugLogsBeforeFirstTestRun
+
+
+runTestWithDurationAndCollectDebugLogs : Mode -> (() -> a) -> (a -> Float -> String -> Bool -> b) -> Task x b
+runTestWithDurationAndCollectDebugLogs =
+    Elm.Kernel.DebugLogs.runTestWithDurationAndCollectDebugLogs
+
+
+rerunFailureToCollectDebugLogs : (() -> a) -> String
+rerunFailureToCollectDebugLogs =
+    Elm.Kernel.DebugLogs.rerunFailureToCollectDebugLogs
+
+
+noDebugLogsForPassingFuzzTests : String
+noDebugLogsForPassingFuzzTests =
+    "For passing fuzz tests, Debug.log is not shown, since showing logs from lots of runs is pretty confusing. Tip: Use Debug.todo to fail a test from anywhere if you want some logs to appear."
diff --git a/src/Test/Runner.elm b/src/Test/Runner.elm
index 075e8e61..99a7e7c5 100644
--- a/src/Test/Runner.elm
+++ b/src/Test/Runner.elm
@@ -6,7 +6,9 @@ module Test.Runner exposing
     , Simplifiable, fuzz, simplify
     )
 
-{-| This is an "experts only" module that exposes functions needed to run and
+{-| **DEPRECATED.** This module has been superseded by the [Test.RunnerV2](Test.RunnerV2) module.
+
+This is an "experts only" module that exposes functions needed to run and
 display tests. A typical user will use an existing runner library for Node or
 the browser, which is implemented using this interface. A list of these runners
 can be found in the `README`.
@@ -41,7 +43,6 @@ These functions give you the ability to run fuzzers separate of running fuzz tes
 -}
 
 import Bitwise
-import Elm.Kernel.Test
 import Expect exposing (Expectation)
 import Fuzz exposing (Fuzzer)
 import Fuzz.Internal
@@ -140,17 +141,7 @@ countRunnables runnable =
 
 run : Runnable -> Expectation
 run (Thunk fn) =
-    case runThunk fn of
-        Ok test ->
-            test
-
-        Err message ->
-            Expect.fail ("This test failed because it threw an exception: \"" ++ message ++ "\"")
-
-
-runThunk : (() -> a) -> Result String a
-runThunk =
-    Elm.Kernel.Test.runThunk
+    fn ()
 
 
 fromRunnableTree : RunnableTree -> List Runner
@@ -237,7 +228,7 @@ distributeSeeds =
 
 distributeSeedsHelp : Bool -> Int -> Random.Seed -> Test -> Distribution
 distributeSeedsHelp hashed runs seed test =
-    case test of
+    case Internal.unwrapTestVariant test of
         Internal.ElmTestVariant__UnitTest aRun ->
             { seed = seed
             , all = [ Runnable (Thunk (\_ -> aRun ())) ]
@@ -245,13 +236,13 @@ distributeSeedsHelp hashed runs seed test =
             , skipped = []
             }
 
-        Internal.ElmTestVariant__FuzzTest aRun ->
+        Internal.ElmTestVariant__FuzzTest maybeRuns aRun ->
             let
                 ( firstSeed, nextSeed ) =
                     Random.step Random.independentSeed seed
             in
             { seed = nextSeed
-            , all = [ Runnable (Thunk (\_ -> aRun firstSeed runs)) ]
+            , all = [ Runnable (Thunk (\_ -> aRun firstSeed (maybeRuns |> Maybe.withDefault runs) [] |> Test.Expectation.fromFuzzTestExpectation)) ]
             , only = []
             , skipped = []
             }
@@ -309,6 +300,9 @@ distributeSeedsHelp hashed runs seed test =
                 , skipped = List.map (Labeled description) next.skipped
                 }
 
+        Internal.ElmTestVariant__Tagged _ subTest ->
+            distributeSeedsHelp hashed runs seed subTest
+
         Internal.ElmTestVariant__Skipped subTest ->
             let
                 -- Go through the motions in order to obtain the seed, but then
diff --git a/src/Test/RunnerV2.elm b/src/Test/RunnerV2.elm
new file mode 100644
index 00000000..7ce21e9c
--- /dev/null
+++ b/src/Test/RunnerV2.elm
@@ -0,0 +1,692 @@
+module Test.RunnerV2 exposing
+    ( toTests, Tests, getUnitTests, getFuzzTests, getExcludedDueToSkip, getExcludedDueToOnly
+    , UnitTest, getUnitTestTag, getUnitTestLabels, runUnitTest, runUnitTestWithUnbufferedLogs
+    , UnitTestExpectation(..), UnitTestFailData, getUnitTestFailDescription, getUnitTestFailReason
+    , FuzzTest, getFuzzTestTag, getFuzzTestLabels, getFuzzTestRuns, runFuzzTest, runFuzzTestWithUnbufferedLogs
+    , FuzzTestExpectation(..), getFuzzTestPassDistributionReport, FuzzTestPassData, FuzzTestFailData, getFuzzTestFailDescription, getFuzzTestFailReason, getFuzzTestFailDistributionReport, getFuzzTestFailGiven, getFuzzTestFailFuzzerInts, getFuzzTestFailRunsElapsed
+    , identifyTest, tagTest
+    , getDebugLogsBeforeFirstTestRun
+    )
+
+{-| This is an "experts only" module that exposes functions needed to run tests.
+A typical user will use an existing runner library for Node or the browser,
+which is implemented using this interface. A list of these runners
+can be found in the [README](.).
+
+This module supersedes the deprecated [Test.Runner](Test.Runner) module.
+
+
+## Consume tests
+
+@docs toTests, Tests, getUnitTests, getFuzzTests, getExcludedDueToSkip, getExcludedDueToOnly
+
+
+## Unit Tests
+
+@docs UnitTest, getUnitTestTag, getUnitTestLabels, runUnitTest, runUnitTestWithUnbufferedLogs
+@docs UnitTestExpectation, UnitTestFailData, getUnitTestFailDescription, getUnitTestFailReason
+
+
+## Fuzz Tests
+
+@docs FuzzTest, getFuzzTestTag, getFuzzTestLabels, getFuzzTestRuns, runFuzzTest, runFuzzTestWithUnbufferedLogs
+@docs FuzzTestExpectation, getFuzzTestPassDistributionReport, FuzzTestPassData, FuzzTestFailData, getFuzzTestFailDescription, getFuzzTestFailReason, getFuzzTestFailDistributionReport, getFuzzTestFailGiven, getFuzzTestFailFuzzerInts, getFuzzTestFailRunsElapsed
+
+
+## Runner test operations
+
+@docs identifyTest, tagTest
+
+
+## Debug logs
+
+@docs getDebugLogsBeforeFirstTestRun
+
+-}
+
+import Array exposing (Array)
+import Random
+import RandomRun
+import Task exposing (Task)
+import Test exposing (Test)
+import Test.Distribution exposing (DistributionReport)
+import Test.Expectation exposing (Expectation(..))
+import Test.Internal as Internal
+import Test.Internal.DebugLogs
+import Test.Runner.Failure exposing (Reason)
+
+
+{-| This type contains flat arrays of tests and some metadata.
+
+`Tests` is opaque for future extensibility. It contains the following:
+
+  - `unitTests : Array UnitTest`
+  - `fuzzTests : Array FuzzTest`
+  - `excludedDueToSkip : Int`
+  - `excludedDueToOnly : Maybe Int`
+
+Use the various `get*` functions to access each field.
+
+The lists of unit tests and fuzz tests only include tests that should be run,
+after taking [`skip`](Test#skip) and [`only`](Test#only) into account.
+The `excludedDueToSkip` and `excludedDueToOnly` fields tell if any
+`skip` and/or `only` reduced the number of tests returned, and by how much.
+A runner could fail the test run if `skip` or `only` was used.
+
+-}
+type Tests
+    = Tests TestsData
+
+
+type alias TestsData =
+    { unitTests : Array UnitTest
+    , fuzzTests : Array FuzzTest
+    , excludedDueToSkip : Int
+    , excludedDueToOnly : Maybe Int
+    }
+
+
+{-| Get unit tests.
+-}
+getUnitTests : Tests -> Array UnitTest
+getUnitTests (Tests testsData) =
+    testsData.unitTests
+
+
+{-| Get fuzz tests.
+-}
+getFuzzTests : Tests -> Array FuzzTest
+getFuzzTests (Tests testsData) =
+    testsData.fuzzTests
+
+
+{-| Get how many tests were excluded due to `skip`.
+If `skip` wasn’t used at all, this returns 0.
+-}
+getExcludedDueToSkip : Tests -> Int
+getExcludedDueToSkip (Tests testsData) =
+    testsData.excludedDueToSkip
+
+
+{-| Get how many tests were excluded due to `only`.
+
+  - If `only` wasn’t used at all, this returns `Nothing`.
+  - If `only` was used but didn’t exclude anything, this returns `Just 0`.
+  - If `only` and excluded `n` tests, this returns `Just n`.
+  - If a test is excluded both due to `skip` _and_ `only`, it is only counted as excluded due to `skip`.
+
+-}
+getExcludedDueToOnly : Tests -> Maybe Int
+getExcludedDueToOnly (Tests testsData) =
+    testsData.excludedDueToOnly
+
+
+{-| A unit test.
+
+`UnitTest` is opaque for future extensibility. It contains the following:
+
+  - `tag : String`. The tag is set via [`tagTest`](#tagTest) and used by runners to cache test results.
+  - `labels : List String`. The list starts with the test name, and then contains each [`describe`](Test#describe) up the hierarchy.
+  - `thunk : () -> UnitTestExpectation`. This is the function originally passed to [`Test.test`](Test#test).
+
+Use the various `getUnitTest*` functions to access each field, as well as [`runUnitTest`](#runUnitTest) to run it.
+
+-}
+type UnitTest
+    = UnitTest
+        { tag : String
+        , labels : List String
+        , thunk : () -> Expectation
+        }
+
+
+{-| Get the [tag](#tagTest) of the test.
+-}
+getUnitTestTag : UnitTest -> String
+getUnitTestTag (UnitTest data) =
+    data.tag
+
+
+{-| Get the labels of the test.
+-}
+getUnitTestLabels : UnitTest -> List String
+getUnitTestLabels (UnitTest data) =
+    data.labels
+
+
+{-| Run the unit test. Returns the test result, the duration it took to run in milliseconds,
+and captured debug logs.
+
+The debug logs are joined to one string with a newline as separator and with a trailing newline.
+
+-}
+runUnitTest : UnitTest -> Task x ( UnitTestExpectation, Float, String )
+runUnitTest (UnitTest data) =
+    Test.Internal.DebugLogs.runTestWithDurationAndCollectDebugLogs
+        Test.Internal.DebugLogs.modeCollect
+        data.thunk
+        (\expectation duration debugLogs _ ->
+            ( toUnitTestExpectation expectation, duration, debugLogs )
+        )
+
+
+{-| Like `runUnitTest`, but if `Debug.log` is used it writes directly to the console
+instead of buffering. This is useful if a test ends up in an infinite loop and you would
+like to see logs as the test runs.
+
+The returned `Bool` says whether `Debug.log` was used at all while running the test.
+
+Note: The logs are printed to stderr, not stdout like you might be used with
+`Platform.worker` programs running in Node.js. This is because test runners typically
+offer structured output on stdout, and don’t want to mix that with debug logs.
+
+-}
+runUnitTestWithUnbufferedLogs : UnitTest -> Task x ( UnitTestExpectation, Float, Bool )
+runUnitTestWithUnbufferedLogs (UnitTest data) =
+    Test.Internal.DebugLogs.runTestWithDurationAndCollectDebugLogs
+        Test.Internal.DebugLogs.modeConsoleLog
+        data.thunk
+        (\expectation duration _ debugLogUsed ->
+            ( toUnitTestExpectation expectation, duration, debugLogUsed )
+        )
+
+
+{-| A fuzz test. It’s similar to a unit test but has more data, and running
+it requires more arguments.
+
+`FuzzTest` is opaque for future extensibility. It contains the following:
+
+  - `tag : String`. The tag is set via [`tagTest`](#tagTest) and used by runners to cache test results.
+  - `labels : List String`. The list starts with the test name, and then contains each [`describe`](Test#describe) up the hierarchy.
+  - `runs : Maybe Int`. Contains the specified number of fuzz runs if [`fuzzWith`](Test#fuzzWith) was used.
+  - `thunk : Random.Seed -> Int -> List Int -> FuzzTestExpectation`. This function runs the fuzz test.
+
+Use the various `getFuzzTest*` functions to access each field, as well as [`runFuzzTest`](#runFuzzTest) to run it.
+
+-}
+type FuzzTest
+    = FuzzTest
+        { tag : String
+        , labels : List String
+        , runs : Maybe Int
+        , thunk : Random.Seed -> Int -> List Int -> Test.Expectation.FuzzTestExpectation
+        }
+
+
+{-| Get the [tag](#tagTest) of the test.
+-}
+getFuzzTestTag : FuzzTest -> String
+getFuzzTestTag (FuzzTest data) =
+    data.tag
+
+
+{-| Get the labels of the test.
+-}
+getFuzzTestLabels : FuzzTest -> List String
+getFuzzTestLabels (FuzzTest data) =
+    data.labels
+
+
+{-| Get the the specified number of fuzz runs if [`fuzzWith`](Test#fuzzWith) was used.
+-}
+getFuzzTestRuns : FuzzTest -> Maybe Int
+getFuzzTestRuns (FuzzTest data) =
+    data.runs
+
+
+{-| Run the fuzz test. Returns the test result, and the duration it took to run in milliseconds,
+and captured debug logs. When it comes to the debug logs, you need to know:
+
+  - If the test failed, the debug logs are from the run that caused the returned test failure.
+
+  - If the test passed, the debug logs are either empty, or a hardcoded message saying:
+
+    > For passing fuzz tests, Debug.log is not shown, since showing logs from lots of runs is pretty confusing.
+    > Tip: Use Debug.todo to fail a test from anywhere if you want some logs to appear.
+
+  - The debug logs are joined to one string with a newline as separator and with a trailing newline.
+
+It requires a few arguments:
+
+  - The initial seed.
+  - The number of fuzz runs.
+  - A list of “fuzzer ints” from a previous run. If non-empty,
+    the test will first be run with input based on those ints,
+    which can quickly reproduce a previous failure. If that run
+    succeeds (or the ints are no longer valid), the test continues
+    with a regular random run.
+
+-}
+runFuzzTest : FuzzTest -> Random.Seed -> Int -> List Int -> Task x ( FuzzTestExpectation, Float, String )
+runFuzzTest (FuzzTest data) seed runs fuzzerInts =
+    Test.Internal.DebugLogs.runTestWithDurationAndCollectDebugLogs
+        Test.Internal.DebugLogs.modeIgnore
+        (\() -> data.thunk seed runs fuzzerInts)
+        (\expectation duration _ debugLogUsed ->
+            case expectation of
+                Test.Expectation.FuzzTestPass distributionReport ->
+                    ( FuzzTestPass (FuzzTestPassData distributionReport)
+                    , duration
+                    , if debugLogUsed then
+                        Test.Internal.DebugLogs.noDebugLogsForPassingFuzzTests
+
+                      else
+                        ""
+                    )
+
+                Test.Expectation.FuzzTestFail failData ->
+                    ( FuzzTestFail
+                        (FuzzTestFailData
+                            { description = failData.description
+                            , reason = failData.reason
+                            , distributionReport = failData.distributionReport
+                            , given = failData.given
+                            , fuzzerInts = RandomRun.toList failData.randomRun
+                            , runsElapsed = failData.runsElapsed
+                            }
+                        )
+                    , duration
+                    , Test.Internal.DebugLogs.rerunFailureToCollectDebugLogs failData.rerunFailure
+                    )
+        )
+
+
+{-| Like `runFuzzTest`, but if `Debug.log` is used it writes directly to the console
+instead of buffering. This is useful if a test ends up in an infinite loop and you would
+like to see logs as the test runs, or if you’d like to see logs from all the runs of the
+test, not just the failing one (if any).
+
+The returned `Bool` says whether `Debug.log` was used at all while running the test.
+
+Note: The logs are printed to stderr, not stdout like you might be used with
+`Platform.worker` programs running in Node.js. This is because test runners typically
+offer structured output on stdout, and don’t want to mix that with debug logs.
+
+-}
+runFuzzTestWithUnbufferedLogs : FuzzTest -> Random.Seed -> Int -> List Int -> Task x ( FuzzTestExpectation, Float, Bool )
+runFuzzTestWithUnbufferedLogs (FuzzTest data) seed runs fuzzerInts =
+    Test.Internal.DebugLogs.runTestWithDurationAndCollectDebugLogs
+        Test.Internal.DebugLogs.modeConsoleLog
+        (\() -> data.thunk seed runs fuzzerInts)
+        (\expectation duration _ debugLogUsed ->
+            ( toFuzzTestExpectation expectation, duration, debugLogUsed )
+        )
+
+
+{-| A unit test either passes, or fails with a description and reason.
+-}
+type UnitTestExpectation
+    = UnitTestPass
+    | UnitTestFail UnitTestFailData
+
+
+{-| Information about a unit test failure.
+
+`UnitTestFailData` is opaque for future extensibility. It contains the following:
+
+  - `description : String`. The failure as described by the [`Expect`](Expect) module.
+  - `reason : Reason`. See the [`Reason`](Test.Runner.Failure#Reason) type.
+
+Use the various `get*` functions to access each field.
+
+-}
+type UnitTestFailData
+    = UnitTestFailData
+        { description : String
+        , reason : Reason
+        }
+
+
+{-| Get the failure description.
+-}
+getUnitTestFailDescription : UnitTestFailData -> String
+getUnitTestFailDescription (UnitTestFailData data) =
+    data.description
+
+
+{-| Get the failure reason.
+-}
+getUnitTestFailReason : UnitTestFailData -> Reason
+getUnitTestFailReason (UnitTestFailData data) =
+    data.reason
+
+
+{-| A fuzz test either passes or fails. In both cases there can be a distribution report.
+In case of failures, there is a description and reason just like for unit tests, but also
+a few more fuzz-specific fields – see [FuzzTestFailData](#FuzzTestFailData).
+-}
+type FuzzTestExpectation
+    = FuzzTestPass FuzzTestPassData
+    | FuzzTestFail FuzzTestFailData
+
+
+{-| `FuzzTestFailData` is opaque for future extensibility. It contains the following:
+
+  - `distributionReport : DistributionReport`. See the [`DistributionReport`](Test.Distribution#DistributionReport) type.
+
+Use the various `get*` functions to access each field.
+
+-}
+type FuzzTestPassData
+    = FuzzTestPassData DistributionReport
+
+
+{-| Get the distribution report from a passing test.
+-}
+getFuzzTestPassDistributionReport : FuzzTestPassData -> DistributionReport
+getFuzzTestPassDistributionReport (FuzzTestPassData distributionReport) =
+    distributionReport
+
+
+{-| Information about a fuzz test failure.
+
+`FuzzTestFailData` is opaque for future extensibility. It contains the following:
+
+  - `description : String`. The failure as described by the [`Expect`](Expect) module.
+  - `reason : Reason`. See the [`Reason`](Test.Runner.Failure#Reason) type.
+  - `distributionReport : DistributionReport`. See the [`DistributionReport`](Test.Distribution#DistributionReport) type.
+  - `given : Maybe String`. This is the input to the test function that caused the failure, formatted with `Debug.toString`.
+    A fuzz test can in unusual circumstances fail to even produce a `given` value, which is why it is `Maybe`.
+  - `fuzzerInts : List Int`. This is the internal fuzzer state that produced `given`. A runner can pass this
+    to [runFuzzTest](#runFuzzTest) to reproduce a previous failure.
+  - `runsElapsed : Int`. How many values the fuzzer generated before uncovering this failure.
+
+Use the various `getFuzzTestFail*` functions to access each field.
+
+-}
+type FuzzTestFailData
+    = FuzzTestFailData
+        { description : String
+        , reason : Reason
+        , distributionReport : DistributionReport
+        , given : Maybe String
+        , fuzzerInts : List Int
+        , runsElapsed : Int
+        }
+
+
+{-| Get the failure description.
+-}
+getFuzzTestFailDescription : FuzzTestFailData -> String
+getFuzzTestFailDescription (FuzzTestFailData data) =
+    data.description
+
+
+{-| Get the failure reason.
+-}
+getFuzzTestFailReason : FuzzTestFailData -> Reason
+getFuzzTestFailReason (FuzzTestFailData data) =
+    data.reason
+
+
+{-| Get the distribution report from a failing test.
+-}
+getFuzzTestFailDistributionReport : FuzzTestFailData -> DistributionReport
+getFuzzTestFailDistributionReport (FuzzTestFailData data) =
+    data.distributionReport
+
+
+{-| Get the value that caused the test to fail.
+
+This is the input to the test function that caused the failure, formatted with `Debug.toString`.
+A fuzz test can in unusual circumstances fail to even produce a `given` value, which is why it is `Maybe`.
+
+-}
+getFuzzTestFailGiven : FuzzTestFailData -> Maybe String
+getFuzzTestFailGiven (FuzzTestFailData data) =
+    data.given
+
+
+{-| Get the internal fuzzer state that produced the test input that caused the failure.
+
+A runner can pass this to [runFuzzTest](#runFuzzTest) to reproduce a previous failure.
+
+-}
+getFuzzTestFailFuzzerInts : FuzzTestFailData -> List Int
+getFuzzTestFailFuzzerInts (FuzzTestFailData data) =
+    data.fuzzerInts
+
+
+{-| Get how many values the fuzzer generated before uncovering this failure.
+
+Note this can be larger than the number of runs the test was given: a test with
+an [`expectDistribution`](Test#expectDistribution) keeps generating values until
+the statistical check settles.
+
+-}
+getFuzzTestFailRunsElapsed : FuzzTestFailData -> Int
+getFuzzTestFailRunsElapsed (FuzzTestFailData data) =
+    data.runsElapsed
+
+
+{-| This lets runners tag tests with an identifier, which can be used to implement
+caching of test results.
+-}
+tagTest : String -> Test -> Test
+tagTest tag test =
+    Internal.ElmTestVariant__Tagged tag test
+        |> Internal.wrapTestVariant
+
+
+{-| This function allows runners to find exposed values of type `Test` without
+having to implement type inference. A runners can collect _all_ exposed values
+from a module, and then use this function to filter out the actual tests.
+-}
+identifyTest : a -> Maybe Test
+identifyTest =
+    Internal.identifyTest
+
+
+{-| Turns a nested [`Test`](Test#Test) (from [`Test.test`](Test#test), [`Test.fuzz`](Test#fuzz) etc.)
+into a flat structure that is easily consumable by runners.
+
+Runners can collect all exposed `Test` values, join them up into
+one single `Test` and then give it to this function. After that
+they can start executing tests.
+
+-}
+toTests : Test -> Tests
+toTests test =
+    Tests (toTestsHelper "" [] test)
+
+
+toTestsHelper : String -> List String -> Test -> TestsData
+toTestsHelper tag labels test =
+    case Internal.unwrapTestVariant test of
+        Internal.ElmTestVariant__UnitTest thunk ->
+            { unitTests =
+                Array.push
+                    (UnitTest
+                        { tag = tag
+                        , labels = labels
+                        , thunk = thunk
+                        }
+                    )
+                    Array.empty
+            , fuzzTests = Array.empty
+            , excludedDueToSkip = 0
+            , excludedDueToOnly = Nothing
+            }
+
+        Internal.ElmTestVariant__FuzzTest maybeRuns thunk ->
+            { unitTests = Array.empty
+            , fuzzTests =
+                Array.push
+                    (FuzzTest
+                        { tag = tag
+                        , labels = labels
+                        , thunk = thunk
+                        , runs = maybeRuns
+                        }
+                    )
+                    Array.empty
+            , excludedDueToSkip = 0
+            , excludedDueToOnly = Nothing
+            }
+
+        Internal.ElmTestVariant__Labeled label subTest ->
+            toTestsHelper tag (label :: labels) subTest
+
+        Internal.ElmTestVariant__Tagged newTag subTest ->
+            toTestsHelper newTag labels subTest
+
+        Internal.ElmTestVariant__Skipped subTest ->
+            { unitTests = Array.empty
+            , fuzzTests = Array.empty
+            , excludedDueToSkip = countSkipped subTest
+            , excludedDueToOnly = Nothing
+            }
+
+        Internal.ElmTestVariant__Only subTest ->
+            let
+                sub =
+                    toTestsHelper tag labels subTest
+            in
+            -- As an optimization, if `excludedDueToOnly` is already
+            -- the correct value (`Just n`), skip creating a new record.
+            if sub.excludedDueToOnly /= Nothing then
+                sub
+
+            else
+                -- Not using record update for performance.
+                { unitTests = sub.unitTests
+                , fuzzTests = sub.fuzzTests
+                , excludedDueToSkip = sub.excludedDueToSkip
+                , excludedDueToOnly = Just 0
+                }
+
+        Internal.ElmTestVariant__Batch subTests ->
+            subTests
+                |> List.foldl
+                    (\subTest acc ->
+                        let
+                            sub =
+                                toTestsHelper tag labels subTest
+
+                            excludedDueToSkip =
+                                acc.excludedDueToSkip + sub.excludedDueToSkip
+                        in
+                        -- Using nested `case` to avoid allocating a tuple.
+                        case acc.excludedDueToOnly of
+                            Just accOnly ->
+                                case sub.excludedDueToOnly of
+                                    Just subOnly ->
+                                        { unitTests = Array.append acc.unitTests sub.unitTests
+                                        , fuzzTests = Array.append acc.fuzzTests sub.fuzzTests
+                                        , excludedDueToSkip = excludedDueToSkip
+                                        , excludedDueToOnly = Just (accOnly + subOnly)
+                                        }
+
+                                    Nothing ->
+                                        { unitTests = acc.unitTests
+                                        , fuzzTests = acc.fuzzTests
+                                        , excludedDueToSkip = excludedDueToSkip
+                                        , excludedDueToOnly = Just (accOnly + Array.length sub.unitTests + Array.length sub.fuzzTests)
+                                        }
+
+                            Nothing ->
+                                case sub.excludedDueToOnly of
+                                    Just subOnly ->
+                                        { unitTests = sub.unitTests
+                                        , fuzzTests = sub.fuzzTests
+                                        , excludedDueToSkip = excludedDueToSkip
+                                        , excludedDueToOnly = Just (subOnly + Array.length acc.unitTests + Array.length acc.fuzzTests)
+                                        }
+
+                                    Nothing ->
+                                        { unitTests = Array.append acc.unitTests sub.unitTests
+                                        , fuzzTests = Array.append acc.fuzzTests sub.fuzzTests
+                                        , excludedDueToSkip = excludedDueToSkip
+                                        , excludedDueToOnly = Nothing
+                                        }
+                    )
+                    { unitTests = Array.empty
+                    , fuzzTests = Array.empty
+                    , excludedDueToSkip = 0
+                    , excludedDueToOnly = Nothing
+                    }
+
+
+countSkipped : Test -> Int
+countSkipped test =
+    case Internal.unwrapTestVariant test of
+        Internal.ElmTestVariant__UnitTest _ ->
+            1
+
+        Internal.ElmTestVariant__FuzzTest _ _ ->
+            1
+
+        Internal.ElmTestVariant__Labeled _ subTest ->
+            countSkipped subTest
+
+        Internal.ElmTestVariant__Tagged _ subTest ->
+            countSkipped subTest
+
+        Internal.ElmTestVariant__Skipped subTest ->
+            countSkipped subTest
+
+        Internal.ElmTestVariant__Only subTest ->
+            countSkipped subTest
+
+        Internal.ElmTestVariant__Batch tests ->
+            List.foldl (\subTest sum -> countSkipped subTest + sum) 0 tests
+
+
+toUnitTestExpectation : Expectation -> UnitTestExpectation
+toUnitTestExpectation expectation =
+    case expectation of
+        Pass _ ->
+            UnitTestPass
+
+        Fail { failData } ->
+            UnitTestFail (UnitTestFailData failData)
+
+
+toFuzzTestExpectation : Test.Expectation.FuzzTestExpectation -> FuzzTestExpectation
+toFuzzTestExpectation expectation =
+    case expectation of
+        Test.Expectation.FuzzTestPass distributionReport ->
+            FuzzTestPass (FuzzTestPassData distributionReport)
+
+        Test.Expectation.FuzzTestFail data ->
+            FuzzTestFail
+                (FuzzTestFailData
+                    { description = data.description
+                    , reason = data.reason
+                    , distributionReport = data.distributionReport
+                    , given = data.given
+                    , fuzzerInts = RandomRun.toList data.randomRun
+                    , runsElapsed = data.runsElapsed
+                    }
+                )
+
+
+{-| It’s possible to write code like this:
+
+    defaultShape =
+        makeShape 3
+            |> Debug.log "shape"
+
+    myTest =
+        test "my test" <|
+            \() ->
+                defaultShape.sides
+                    |> Expect.equal 3
+
+In this case, `defaultShape` will be evaluated before the test is run!
+This is due to Elm being an eager language and what the generated JavaScript looks like.
+
+This means that when a test runner starts running its Elm code, there might already
+be a few debug logs made. This task lets you retrieve them.
+
+If you set `globalThis.elmTestPrintDebugLogsBeforeFirstTestToConsole` to a truthy
+value, these debug logs will be printed to the console, and the returned `DebugLogs`
+here will be empty. Runners might want to do this when using the
+[runUnitTestWithUnbufferedLogs](#runUnitTestWithUnbufferedLogs) and
+[runFuzzTestWithUnbufferedLogs](#runFuzzTestWithUnbufferedLogs) functions,
+to consistently print all debug logs to the console.
+
+-}
+getDebugLogsBeforeFirstTestRun : Task x String
+getDebugLogsBeforeFirstTestRun =
+    Test.Internal.DebugLogs.getDebugLogsBeforeFirstTestRun
diff --git a/tests/src/RunnerV2Tests.elm b/tests/src/RunnerV2Tests.elm
new file mode 100644
index 00000000..d93e43d9
--- /dev/null
+++ b/tests/src/RunnerV2Tests.elm
@@ -0,0 +1,260 @@
+module RunnerV2Tests exposing (all)
+
+import Array
+import Expect
+import Fuzz
+import Helpers exposing (expectPass)
+import Json.Encode
+import Test exposing (..)
+import Test.RunnerV2 as Runner exposing (Tests, UnitTestExpectation(..))
+
+
+all : Test
+all =
+    describe "Test.RunnerV2"
+        [ describe "toTests"
+            [ test "an only inside another only should ignore the non-only siblings" <|
+                \_ ->
+                    let
+                        suite =
+                            describe "three tests"
+                                [ test "passes" expectPass
+                                , Test.only <|
+                                    describe "two tests"
+                                        [ test "fails" testImpl
+                                        , Test.only (test "is an only" testImpl)
+                                        ]
+                                ]
+                    in
+                    toTests suite
+                        |> Expect.equal
+                            { excludedDueToSkip = 0
+                            , excludedDueToOnly = Just 2
+                            , unitTestsLabels = [ [ "three tests", "two tests", "is an only" ] ]
+                            , fuzzTestsLabels = []
+                            }
+            , test "should keep all only tests spread among siblings" <|
+                \_ ->
+                    let
+                        suite =
+                            describe "root"
+                                [ test "A" expectPass
+                                , describe "B"
+                                    [ Test.only (test "1" testImpl)
+                                    ]
+                                , Test.only <|
+                                    describe "C"
+                                        [ test "1" testImpl
+                                        , Test.only (test "2" testImpl)
+                                        , describe "3"
+                                            [ test "X" testImpl
+                                            , Test.only (test "Y" testImpl)
+                                            , test "Z" testImpl
+                                            ]
+                                        ]
+                                , describe "D"
+                                    [ Test.only (test "1" testImpl)
+                                    ]
+                                ]
+                    in
+                    toTests suite
+                        |> Expect.equal
+                            { excludedDueToSkip = 0
+                            , excludedDueToOnly = Just 4
+                            , unitTestsLabels =
+                                [ [ "root", "B", "1" ]
+                                , [ "root", "C", "2" ]
+                                , [ "root", "C", "3", "Y" ]
+                                , [ "root", "D", "1" ]
+                                ]
+                            , fuzzTestsLabels = []
+                            }
+            , test "a skip inside an only takes effect" <|
+                \_ ->
+                    let
+                        suite =
+                            describe "three tests"
+                                [ test "passes" expectPass
+                                , Test.only <|
+                                    describe "two tests"
+                                        [ test "fails" testImpl
+                                        , Test.skip (test "is skipped" testImpl)
+                                        ]
+                                ]
+                    in
+                    toTests suite
+                        |> Expect.equal
+                            { excludedDueToSkip = 1
+                            , excludedDueToOnly = Just 1
+                            , unitTestsLabels = [ [ "three tests", "two tests", "fails" ] ]
+                            , fuzzTestsLabels = []
+                            }
+            , test "an only inside a skip has no effect" <|
+                \_ ->
+                    let
+                        suite =
+                            describe "three tests"
+                                [ test "passes" expectPass
+                                , Test.skip <|
+                                    describe "two tests"
+                                        [ test "fails" testImpl
+                                        , Test.only (test "is skipped" testImpl)
+                                        ]
+                                ]
+                    in
+                    toTests suite
+                        |> Expect.equal
+                            { excludedDueToSkip = 2
+                            , excludedDueToOnly = Nothing
+                            , unitTestsLabels = [ [ "three tests", "passes" ] ]
+                            , fuzzTestsLabels = []
+                            }
+            , test "a skip inside another skip has no effect" <|
+                \_ ->
+                    let
+                        suite =
+                            describe "three tests"
+                                [ test "passes" expectPass
+                                , Test.skip <|
+                                    describe "two tests"
+                                        [ test "fails" testImpl
+                                        , Test.skip (test "is skipped" testImpl)
+                                        ]
+                                ]
+                    in
+                    toTests suite
+                        |> Expect.equal
+                            { excludedDueToSkip = 2
+                            , excludedDueToOnly = Nothing
+                            , unitTestsLabels = [ [ "three tests", "passes" ] ]
+                            , fuzzTestsLabels = []
+                            }
+            , test "when all tests are skipped, we get empty arrays of tests" <|
+                \_ ->
+                    toTests (Test.skip <| test "passes" expectPass)
+                        |> Expect.equal
+                            { excludedDueToSkip = 1
+                            , excludedDueToOnly = Nothing
+                            , unitTestsLabels = []
+                            , fuzzTestsLabels = []
+                            }
+            , test "a test that does not use only or skip is marked as having seen neither of those" <|
+                \_ ->
+                    toTests (test "passes" expectPass)
+                        |> Expect.equal
+                            { excludedDueToSkip = 0
+                            , excludedDueToOnly = Nothing
+                            , unitTestsLabels = [ [ "passes" ] ]
+                            , fuzzTestsLabels = []
+                            }
+            ]
+        , describe "tagTests"
+            [ test "runners can tag tests with an identifier of choice" <|
+                \() ->
+                    let
+                        suite =
+                            concat
+                                [ Runner.tagTest "tag1" (test "standalone test" testImpl)
+                                , Runner.tagTest "tag2"
+                                    (describe "describe"
+                                        [ test "nested" testImpl
+                                        ]
+                                    )
+                                , Runner.tagTest "tag3"
+                                    (concat
+                                        [ test "concatenated" testImpl
+                                        ]
+                                    )
+                                ]
+                    in
+                    Runner.toTests suite
+                        |> Runner.getUnitTests
+                        |> Array.toList
+                        |> List.map
+                            (\unitTest ->
+                                ( Runner.getUnitTestLabels unitTest |> List.reverse
+                                , Runner.getUnitTestTag unitTest
+                                )
+                            )
+                        |> Expect.equal
+                            [ ( [ "standalone test" ], "tag1" )
+                            , ( [ "describe", "nested" ], "tag2" )
+                            , ( [ "concatenated" ], "tag3" )
+                            ]
+            ]
+        , describe "identifyTest"
+            [ test "it identifies all variants of tests" <|
+                \() ->
+                    let
+                        tests =
+                            [ test "test" testImpl
+                            , fuzz "fuzz" Fuzz.int testImpl
+                            , fuzz2 "fuzz2" Fuzz.int Fuzz.int (\_ -> testImpl)
+                            , fuzz3 "fuzz2" Fuzz.int Fuzz.int Fuzz.int (\_ _ -> testImpl)
+                            , fuzzWith "fuzzWith" { distribution = noDistribution, runs = 1 } Fuzz.int testImpl
+                            , only (test "only" testImpl)
+                            , skip (test "skip" testImpl)
+                            , describe "describe" [ test "described" testImpl ]
+                            , concat [ test "concat" testImpl ]
+                            , Runner.tagTest "tag" (test "tagged" testImpl)
+                            , todo "todo"
+                            ]
+                    in
+                    tests
+                        |> List.filterMap Runner.identifyTest
+                        |> Expect.equalLists tests
+            , test "it returns Nothing for other types of values" <|
+                \() ->
+                    let
+                        notTests =
+                            [ Runner.identifyTest ()
+                            , Runner.identifyTest Json.Encode.null
+                            , Runner.identifyTest False
+                            , Runner.identifyTest 0
+                            , Runner.identifyTest 1.5
+                            , Runner.identifyTest ""
+                            , Runner.identifyTest ' '
+                            , Runner.identifyTest []
+                            , Runner.identifyTest {}
+                            , Runner.identifyTest Nothing
+                            , Runner.identifyTest Just
+                            ]
+                    in
+                    notTests
+                        |> List.filterMap identity
+                        |> Expect.equalLists []
+            ]
+        ]
+
+
+toTests :
+    Test
+    ->
+        { excludedDueToSkip : Int
+        , excludedDueToOnly : Maybe Int
+        , unitTestsLabels : List (List String)
+        , fuzzTestsLabels : List (List String)
+        }
+toTests test =
+    let
+        tests =
+            Runner.toTests test
+    in
+    { excludedDueToSkip = Runner.getExcludedDueToSkip tests
+    , excludedDueToOnly = Runner.getExcludedDueToOnly tests
+    , unitTestsLabels =
+        Runner.getUnitTests tests
+            |> Array.toList
+            |> List.map (Runner.getUnitTestLabels >> List.reverse)
+    , fuzzTestsLabels =
+        Runner.getFuzzTests tests
+            |> Array.toList
+            |> List.map (Runner.getFuzzTestLabels >> List.reverse)
+    }
+
+
+{-| Dummy test implementation.
+-}
+testImpl : a -> Expect.Expectation
+testImpl _ =
+    Expect.pass
diff --git a/tests/src/Tests.elm b/tests/src/Tests.elm
index eacfd3cf..1310b8ee 100644
--- a/tests/src/Tests.elm
+++ b/tests/src/Tests.elm
@@ -8,6 +8,7 @@ import Helpers exposing (..)
 import Random
 import RandomRunTests
 import RunnerTests
+import RunnerV2Tests
 import RuntimeExceptionTests
 import ShrinkingChallengeTests exposing (shrinkingChallenges)
 import Test exposing (..)
@@ -31,6 +32,7 @@ all =
         , fuzzerTests
         , floatWithinTests
         , RunnerTests.all
+        , RunnerV2Tests.all
         , RuntimeExceptionTests.all
         , elmHtmlTests
         , shrinkingChallenges