@reventlessdev/reventless-seed 1.0.0-alpha.20 → 1.0.0-alpha.22

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

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Seed_Client$ReventlessSeed from "../src/Seed_Client.res.mjs";
 
 function errors(entries) {
@@ -61,9 +63,11 @@ function b64url(payload) {
   return Buffer.from(payload, "utf8").toString("base64url");
 }
 
+let joseHeader = Buffer.from(`{"kid":"abc123","alg":"RS256"}`, "utf8").toString("base64url");
+
 function jwt(claims) {
   let payload = JSON.stringify(Object.fromEntries(claims));
-  return `header.` + Buffer.from(payload, "utf8").toString("base64url") + `.signature`;
+  return joseHeader + `.` + Buffer.from(payload, "utf8").toString("base64url") + `.signature`;
 }
 
 function localToken(claims) {
@@ -83,6 +87,21 @@ function clientWith(token) {
   return c;
 }
 
+globalThis.describe("Seed_Client.claims:", () => {
+  globalThis.test("skips the JOSE header and reads the payload behind it", () => {
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Seed_Client$ReventlessSeed.claims(clientWith(jwt([[
+        "sub",
+        "real-sub"
+      ]]))), c => c["sub"]), Stdlib_JSON.Decode.string)).toEqual("real-sub");
+  });
+  globalThis.test("takes the first segment when there is no header", () => {
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Seed_Client$ReventlessSeed.claims(clientWith(localToken([[
+        "userId",
+        "local-shopper"
+      ]]))), c => c["userId"]), Stdlib_JSON.Decode.string)).toEqual("local-shopper");
+  });
+});
+
 globalThis.describe("Seed_Client.effectiveGroups:", () => {
   globalThis.test("reads the payload wherever the provider put it", () => {
     globalThis.expect(Seed_Client$ReventlessSeed.effectiveGroups(clientWith(jwt([[
@@ -108,6 +127,50 @@ globalThis.describe("Seed_Client.effectiveGroups:", () => {
   });
 });
 
+globalThis.describe("Seed_Client.callerId:", () => {
+  globalThis.test("reads the id under whichever name the provider gave it", () => {
+    globalThis.expect(Seed_Client$ReventlessSeed.callerId(clientWith(jwt([[
+        "sub",
+        "4275e4a4-00c1-70e1"
+      ]])))).toEqual("4275e4a4-00c1-70e1");
+    globalThis.expect(Seed_Client$ReventlessSeed.callerId(clientWith(localToken([[
+        "userId",
+        "local-shopper"
+      ]])))).toEqual("local-shopper");
+  });
+  globalThis.test("prefers sub when a token carries both names", () => {
+    globalThis.expect(Seed_Client$ReventlessSeed.callerId(clientWith(jwt([
+      [
+        "sub",
+        "f215e4b4-30f1-700c"
+      ],
+      [
+        "userId",
+        "local-shopper"
+      ]
+    ])))).toEqual("f215e4b4-30f1-700c");
+  });
+  globalThis.test("says nothing about a token it cannot read, or one naming no id", () => {
+    globalThis.expect(Seed_Client$ReventlessSeed.callerId(clientWith("not-a-token"))).toEqual(undefined);
+    globalThis.expect(Seed_Client$ReventlessSeed.callerId(clientWith(jwt([[
+        "cognito:groups",
+        ["Admin"].map(prim => prim)
+      ]])))).toEqual(undefined);
+    globalThis.expect(Seed_Client$ReventlessSeed.callerId(Seed_Client$ReventlessSeed.make({
+      endpoint: "http://example.invalid/graphql"
+    }))).toEqual(undefined);
+  });
+  globalThis.test("refuses a claim that is not a single string", () => {
+    globalThis.expect(Seed_Client$ReventlessSeed.callerId(clientWith(jwt([[
+        "sub",
+        [
+          "a",
+          "b"
+        ].map(prim => prim)
+      ]])))).toEqual(undefined);
+  });
+});
+
 globalThis.describe("Seed_Client.identitySummary:", () => {
   globalThis.test("names the membership a narrowed token gave up", () => {
     globalThis.expect(Seed_Client$ReventlessSeed.identitySummary(clientWith(jwt([
@@ -138,6 +201,43 @@ globalThis.describe("Seed_Client.identitySummary:", () => {
   });
 });
 
+globalThis.describe("Seed_Client.narrowedFrom:", () => {
+  globalThis.test("names the membership a narrowed token was reduced from", () => {
+    globalThis.expect(Seed_Client$ReventlessSeed.narrowedFrom(clientWith(jwt([
+      [
+        "cognito:groups",
+        ["Shopper"].map(prim => prim)
+      ],
+      [
+        "availableRoles",
+        "Admin,Shopper"
+      ]
+    ])))).toEqual([
+      "Admin",
+      "Shopper"
+    ]);
+  });
+  globalThis.test("says nothing about an unnarrowed token", () => {
+    globalThis.expect(Seed_Client$ReventlessSeed.narrowedFrom(clientWith(jwt([[
+        "cognito:groups",
+        ["Shopper"].map(prim => prim)
+      ]])))).toEqual(undefined);
+    globalThis.expect(Seed_Client$ReventlessSeed.narrowedFrom(clientWith(jwt([[
+        "cognito:groups",
+        [
+          "Admin",
+          "Shopper"
+        ].map(prim => prim)
+      ]])))).toEqual(undefined);
+  });
+  globalThis.test("treats an empty availableRoles as not narrowed", () => {
+    globalThis.expect(Seed_Client$ReventlessSeed.narrowedFrom(clientWith(jwt([[
+        "availableRoles",
+        ""
+      ]])))).toEqual(undefined);
+  });
+});
+
 globalThis.describe("Seed_Client.isDenied:", () => {
   globalThis.test("recognises a refusal in either platform's vocabulary", () => {
     let entries = [errorOfType("Unauthorized")];
@@ -159,6 +259,7 @@ export {
   errors,
   errorOfType,
   b64url,
+  joseHeader,
   jwt,
   localToken,
   strings,

package/lib/bs/tests/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/bs/tests/Seed_ConnectTest.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Seed_Connect$ReventlessSeed from "../src/Seed_Connect.res.mjs";
+
+function withEnv(value, f) {
+  let key = "SEED_ROLE";
+  let previous = process.env[key];
+  if (value !== undefined) {
+    process.env[key] = value;
+  } else {
+    Stdlib_Dict.$$delete(process.env, key);
+  }
+  f();
+  if (previous !== undefined) {
+    process.env[key] = previous;
+    return;
+  } else {
+    return Stdlib_Dict.$$delete(process.env, key);
+  }
+}
+
+globalThis.describe("Seed_Connect.roleFromEnv:", () => {
+  globalThis.test("is absent when nothing asked for a role", () => withEnv(undefined, () => {
+    globalThis.expect(Seed_Connect$ReventlessSeed.roleFromEnv()).toEqual(undefined);
+  }));
+  globalThis.test("reads a named role as a narrowing to it", () => withEnv("Shopper", () => {
+    globalThis.expect(Seed_Connect$ReventlessSeed.roleFromEnv()).toEqual({
+      TAG: "Narrowed",
+      _0: "Shopper"
+    });
+  }));
+  globalThis.test("takes each spelling of full membership as a clear", () => {
+    [
+      "full",
+      "all",
+      "none",
+      "clear",
+      "FULL",
+      "All"
+    ].forEach(v => withEnv(v, () => {
+      globalThis.expect(Seed_Connect$ReventlessSeed.roleFromEnv()).toEqual("Full");
+    }));
+  });
+  globalThis.test("passes a role name through with its case intact", () => withEnv("Merchandiser", () => {
+    globalThis.expect(Seed_Connect$ReventlessSeed.roleFromEnv()).toEqual({
+      TAG: "Narrowed",
+      _0: "Merchandiser"
+    });
+  }));
+});
+
+export {
+  withEnv,
+}
+/*  Not a pure module */

package/lib/bs/tests/Seed_PromptTest.res

@@ -15,22 +15,18 @@ open JestGlobals
 
 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)
-    )
+    ["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)
-    )
+    ["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)
+    [" y", "y ", "  yes  "]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true),
     )
   })
 
@@ -38,14 +34,14 @@ describe("Seed_Prompt.isAffirmative:", () => {
   // 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)
+    ["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)
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false),
     )
   })
 

package/lib/bs/tests/Seed_RandomTest.res

@@ -16,36 +16,45 @@ describe("Seed_Random:", () => {
   }
 
   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))
+    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(
+      "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)
-    })
+    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(
+      "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)
-    })
+    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:", () => {
@@ -54,40 +63,50 @@ describe("Seed_Random:", () => {
       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)
+    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(
+      "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)
+    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(
+      "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(
+      "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",
-      )
+    testSync(
+      "pickOr falls back only when there is nothing to pick",
+      () =>
+        expect(Seed_Random.make(~seed=3)->Seed_Random.pickOr(~fallback="fallback", []))->toBe(
+          "fallback",
+        ),
     )
   })
 
@@ -96,65 +115,86 @@ describe("Seed_Random:", () => {
 
     // 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())
-    })
+    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(
+      "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(
+      "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)
-    })
+    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)
+      },
+    )
   })
 })