@reventlessdev/reventless-seed 1.0.0-alpha.2 → 1.0.0-alpha.21

package/lib/ocaml/Seed_ConnectTest.res

@@ -0,0 +1,64 @@
+open JestGlobals
+
+// `SEED_ROLE` is how a run says what to act as when nobody can answer a prompt —
+// a CI run wedged by a stored narrowing, or a deliberate restricted run.
+//
+// It carries two different intentions in one variable, which is why the parsing
+// is worth pinning: naming a role narrows to it, and the "give me everything"
+// answer has several spellings because an operator setting it by hand will write
+// whichever one comes to mind. Getting that wrong is not a typo — `SEED_ROLE=full`
+// read as a role named "full" would ask the platform to act as a group nobody
+// holds, and be refused.
+
+let withEnv = (value: option<string>, f: unit => unit) => {
+  let key = "SEED_ROLE"
+  let previous = NodeProcess.env->Dict.get(key)
+  switch value {
+  | Some(v) => NodeProcess.env->Dict.set(key, v)
+  | None => NodeProcess.env->Dict.delete(key)
+  }
+  f()
+  switch previous {
+  | Some(v) => NodeProcess.env->Dict.set(key, v)
+  | None => NodeProcess.env->Dict.delete(key)
+  }
+}
+
+describe("Seed_Connect.roleFromEnv:", () => {
+  testSync("is absent when nothing asked for a role", () =>
+    withEnv(None, () => expect(Seed_Connect.roleFromEnv())->Expect.toEqual(None))
+  )
+
+  testSync("reads a named role as a narrowing to it", () =>
+    withEnv(
+      Some("Shopper"),
+      () =>
+        expect(Seed_Connect.roleFromEnv())->Expect.toEqual(Some(Seed_Connect.Narrowed("Shopper"))),
+    )
+  )
+
+  // Every spelling of "everything" an operator might reach for. They all mean
+  // clear the stored choice, which is what seeding wants.
+  testSync("takes each spelling of full membership as a clear", () =>
+    ["full", "all", "none", "clear", "FULL", "All"]->Array.forEach(
+      v =>
+        withEnv(
+          Some(v),
+          () => expect(Seed_Connect.roleFromEnv())->Expect.toEqual(Some(Seed_Connect.Full)),
+        ),
+    )
+  )
+
+  // Role names are case-sensitive to the platform (`mayActAs` compares exactly),
+  // so a named role is passed through untouched — only the clear vocabulary is
+  // case-folded.
+  testSync("passes a role name through with its case intact", () =>
+    withEnv(
+      Some("Merchandiser"),
+      () =>
+        expect(Seed_Connect.roleFromEnv())->Expect.toEqual(
+          Some(Seed_Connect.Narrowed("Merchandiser")),
+        ),
+    )
+  )
+})

package/lib/ocaml/Seed_Prompt.res

@@ -1,7 +1,7 @@
 // One shared readline interface for every interactive prompt in a seed run.
 //
 // The reason this module exists: creating and closing a fresh `readline`
-// interface per prompt leaves stdin paused after the first `close`, so the
+// interface per prompt leaves NodeProcess.stdin paused after the first `close`, so the
 // second prompt (password after username) never fires and the run hangs. A
 // single interface, created lazily and closed exactly once, avoids that — and a
 // `muted` gate on its output lets password entry reuse the same interface
@@ -14,18 +14,8 @@ open Seed_Types
 
 // ── Node bindings ─────────────────────────────────────────────────────────────
 
-type stream
-@val @scope("process") external stdin: stream = "stdin"
-@val @scope("process") external stdout: stream = "stdout"
-@send external writeStream: (stream, string) => unit = "write"
-@get external isTTY: stream => bool = "isTTY"
-@send external pauseStream: stream => unit = "pause"
-@send external unrefStream: stream => unit = "unref"
-
-@scope("process") @val external processEnv: dict<string> = "env"
-
 type rl
-type rlOptions = {input: stream, output: stream, terminal?: bool}
+type rlOptions = {input: NodeProcess.stream, output: NodeProcess.stream, terminal?: bool}
 @module("node:readline") external createInterface: rlOptions => rl = "createInterface"
 @send external question: (rl, string, string => unit) => unit = "question"
 @send external closeRl: rl => unit = "close"
