test: cover web-runtime seeded PRNG, weighted pick, and seed define wiring

pkg/spec/test/web-runtime.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { __testing__ } from "../src/web-runtime.ts";
+
+const { mulberry32, deriveSeed32, pickWeighted, WEB_PRESS_KEYS } = __testing__;
+
+function entry(weight: number, kind: string) {
+  return [weight, { __sanderlingActionGenerator: true, __sanderlingKind: kind }] as const;
+}
+
+test("mulberry32 is deterministic for the same seed", () => {
+  const a = mulberry32(deriveSeed32("12345"));
+  const b = mulberry32(deriveSeed32("12345"));
+  const first = Array.from({ length: 8 }, () => a());
+  const second = Array.from({ length: 8 }, () => b());
+  assert.deepEqual(first, second);
+});
+
+test("mulberry32 diverges for different seeds", () => {
+  const a = Array.from({ length: 8 }, mulberry32(deriveSeed32("1")));
+  const b = Array.from({ length: 8 }, mulberry32(deriveSeed32("2")));
+  assert.notDeepEqual(a, b);
+});
+
+test("mulberry32 stays in [0, 1)", () => {
+  const next = mulberry32(deriveSeed32("seed"));
+  for (let i = 0; i < 1000; i++) {
+    const value = next();
+    assert.ok(value >= 0 && value < 1, `value out of range: ${value}`);
+  }
+});
+
+test("deriveSeed32 folds a 64-bit seed without precision loss", () => {
+  // Two distinct 64-bit values that collide as a JS Number must not collide here.
+  const a = deriveSeed32("9007199254740993");
+  const b = deriveSeed32("9007199254740992");
+  assert.notEqual(a, b);
+  assert.equal(deriveSeed32(undefined), 0);
+});
+
+test("pickWeighted selects by cumulative ascending scan", () => {
+  const handle = { __sanderlingActionGenerator: true, __sanderlingKind: "weighted", entries: [entry(1, "a"), entry(3, "b")] } as const;
+  // total = 4. pick = 0.1 -> 0.4 lands in [0,1) -> first; pick = 0.5 -> 2.0 lands in [1,4) -> second.
+  assert.equal(pickWeighted(handle as never, () => 0.1)?.__sanderlingKind, "a");
+  assert.equal(pickWeighted(handle as never, () => 0.5)?.__sanderlingKind, "b");
+});
+
+test("pickWeighted never selects a zero-weight entry when pick lands before it", () => {
+  const handle = { __sanderlingActionGenerator: true, __sanderlingKind: "weighted", entries: [entry(1, "a"), entry(0, "zero"), entry(1, "b")] } as const;
+  // total = 2. Any pick < 0.5 lands strictly inside the first entry's [0,1) band.
+  for (const r of [0, 0.1, 0.25, 0.49]) {
+    assert.equal(pickWeighted(handle as never, () => r)?.__sanderlingKind, "a");
+  }
+  // A zero-weight entry adds 0 to the cumulative, so it can never win.
+  for (let i = 0; i < 100; i++) {
+    const r = i / 100;
+    assert.notEqual(pickWeighted(handle as never, () => r)?.__sanderlingKind, "zero");
+  }
+});
+
+test("seeded press-key draw is reproducible", () => {
+  const draw = (seed: string) => {
+    const next = mulberry32(deriveSeed32(seed));
+    return Array.from({ length: 12 }, () => WEB_PRESS_KEYS[Math.floor(next() * WEB_PRESS_KEYS.length)]);
+  };
+  assert.deepEqual(draw("777"), draw("777"));
+  assert.notDeepEqual(draw("777"), draw("778"));
+});