@reventlessdev/reventless-seed 1.0.0-alpha.5 → 1.0.0-alpha.7

package/lib/bs/tests/Seed_RandomTest.res.mjs

@@ -0,0 +1,208 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Seed_Random$ReventlessSeed from "../src/Seed_Random.res.mjs";
+
+globalThis.describe("Seed_Random:", () => {
+  let take = (seed, n) => {
+    let r = Seed_Random$ReventlessSeed.make(seed);
+    return Stdlib_Array.make(n, 0.0).map(param => Seed_Random$ReventlessSeed.float(r));
+  };
+  globalThis.describe("reproducibility — the reason this module exists:", () => {
+    globalThis.test("the same seed replays the same sequence", () => {
+      globalThis.expect(take(42, 25)).toEqual(take(42, 25));
+    });
+    globalThis.test("different seeds diverge", () => {
+      globalThis.expect(Primitive_object.equal(take(42, 25), take(43, 25))).toBe(false);
+    });
+    globalThis.test("a fresh generator does not continue the previous one", () => {
+      let r = Seed_Random$ReventlessSeed.make(7);
+      let first = Seed_Random$ReventlessSeed.float(r);
+      Seed_Random$ReventlessSeed.float(r);
+      globalThis.expect(Seed_Random$ReventlessSeed.float(Seed_Random$ReventlessSeed.make(7))).toEqual(first);
+    });
+  });
+  globalThis.describe("float stays a unit interval:", () => {
+    globalThis.test("every draw is in [0, 1)", () => {
+      globalThis.expect(take(99, 500).every(f => {
+        if (f >= 0.0) {
+          return f < 1.0;
+        } else {
+          return false;
+        }
+      })).toBe(true);
+    });
+    globalThis.test("and the draws are not all the same value", () => {
+      let draws = take(99, 100);
+      globalThis.expect(draws.some(f => f !== draws[0])).toBe(true);
+    });
+  });
+  globalThis.describe("int is inclusive on both ends, as documented:", () => {
+    let draws = (min, max, n) => {
+      let r = Seed_Random$ReventlessSeed.make(5);
+      return Stdlib_Array.make(n, 0).map(param => Seed_Random$ReventlessSeed.int(r, min, max));
+    };
+    globalThis.test("never escapes the range", () => {
+      globalThis.expect(draws(3, 7, 500).every(i => {
+        if (i >= 3) {
+          return i <= 7;
+        } else {
+          return false;
+        }
+      })).toBe(true);
+    });
+    globalThis.test("reaches both bounds", () => {
+      let d = draws(3, 7, 500);
+      globalThis.expect([
+        d.includes(3),
+        d.includes(7)
+      ]).toEqual([
+        true,
+        true
+      ]);
+    });
+    globalThis.test("a single-value range is that value", () => {
+      globalThis.expect(draws(4, 4, 10).every(i => i === 4)).toBe(true);
+    });
+  });
+  globalThis.describe("pick:", () => {
+    globalThis.test("returns None for an empty array", () => {
+      globalThis.expect(Seed_Random$ReventlessSeed.pick(Seed_Random$ReventlessSeed.make(1), [])).toEqual(undefined);
+    });
+    globalThis.test("always lands on a member", () => {
+      let r = Seed_Random$ReventlessSeed.make(2);
+      let xs = [
+        "a",
+        "b",
+        "c",
+        "d"
+      ];
+      let hits = Stdlib_Array.make(200, "").map(param => Seed_Random$ReventlessSeed.pickOr(r, "MISS", xs));
+      globalThis.expect(hits.every(h => xs.includes(h))).toBe(true);
+    });
+    globalThis.test("pickOr falls back only when there is nothing to pick", () => {
+      globalThis.expect(Seed_Random$ReventlessSeed.pickOr(Seed_Random$ReventlessSeed.make(3), "fallback", [])).toBe("fallback");
+    });
+  });
+  globalThis.describe("sampleWeighted is without replacement:", () => {
+    let equal = xs => xs.map(x => [
+      x,
+      1.0
+    ]);
+    globalThis.test("count = length yields a permutation, not a multiset", () => {
+      let xs = [
+        "a",
+        "b",
+        "c",
+        "d",
+        "e"
+      ];
+      let out = Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(11), equal(xs), 5);
+      let sorted = out.toSorted(Primitive_string.compare);
+      globalThis.expect([
+        out.length,
+        sorted
+      ]).toEqual([
+        5,
+        [
+          "a",
+          "b",
+          "c",
+          "d",
+          "e"
+        ]
+      ]);
+    });
+    globalThis.test("count < length returns exactly count distinct items", () => {
+      let xs = [
+        "a",
+        "b",
+        "c",
+        "d",
+        "e"
+      ];
+      let out = Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(12), equal(xs), 3);
+      let distinct = new Set(out).size;
+      globalThis.expect([
+        out.length,
+        distinct
+      ]).toEqual([
+        3,
+        3
+      ]);
+    });
+    globalThis.test("count > length clamps to the pool", () => {
+      globalThis.expect(Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(13), equal([
+        "a",
+        "b"
+      ]), 99).length).toBe(2);
+    });
+    globalThis.test("a zero-weight entry is never chosen while others remain", () => {
+      let out = Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(14), [
+        [
+          "never",
+          0.0
+        ],
+        [
+          "a",
+          1.0
+        ],
+        [
+          "b",
+          1.0
+        ]
+      ], 2);
+      globalThis.expect(out.includes("never")).toBe(false);
+    });
+    globalThis.test("is reproducible for a given seed", () => {
+      let run = () => Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(15), equal([
+        "a",
+        "b",
+        "c",
+        "d",
+        "e",
+        "f"
+      ]), 4);
+      globalThis.expect(run()).toEqual(run());
+    });
+  });
+  globalThis.describe("zipfWeights skews toward the head:", () => {
+    let weights = Seed_Random$ReventlessSeed.zipfWeights([
+      "a",
+      "b",
+      "c",
+      "d",
+      "e"
+    ], 1.1);
+    globalThis.test("keeps every item, in order", () => {
+      globalThis.expect(weights.map(param => param[0])).toEqual([
+        "a",
+        "b",
+        "c",
+        "d",
+        "e"
+      ]);
+    });
+    globalThis.test("weight decreases monotonically with rank", () => {
+      let ws = weights.map(param => param[1]);
+      let decreasing = ws.every((w, i) => {
+        if (i === 0) {
+          return true;
+        } else {
+          return w < ws[i - 1 | 0];
+        }
+      });
+      globalThis.expect(decreasing).toBe(true);
+    });
+    globalThis.test("the leader is clear — first outweighs last several times over", () => {
+      let first = Stdlib_Option.mapOr(weights[0], 0.0, param => param[1]);
+      let last = Stdlib_Option.mapOr(weights[4], 0.0, param => param[1]);
+      globalThis.expect(first > last * 3.0).toBe(true);
+    });
+  });
+});
+
+/*  Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785495045271)
-#Done(1785495045300)
+#Start(1785603404546)
+#Done(1785603404581)

package/lib/ocaml/ReventlessSeed.mlmap

@@ -4,7 +4,7 @@ Seed_Client
 Seed_Connect
 Seed_Prompt
 Seed_Random
+Seed_RandomTest
 Seed_Runner
 Seed_Types
 Seed_Upload
-UploadEndpointResolutionTest

package/lib/ocaml/Seed.res

@@ -14,13 +14,12 @@ module Connect = Seed_Connect
 
 exception Failed = Seed_Types.Failed
 
-// A live target a data set seeds against: an authenticated client, the
-// deployment's upload endpoints (the legacy single service and the per-store
-// map, either of which may be empty), and a label.
+// A live target a data set seeds against: an authenticated client, whether uploads
+// are skipped this run, and a label. Uploads mint through the domain API's
+// `Upload_Presign` mutation on the client (route B), so no upload endpoint is carried.
 type connection = Seed_Connect.connection = {
   client: Seed_Client.t,
-  uploadEndpoint: string,
-  uploadEndpoints: dict<string>,
+  uploadsSkipped: bool,
   label: string,
 }
 

package/lib/ocaml/Seed_Client.res

@@ -43,6 +43,10 @@ let make = (~config: config): t => {config, token: None}
     Seed.Upload) can authenticate side-channel requests with the same identity. */
 let currentToken = (t: t): option<string> => t.token
 