@@ -42,10 +32,10 @@ let iface = (): rl =>
   switch rlRef.contents {
   | Some(rl) => rl
   | None =>
-    let rl = createInterface({input: stdin, output: stdout, terminal: true})
+    let rl = createInterface({input: NodeProcess.stdin, output: NodeProcess.stdout, terminal: true})
     rl->setWriteToOutput(s =>
       if !muted.contents {
-        stdout->writeStream(s)
+        NodeProcess.stdout->NodeProcess.write(s)
       }
     )
     rlRef := Some(rl)
@@ -58,27 +48,31 @@ let close = (): unit =>
     rl->closeRl
     rlRef := None
     // Closing the interface is not enough: a terminal-mode readline leaves
-    // stdin resumed and reffed, which keeps the event loop alive so the CLI
+    // NodeProcess.stdin resumed and reffed, which keeps the event loop alive so the CLI
     // never exits after seeding. Release it explicitly.
-    stdin->pauseStream
-    stdin->unrefStream
+    NodeProcess.stdin->NodeProcess.pause
+    NodeProcess.stdin->NodeProcess.unref
   | None => ()
   }
 
 // ── Env + TTY ─────────────────────────────────────────────────────────────────
 
 let envValue = (key: string): option<string> =>
-  switch processEnv->Dict.get(key) {
+  switch NodeProcess.env->Dict.get(key) {
   | Some(v) if v->String.trim != "" => Some(v->String.trim)
   | _ => None
   }
 
+/** Whether an interactive prompt is possible at all. Callers that can carry on
+    without an answer ask this first; a prompt nobody can answer is worse than a
+    default, because it turns a workable run into a hang or a throw. */
+let hasTty = (): bool => NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)
+
 let requireTty = (): unit =>
-  if !(stdin->isTTY) {
+  if !hasTty() {
     throw(
       Failed(
-        "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++
-        "env vars to run non-interactively.",
+        "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++ "env vars to run non-interactively.",
       ),
     )
   }
@@ -101,24 +95,41 @@ let askHidden = (query: string): promise<string> =>
     let rl = iface()
     rl->question(query, answer => {
       muted := false
-      stdout->writeStream("\n")
+      NodeProcess.stdout->NodeProcess.write("\n")
       resolve(answer)
     })
     muted := true
   })
 
+/**
+ * Whether an answer means yes — the one vocabulary, for the typed reply and the
+ * env var that stands in for it alike.
+ *
+ * It exists because those two drifted: a `[y/N]` prompt took `y`, and the env
+ * var beside it took only `1` or `yes`, so the obvious `SEED_RESET_CONFIRM=y`
+ * silently fell through to the interactive branch — which, on the CI runs the
+ * variable exists for, has no TTY and throws. Two spellings of one question are
+ * one spelling too many; callers ask this instead of comparing strings.
+ *
+ * Trimmed and case-folded, so `Yes`/` y ` answer the same as `y`.
+ */
+let isAffirmative = (answer: string): bool =>
+  switch answer->String.trim->String.toLowerCase {
+  | "y" | "yes" | "1" => true
+  | _ => false
+  }
+
 /**
  * Chooses one of `options` (a label paired with the value it selects).
  *
  * Auto-returns when there is a single option, so a lone data set or stack needs
  * no keypress. `env` (e.g. `SEED_SET`) preselects by matching label or 1-based
  * index, so CI runs without a TTY. Otherwise it prints a numbered menu.
+ *
+ * `defaultIndex` makes Enter a valid answer, selecting that 0-based option;
+ * without one every reply must name a choice.
  */