+/** The GraphQL endpoint this client targets — so `Seed.Upload` can resolve a
+    relative presigned `uploadUrl` against the same origin. */
+let endpoint = (t: t): string => t.config.endpoint
+
 /** Injects a bearer obtained out-of-band (e.g. a Cognito id token), instead of
     minting one via `login`. Provider-agnostic: the harness only cares that the
     token is a valid bearer for `endpoint`. */

package/lib/ocaml/Seed_Connect.res

@@ -9,15 +9,13 @@
 
 open Seed_Types
 
-// `uploadEndpoint` is the legacy single presign service (and the local dev
-// server's one upload route); `uploadEndpoints` maps the qualified
-// `{plugin}.{store}` of each declared store to its own presign endpoint. Both,
-// because a deployment may publish either or both — see `Seed_Upload.endpointFor`
-// for the resolution between them.
+// Under route B the client mints uploads through the domain API's `Upload_Presign`
+// mutation (authenticated by the same bearer as commands), so a connection needs no
+// upload endpoint — just the authenticated client and whether uploads are skipped this
+// run (`SEED_SKIP_UPLOADS`). Which store an asset uploads into is the caller's `~store`.
 type connection = {
   client: Seed_Client.t,
-  uploadEndpoint: string,
-  uploadEndpoints: dict<string>,
+  uploadsSkipped: bool,
   label: string,
 }
 
@@ -29,48 +27,20 @@ type connection = {
 let make = async (
   ~label: string,
   ~endpoint: string,
-  ~uploadEndpoint: string,
-  ~uploadEndpoints: dict<string>=Dict.make(),
   ~login: (~username: string, ~password: string) => promise<string>,
   ~localDefaults: bool=false,
 ): connection => {
-  // `SEED_SKIP_UPLOADS` forces the connection to carry no upload endpoint at
-  // all, so a data set's upload phase no-ops the same way it does when a
-  // deployment serves none. Use it to seed domain data fast, or to skip a
-  // broken/absent upload path without editing the data set. It is the single
-  // knob: an empty `REVENTLESS_UPLOAD_ENDPOINT` env reads as "unset" (falls back
-  // to discovery), so this is the reliable way to disable uploads — which means
-  // it has to clear the per-store map too, or a declared store keeps uploading
-  // through it.
-  let skip = Seed_Prompt.envValue("SEED_SKIP_UPLOADS")->Option.isSome
-  let uploadEndpoint = skip ? "" : uploadEndpoint
-  let uploadEndpoints = skip ? Dict.make() : uploadEndpoints
+  // `SEED_SKIP_UPLOADS` forces the upload phase to no-op — seed domain data fast, or
+  // skip a broken/absent upload path without editing the data set. The data set reads
+  // `connection.uploadsSkipped` and reports the skip.
+  let uploadsSkipped = Seed_Upload.uploadsSkipped()
   let (username, password) = await Seed_Prompt.credentials(~localDefaults)
   let token = await login(~username, ~password)
   let client = Seed_Client.make(~config={endpoint: endpoint})
   client->Seed_Client.useToken(token)
-  {client, uploadEndpoint, uploadEndpoints, label}
+  {client, uploadsSkipped, label}
 }
 
-/**
- * The endpoint an asset destined for `store` uploads through, or the reason
- * there is none — the message to report when the upload phase skips.
- *
- * `store` is the qualified `{plugin}.{store}` the asset's field declares, e.g.
- * `"Catalog.productImages"`. Resolution is `Seed_Upload.endpointFor`; naming a
- * store the deployment does not serve falls back to the legacy single service
- * rather than to another store's endpoint.
- */
-let uploadEndpointFor = (c: connection, ~store: string): result<string, string> =>
-  switch Seed_Upload.endpointFor(
-    ~store,
-    ~uploadEndpoint=c.uploadEndpoint,
-    ~uploadEndpoints=c.uploadEndpoints,
-  ) {
-  | Some(endpoint) => Ok(endpoint)
-  | None => Error(Seed_Upload.unresolvedReason(~store, ~uploadEndpoints=c.uploadEndpoints))
-  }
-
 /**
  * A login function backed by an HTTP login endpoint (the local dev
  * `/__inmemory/login` shape: POST `{username, password}` → `{token}`). Reuses
@@ -98,24 +68,18 @@ let envOr = (key: string, fallback: string): string =>
  * defaults baked in and overridable per endpoint (arg, then env var, then
  * default). Empty input at the credential prompt falls back to `admin`/`admin`.
  *
- * No per-store map: the local dev server serves every store through its one
- * upload route, so a data set naming a store resolves to that route by the
- * "declares a store with no matching endpoint" row.
+ * No upload endpoint: uploads mint through the domain API's `Upload_Presign` mutation
+ * on the same `graphql` endpoint, with the store passed per asset.
  */
-let local = (~graphql=?, ~upload=?, ~login=?, ()): (unit => promise<connection>) => {
+let local = (~graphql=?, ~login=?, ()): (unit => promise<connection>) => {
   let endpoint =
     graphql->Option.getOr(envOr("REVENTLESS_GRAPHQL_ENDPOINT", "http://localhost:4000/graphql"))
-  let uploadEndpoint =
-    upload->Option.getOr(
-      envOr("REVENTLESS_UPLOAD_ENDPOINT", "http://localhost:4000/__inmemory/upload"),
-    )
   let loginEndpoint =
     login->Option.getOr(envOr("REVENTLESS_LOGIN_ENDPOINT", "http://localhost:4000/__inmemory/login"))
   () =>
     make(
       ~label="local",
       ~endpoint,
-      ~uploadEndpoint,
       ~login=viaLoginEndpoint(~loginEndpoint),
       ~localDefaults=true,
     )

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,23 +48,23 @@ 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
   }
 
 let requireTty = (): unit =>
-  if !(stdin->isTTY) {
+  if !(NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)) {
     throw(
       Failed(
         "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++
@@ -101,7 +91,7 @@ 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

package/lib/ocaml/Seed_RandomTest.res

@@ -0,0 +1,160 @@
+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)
+    })
+  })
+})