-let select = async (
-  ~title: string,
-  ~options: array<(string, 'a)>,
-  ~env=?,
-): 'a =>
+let select = async (~title: string, ~options: array<(string, 'a)>, ~env=?, ~defaultIndex=?): 'a =>
   switch options {
   | [(_, only)] => only
   | _ =>
@@ -145,15 +156,24 @@ let select = async (
       options->Array.forEachWithIndex(((label, _), i) =>
         Console.log(`  ${(i + 1)->Int.toString}) ${label}`)
       )
+      let fallback = defaultIndex->Option.flatMap(i => options->Array.get(i))
+      let hint = switch (defaultIndex, fallback) {
+      | (Some(i), Some(_)) => ` (default ${(i + 1)->Int.toString})`
+      | _ => ""
+      }
       let rec pick = async (): 'a => {
-        let answer = await ask(`\nSelect [1-${(options->Array.length)->Int.toString}]: `)
-        switch Int.fromString(answer) {
-        | Some(n) if n >= 1 && n <= options->Array.length =>
-          let (_, value) = options->Array.getUnsafe(n - 1)
-          value
+        let answer = await ask(`\nSelect [1-${options->Array.length->Int.toString}]${hint}: `)
+        switch (answer, fallback) {
+        | ("", Some((_, value))) => value
         | _ =>
-          Console.log("  Not a valid choice.")
-          await pick()
+          switch Int.fromString(answer) {
+          | Some(n) if n >= 1 && n <= options->Array.length =>
+            let (_, value) = options->Array.getUnsafe(n - 1)
+            value
+          | _ =>
+            Console.log("  Not a valid choice.")
+            await pick()
+          }
         }
       }
       await pick()
@@ -161,13 +181,30 @@ let select = async (
   }
 
 /**
- * Prompts for a username (visible) and password (echo muted).
+ * The account a run authenticated as, alongside every account the platform's
+ * accounts file declares.
  *
- * `REVENTLESS_DEMO_USER` / `REVENTLESS_DEMO_PASSWORD` skip the prompts. With
- * `localDefaults`, empty input falls back to `admin`/`admin` — the dev login.
+ * `accounts` is `[]` whenever no file was read — the
+ * `REVENTLESS_DEMO_USER`/`REVENTLESS_DEMO_PASSWORD` path bypasses it entirely,
+ * and so does typing both halves — so a consumer must handle empty rather than
+ * assume the file was there. `caller` is always populated, but carries no
+ * `groups` and no `userId` on those paths: nothing read them off a file.
  */
-let credentials = async (~localDefaults: bool=false): (string, string) => {
-  let username = switch envValue("REVENTLESS_DEMO_USER") {
+type resolved = {caller: Seed_Users.user, accounts: array<Seed_Users.user>}
+
+let typedUser = (~username: string, ~password: string): Seed_Users.user => {
+  username,
+  password,
+  groups: [],
+  userId: None,
+}
+
+// Typing both halves is the fallback, not the first offer: it is what happens
+// when the platform keeps no accounts file. `envUser` is threaded in so a
+// `REVENTLESS_DEMO_USER` that named nobody in the file still skips the username
+// prompt rather than asking for a name that was already given.
+let askCredentials = async (~localDefaults: bool, ~envUser: option<string>): Seed_Users.user => {
+  let username = switch envUser {
   | Some(u) => u
   | None =>
     requireTty()
@@ -181,8 +218,70 @@ let credentials = async (~localDefaults: bool=false): (string, string) => {
     let entered = await askHidden(localDefaults ? "Password [admin]: " : "Password: ")
     entered == "" && localDefaults ? "admin" : entered
   }
-  if username == "" || password == "" {
+  typedUser(~username, ~password)
+}
+
+// The accounts file the platform already keeps (`.reventless/users.yaml`, or
+// `SEED_USERS_FILE`). It records the password beside the username, so choosing
+// an account is the whole credential step — nothing is typed.
+//
+// A named `REVENTLESS_DEMO_USER` picks its entry directly; otherwise the file's
+// accounts are offered in the order it defines them, first as the default.
+// `None` means the file has nothing to offer and the caller should ask.
+//
+// The whole list travels back with the chosen account, not just the credentials
+// it supplied: the file is also the only place a demo owner's id can be looked
+// up, and reading it once to pick a login and never again is what let a data set
+// seed rows under ids nobody on the platform holds.
+let fromUsersFile = async (~envUser: option<string>): option<resolved> =>
+  switch Seed_Users.load(~path=?envValue("SEED_USERS_FILE")) {
+  | None => None
+  | Some((path, users)) =>
+    let chosen = switch envUser {
+    | Some(name) => users->Array.find(u => u.username == name)
+    | None =>
+      Some(
+        await select(
+          ~title=`User (${path}):`,
+          ~options=users->Array.map(u => (Seed_Users.label(u), u)),
+          ~env="SEED_USER",
+          ~defaultIndex=0,
+        ),
+      )
+    }
+    // Logged for every arm, including the single-account file that selects
+    // itself without a keypress: which identity seeded the data is the thing an
+    // operator checks when owner-scoped rows turn up under the wrong account.
+    chosen->Option.map(u => {
+      Console.log(`Logging in as ${u.username} (from ${path})`)
+      {caller: u, accounts: users}
+    })
+  }
+
+/**
+ * Resolves the credentials a seed run logs in with.
+ *
+ * `REVENTLESS_DEMO_USER` + `REVENTLESS_DEMO_PASSWORD` together are the
+ * non-interactive path and skip everything below. Otherwise the platform's
+ * `.reventless/users.yaml` supplies the accounts to choose from, and only a
+ * platform without one falls back to typing both halves — where, with
+ * `localDefaults`, empty input means `admin`/`admin`.
+ *
+ * Returns the resolved account rather than a pair, and the accounts file
+ * alongside it when there was one — see `resolved`.
+ */
+let credentials = async (~localDefaults: bool=false): resolved => {
+  let envUser = envValue("REVENTLESS_DEMO_USER")
+  let resolved = switch (envUser, envValue("REVENTLESS_DEMO_PASSWORD")) {
+  | (Some(username), Some(password)) => {caller: typedUser(~username, ~password), accounts: []}
+  | _ =>
+    switch await fromUsersFile(~envUser) {
+    | Some(resolved) => resolved
+    | None => {caller: await askCredentials(~localDefaults, ~envUser), accounts: []}
+    }
+  }
+  if resolved.caller.username == "" || resolved.caller.password == "" {
     throw(Failed("username and password are required."))
   }
-  (username, password)
+  resolved
 }

package/lib/ocaml/Seed_PromptTest.res

@@ -0,0 +1,55 @@
+open JestGlobals
+
+// `isAffirmative` is the one vocabulary for "yes", shared by a typed `[y/N]`
+// reply and by the env var that stands in for it on a run with no terminal.
+//
+// It exists because those two drifted: the prompt took `y`, the env var took
+// only the literals `1` and `yes`, and every other value — `y` included, and an
+// explicit `no` with it — fell through to the interactive branch, which throws
+// when there is no TTY. So the variable that exists to make the tool
+// non-interactive had two spellings that worked and a crash for the rest.
+//
+// The suite is written around the shape of that bug rather than around the
+// function: what must confirm, what must decline, and — the case that actually
+// broke CI — that declining is a normal answer and not a fall-through.
+
+describe("Seed_Prompt.isAffirmative:", () => {
+  testSync("takes the three spellings of yes", () => {
+    ["y", "yes", "1"]->Array.forEach(v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true))
+  })
+
+  // A prompt that prints `[y/N]` invites a capital as readily as a lowercase
+  // one, and an env var set by hand is written however the hand felt.
+  testSync("ignores case, so Y and YES answer as y does", () => {
+    ["Y", "Yes", "YES"]->Array.forEach(v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true))
+  })
+
+  testSync("ignores surrounding space", () => {
+    [" y", "y ", "  yes  "]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true),
+    )
+  })
+
+  // The half that matters most: every one of these is an ANSWER, and the caller
+  // reads it as "no". None may be mistaken for "nothing was said", which is what
+  // sent the old code to a prompt it could not open.
+  testSync("declines every spelling of no, capital N included", () => {
+    ["n", "N", "no", "No", "NO"]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false),
+    )
+  })
+
+  testSync("declines anything it does not recognise", () => {
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false),
+    )
+  })
+
+  // `true` is deliberately absent from the vocabulary above. Named here so that
+  // adding it is a decision someone takes against a failing test rather than a
+  // kindness someone slips in: the prompt this stands in for asks `[y/N]`, and a
+  // reply nobody would type at that prompt should not work around it either.
+  testSync("does not quietly grow a fourth spelling", () => {
+    expect(Seed_Prompt.isAffirmative("true"))->Expect.toBe(false)
+  })
+})

package/lib/ocaml/Seed_Random.res

@@ -10,13 +10,15 @@ type t = {mutable state: int}
 
 let make = (~seed: int): t => {state: seed}
 
-
 /** mulberry32 — small, fast, and stable across JS engines and Node versions. */
 let float = (r: t): float => {
   r.state = (r.state + 0x6d2b79f5)->Int.bitwiseOr(0)
   let a = r.state
   let b = imul(a->Int.bitwiseXor(a->Int.shiftRightUnsigned(15)), a->Int.bitwiseOr(1))
-  let c = b->Int.bitwiseXor(b + imul(b->Int.bitwiseXor(b->Int.shiftRightUnsigned(7)), b->Int.bitwiseOr(61)))
+  let c =
+    b->Int.bitwiseXor(
+      b + imul(b->Int.bitwiseXor(b->Int.shiftRightUnsigned(7)), b->Int.bitwiseOr(61)),
+    )
   let bits = c->Int.bitwiseXor(c->Int.shiftRightUnsigned(14))
   // `bits` is a signed 32-bit result; fold the sign bit back in to get the
   // unsigned value a `>>> 0` would produce.

package/lib/ocaml/Seed_RandomTest.res

@@ -0,0 +1,200 @@
+open JestGlobals
+
+// `Seed_Random` exists so that two seed runs against a fresh store produce the
+// same data — that is what makes a seeded store usable as a screenshot baseline
+// or a comparison target. Its correctness is therefore not "looks random" but
+// "repeats exactly, and stays inside the bounds it advertises".
+//
+// The suite is written around that: every case below fails for a generator that
+// is subtly non-reproducible or that walks out of its range, and none of them
+// would notice a change of algorithm that kept both properties.
+
+describe("Seed_Random:", () => {
+  let take = (~seed, ~n) => {
+    let r = Seed_Random.make(~seed)
+    Array.make(~length=n, 0.0)->Array.map(_ => Seed_Random.float(r))
+  }
+
+  describe("reproducibility — the reason this module exists:", () => {
+    testSync(
+      "the same seed replays the same sequence",
+      () => expect(take(~seed=42, ~n=25))->toEqual(take(~seed=42, ~n=25)),
+    )
+
+    // Without this, a generator that returned a constant would satisfy the
+    // case above and nothing else in the suite would catch it.
+    testSync(
+      "different seeds diverge",
+      () => expect(take(~seed=42, ~n=25) == take(~seed=43, ~n=25))->toBe(false),
+    )
+
+    testSync(
+      "a fresh generator does not continue the previous one",
+      () => {
+        let r = Seed_Random.make(~seed=7)
+        let first = Seed_Random.float(r)
+        let _ = Seed_Random.float(r)
+        expect(Seed_Random.float(Seed_Random.make(~seed=7)))->toEqual(first)
+      },
+    )
+  })
+
+  describe("float stays a unit interval:", () => {
+    // mulberry32's last step is a signed 32-bit value folded back to unsigned.
+    // Get that fold wrong and roughly half the draws come out negative, which
+    // every consumer below (int, pick, sampleWeighted) silently mis-scales.
+    testSync(
+      "every draw is in [0, 1)",
+      () => expect(take(~seed=99, ~n=500)->Array.every(f => f >= 0.0 && f < 1.0))->toBe(true),
+    )
+
+    testSync(
+      "and the draws are not all the same value",
+      () => {
+        let draws = take(~seed=99, ~n=100)
+        expect(draws->Array.some(f => f != draws->Array.getUnsafe(0)))->toBe(true)
+      },
+    )
+  })
+
+  describe("int is inclusive on both ends, as documented:", () => {
+    let draws = (~min, ~max, ~n) => {
+      let r = Seed_Random.make(~seed=5)
+      Array.make(~length=n, 0)->Array.map(_ => Seed_Random.int(r, ~min, ~max))
+    }
+
+    testSync(
+      "never escapes the range",
+      () => expect(draws(~min=3, ~max=7, ~n=500)->Array.every(i => i >= 3 && i <= 7))->toBe(true),
+    )
+
+    // The documented contract is "inclusive on both ends"; an off-by-one in the
+    // `max - min + 1` scaling shows up as a bound that is never drawn.
+    testSync(
+      "reaches both bounds",
+      () => {
+        let d = draws(~min=3, ~max=7, ~n=500)
+        expect((d->Array.includes(3), d->Array.includes(7)))->toEqual((true, true))
+      },
+    )
+
+    testSync(
+      "a single-value range is that value",
+      () => expect(draws(~min=4, ~max=4, ~n=10)->Array.every(i => i == 4))->toBe(true),
+    )
+  })
+
+  describe("pick:", () => {
+    testSync(
+      "returns None for an empty array",
+      () => expect(Seed_Random.make(~seed=1)->Seed_Random.pick([]))->toEqual(None),
+    )
+
+    testSync(
+      "always lands on a member",
+      () => {
+        let r = Seed_Random.make(~seed=2)
+        let xs = ["a", "b", "c", "d"]
+        let hits =
+          Array.make(~length=200, "")->Array.map(_ => r->Seed_Random.pickOr(~fallback="MISS", xs))
+        expect(hits->Array.every(h => xs->Array.includes(h)))->toBe(true)
+      },
+    )
+
+    testSync(
+      "pickOr falls back only when there is nothing to pick",
+      () =>
+        expect(Seed_Random.make(~seed=3)->Seed_Random.pickOr(~fallback="fallback", []))->toBe(
+          "fallback",
+        ),
+    )
+  })
+
+  describe("sampleWeighted is without replacement:", () => {
+    let equal = xs => xs->Array.map(x => (x, 1.0))
+
+    // The documented shuffle use: equal weights, count = length. If sampling
+    // ever replaced instead of removing, duplicates would appear here.
+    testSync(
+      "count = length yields a permutation, not a multiset",
+      () => {
+        let xs = ["a", "b", "c", "d", "e"]
+        let out = Seed_Random.make(~seed=11)->Seed_Random.sampleWeighted(equal(xs), ~count=5)
+        let sorted = out->Array.toSorted(String.compare)
+        expect((out->Array.length, sorted))->toEqual((5, ["a", "b", "c", "d", "e"]))
+      },
+    )
+
+    testSync(
+      "count < length returns exactly count distinct items",
+      () => {
+        let xs = ["a", "b", "c", "d", "e"]
+        let out = Seed_Random.make(~seed=12)->Seed_Random.sampleWeighted(equal(xs), ~count=3)
+        let distinct = Set.fromArray(out)->Set.size
+        expect((out->Array.length, distinct))->toEqual((3, 3))
+      },
+    )
+
+    testSync(
+      "count > length clamps to the pool",
+      () =>
+        expect(
+          Seed_Random.make(~seed=13)
+          ->Seed_Random.sampleWeighted(equal(["a", "b"]), ~count=99)
+          ->Array.length,
+        )->toBe(2),
+    )
+
+    testSync(
+      "a zero-weight entry is never chosen while others remain",
+      () => {
+        let out =
+          Seed_Random.make(~seed=14)->Seed_Random.sampleWeighted(
+            [("never", 0.0), ("a", 1.0), ("b", 1.0)],
+            ~count=2,
+          )
+        expect(out->Array.includes("never"))->toBe(false)
+      },
+    )
+
+    testSync(
+      "is reproducible for a given seed",
+      () => {
+        let run = () =>
+          Seed_Random.make(~seed=15)->Seed_Random.sampleWeighted(
+            equal(["a", "b", "c", "d", "e", "f"]),
+            ~count=4,
+          )
+        expect(run())->toEqual(run())
+      },
+    )
+  })
+
+  describe("zipfWeights skews toward the head:", () => {
+    let weights = Seed_Random.zipfWeights(["a", "b", "c", "d", "e"], ~exponent=1.1)
+
+    testSync(
+      "keeps every item, in order",
+      () => expect(weights->Array.map(((item, _)) => item))->toEqual(["a", "b", "c", "d", "e"]),
+    )
+
+    testSync(
+      "weight decreases monotonically with rank",
+      () => {
+        let ws = weights->Array.map(((_, w)) => w)
+        let decreasing =
+          ws->Array.everyWithIndex((w, i) => i == 0 || w < ws->Array.getUnsafe(i - 1))
+        expect(decreasing)->toBe(true)
+      },
+    )
+
+    testSync(
+      "the leader is clear — first outweighs last several times over",
+      () => {
+        let first = weights->Array.get(0)->Option.mapOr(0.0, ((_, w)) => w)
+        let last = weights->Array.get(4)->Option.mapOr(0.0, ((_, w)) => w)
+        expect(first > last *. 3.0)->toBe(true)
+      },
+    )
+  })
+})