functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/crypto/sha2/proof.f.js

@@ -1,13 +1,12 @@
-import { utf8 } from "../../text/module.f.js";
-import { repeat, uint, vec } from "../../types/bit_vec/module.f.js";
-import { flip } from "../../types/function/module.f.js";
-import { map } from "../../types/list/module.f.js";
-import { base32, base64, computeSync, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from "./module.f.js";
+import { utf8 } from '../../text/module.f.js';
+import { repeat, uint, vec } from '../../types/bit_vec/module.f.js';
+import { flip } from '../../types/function/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
+import { map } from '../../types/list/module.f.js';
+import { base32, base64, computeSync, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from './module.f.js';
 const checkEmpty = ({ init, end, hashLength }) => (x) => {
     const result = end(init);
-    if (result !== vec(hashLength)(x)) {
-        throw [result, x];
-    }
+    assertEq(result, vec(hashLength)(x), [result, x]);
 };
 // https://en.wikipedia.org/wiki/SHA-2#Test_vectors
 //
@@ -21,16 +20,12 @@ export const proof = {
                 s256: () => {
                     const result = fromV8(compress(sha256.init.hash)(e));
                     const x = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
-                    if (result !== x) {
-                        throw [result.toString(16), x.toString(16)];
-                    }
+                    assertEq(result, x, [result.toString(16), x.toString(16)]);
                 },
                 s224: () => {
                     const result = fromV8(compress(sha224.init.hash)(e)) >> 32n;
                     const x = 0xd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
             };
         },
@@ -41,30 +36,22 @@ export const proof = {
                 s512: () => {
                     const result = fromV8(compress(sha512.init.hash)(e));
                     const x = 0xcf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
                 s384: () => {
                     const result = fromV8(compress(sha384.init.hash)(e)) >> 128n;
                     const x = 0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
                 s512x256: () => {
                     const result = fromV8(base64.compress(sha512x256.init.hash)(e)) >> 256n;
                     const x = 0xc672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
                 s512x224: () => {
                     const result = fromV8(compress(sha512x224.init.hash)(e)) >> 288n;
                     const x = 0x6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
             };
         }
@@ -83,36 +70,26 @@ export const proof = {
             {
                 const s = utf8("The quick brown fox jumps over the lazy dog");
                 const h = computeSync(sha224)([s]);
-                if (uint(h) !== e) {
-                    throw h;
-                }
+                assertEq(uint(h), e, h);
             }
             {
                 const s = ['The', ' quick', ' brown', ' fox', ' jumps', ' over', ' the', ' lazy', ' dog'];
                 const h = computeSync(sha224)(map(utf8)(s));
-                if (uint(h) !== e) {
-                    throw h;
-                }
+                assertEq(uint(h), e, h);
             }
         },
         () => {
             const s = utf8("The quick brown fox jumps over the lazy dog.");
             const h = computeSync(sha224)([s]);
-            if (uint(h) !== 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
-                throw h;
-            }
+            assertEq(uint(h), 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn, h);
         },
         () => {
             const s = utf8("hello world");
-            if (uint(s) !== 0x68656c6c6f20776f726c64n) {
-                throw s;
-            }
+            assertEq(uint(s), 0x68656c6c6f20776f726c64n, s);
             let state = sha256.init;
             state = sha256.append(s)(state);
             const h = sha256.end(state);
-            if (uint(h) !== 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
-                throw h;
-            }
+            assertEq(uint(h), 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n, h);
         }
     ],
     fill: () => {
@@ -123,18 +100,14 @@ export const proof = {
                 let state = sha256.init;
                 state = sha256.append(r)(state);
                 const h = uint(sha256.end(state));
-                if (h >> 224n !== 0x8a83665fn) {
-                    throw h;
-                }
+                assertEq(h >> 224n, 0x8a83665fn, h);
             },
             16: () => {
                 const r = times(16n);
                 let state = sha256.init;
                 state = sha256.append(r)(state);
                 const h = sha256.end(state);
-                if (uint(h) !== 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
-                    throw h;
-                }
+                assertEq(uint(h), 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n, h);
             }
         };
     },
@@ -144,9 +117,7 @@ export const proof = {
             const msg = flip(repeat)(zero)(113n);
             const h = computeSync(sha384)([msg]);
             const x = 0x6be9af2cf3cd5dd12c8d9399ec2b34e66034fbd699d4e0221d39074172a380656089caafe8f39963f94cc7c0a07e3d21n;
-            if (uint(h) !== x) {
-                throw h;
-            }
+            assertEq(uint(h), x, h);
         },
     },
     // Regression guard (sha2-append-quadratic): `append` used to be
@@ -155,7 +126,7 @@ export const proof = {
     // O(n²); now near-linear (~40-60ms on Node, well under `bun test`'s 5s
     // per-test limit on Bun). No timing assertion (duration varies by
     // engine/machine); relies on the test runner's own per-test timing to
-    // catch a regression, same convention as `fs/base64/proof.f.ts`
+    // catch a regression, same convention as `fjs/basen/base64/proof.f.ts`
     // `encodeLargeVecIsSlow`.
     appendLargeVecIsFast: () => {
         const big = repeat(100000n)(vec(8n)(0xffn));
@@ -163,8 +134,6 @@ export const proof = {
         state = sha256.append(big)(state);
         const h = sha256.end(state);
         const x = 0xbe87f6dbe42cdf682276fbecab3636fbfcaa008cf454d635dd77872b50d940aan;
-        if (uint(h) !== x) {
-            throw h;
-        }
+        assertEq(uint(h), x, h);
     },
 };

package/{fs → fjs}/crypto/sign/module.f.d.ts

@@ -1,8 +1,3 @@
-/**
- * Signing helpers built on secp256k1 and SHA-256 primitives.
- *
- * @module
- */
 import type { Array2 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 import type { Curve } from '../secp/module.f.ts';

package/{fs → fjs}/crypto/sign/module.f.js

@@ -1,7 +1,13 @@
-import { bitLength, divUp8, roundUp8 } from "../../types/bigint/module.f.js";
-import { empty, length, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
-import { hmac } from "../hmac/module.f.js";
-import { computeSync } from "../sha2/module.f.js";
+/**
+ * Signing helpers built on secp256k1 and SHA-256 primitives.
+ *
+ * @module
+ */
+import { assertNotNullish } from '../../asserts/module.f.js';
+import { bitLength, divUp8, roundUp8 } from '../../types/bigint/module.f.js';
+import { empty, length, msb, repeat, unpack, vec, vec8 } from '../../types/bit_vec/module.f.js';
+import { hmac } from '../hmac/module.f.js';
+import { computeSync } from '../sha2/module.f.js';
 /**
  * Builds RFC6979 helper conversions for a subgroup order.
  *
@@ -139,13 +145,10 @@ export const sign = (c) => (hf) => (x) => (m) => {
     //
     //     If r turns out to be zero, a new k should be selected and r
     //     computed again (this is an utterly improbable occurrence).
-    const rxy = c.mul(k)(g);
     // TODO: implement the loop. `computeK` should either
     // - accept a state (current `k`).
     // - accept a `is_valid` function.
-    if (rxy === null) {
-        throw 'rxy === null';
-    }
+    const rxy = assertNotNullish(c.mul(k)(g), 'rxy === null');
     const [r] = rxy;
     // 4.  The value s (modulo q) is computed:
     //

package/{fs → fjs}/crypto/sign/proof.f.js

@@ -4,6 +4,7 @@ import { hmac } from "../hmac/module.f.js";
 import { secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
 import { computeSync, sha224, sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { all, concat, computeK, fromCurve, sign } from "./module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
 const sample = utf8("sample");
 const test = utf8("test");
 const x00 = vec8(0x00n);
@@ -15,172 +16,108 @@ const r32 = repeat(32n);
 const hmac256 = hmac(sha256);
 export const proof = {
     bits2int: () => {
-        if (all(7n).bits2int(vec(5n)(20n)) !== 5n) {
-            throw new Error("fail");
-        }
-        if (all(17n).bits2int(vec(3n)(5n)) !== 5n) {
-            throw new Error("fail");
-        }
+        assertEq(all(7n).bits2int(vec(5n)(20n)), 5n, new Error("fail"));
+        assertEq(all(17n).bits2int(vec(3n)(5n)), 5n, new Error("fail"));
     },
     int2octets: () => {
         // 3 bit prime
-        if (all(5n).int2octets(5n) !== vec(8n)(5n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(5n).int2octets(5n), vec(8n)(5n), new Error("fail"));
         // 5 bit prime
-        if (all(17n).int2octets(20n) !== vec(8n)(20n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(17n).int2octets(20n), vec(8n)(20n), new Error("fail"));
         // 15 bit prime
-        if (all(16387n).int2octets(0x13n) !== vec(16n)(0x13n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(16387n).int2octets(0x13n), vec(16n)(0x13n), new Error("fail"));
     },
     bit2octets: () => {
-        if (all(11n).bits2octets(vec(4n)(13n)) !== vec(8n)(2n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(11n).bits2octets(vec(4n)(13n)), vec(8n)(2n), new Error("fail"));
     },
     k: () => {
         //
         const q = 0x4000000000000000000020108a2e0cc0d99f8a5efn;
         const { qlen, int2octets, bits2octets, bits2int } = all(q);
-        if (qlen !== 163n) {
-            throw qlen;
-        }
+        assertEq(qlen, 163n);
         const x = 0x09a4d6792295a7f730fc3f2b49cbc0f62e862272fn;
         const h1 = computeSync(sha256)([sample]);
-        if (h1 !== v256(0xaf2bdbe1aa9b6ec1e2ade1d694f41fc71a831d0268e9891562113d8a62add1bfn)) {
-            throw h1;
-        }
+        assertEq(h1, v256(0xaf2bdbe1aa9b6ec1e2ade1d694f41fc71a831d0268e9891562113d8a62add1bfn));
         const xi2o = int2octets(x);
-        if (xi2o !== v168(0x009a4d6792295a7f730fc3f2b49cbc0f62e862272fn)) {
-            throw xi2o;
-        }
+        assertEq(xi2o, v168(0x009a4d6792295a7f730fc3f2b49cbc0f62e862272fn));
         const h1b2o = bits2octets(h1);
-        if (h1b2o !== v168(0x01795edf0d54db760f156d0dac04c0322b3a204224n)) {
-            throw h1b2o;
-        }
+        assertEq(h1b2o, v168(0x01795edf0d54db760f156d0dac04c0322b3a204224n));
         let v = r32(x01);
-        if (v !== v256(0x0101010101010101010101010101010101010101010101010101010101010101n)) {
-            throw v;
-        }
+        assertEq(v, v256(0x0101010101010101010101010101010101010101010101010101010101010101n));
         let k = r32(x00);
-        if (k !== v256(0x0000000000000000000000000000000000000000000000000000000000000000n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x0000000000000000000000000000000000000000000000000000000000000000n));
         // d.
         // 256 + 8 + 168 + 168 = 600
         const vv = concat(v, x00, xi2o, h1b2o);
         const vvu = 0x010101010101010101010101010101010101010101010101010101010101010100009a4d6792295a7f730fc3f2b49cbc0f62e862272f01795edf0d54db760f156d0dac04c0322b3a204224n;
-        if (vv !== v600(vvu)) {
-            throw [vv.toString(16), vvu.toString(16)];
-        }
+        assertEq(vv, v600(vvu), [vv.toString(16), vvu.toString(16)]);
         k = hmac256(k)(vv);
-        if (k !== v256(0x09999a9bfef972d3346911883fad7951d23f2c8b47f420222d1171eeeeac5ab8n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x09999a9bfef972d3346911883fad7951d23f2c8b47f420222d1171eeeeac5ab8n));
         // e.
         v = hmac256(k)(v);
-        if (v !== v256(0xd5f4030f755ee86aa10bba8c09df114ff6b6111c238500d13c7343a8c01becf7n)) {
-            throw v;
-        }
+        assertEq(v, v256(0xd5f4030f755ee86aa10bba8c09df114ff6b6111c238500d13c7343a8c01becf7n));
         // f. K = HMAC_K(V || 0x01 || int2octets(x) || bits2octets(h1))
         k = hmac256(k)(concat(v, x01, xi2o, h1b2o));
-        if (k !== v256(0x0cf2fe96d5619c9ef53cb7417d49d37ea68a4ffed0d7e623e38689289911bd57n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x0cf2fe96d5619c9ef53cb7417d49d37ea68a4ffed0d7e623e38689289911bd57n));
         // g.
         v = hmac256(k)(v);
-        if (v !== v256(0x783457c1cf3148a8f2a9ae73ed472fa98ed9cd925d8e964ce0764def3f842b9an)) {
-            throw v;
-        }
+        assertEq(v, v256(0x783457c1cf3148a8f2a9ae73ed472fa98ed9cd925d8e964ce0764def3f842b9an));
         // h.
         v = hmac256(k)(v);
         let t = msb.concat(empty)(v);
-        if (t !== v256(0x9305a46de7ff8eb107194debd3fd48aa20d5e7656cbe0ea69d2a8d4e7c67314an)) {
-            throw t;
-        }
+        assertEq(t, v256(0x9305a46de7ff8eb107194debd3fd48aa20d5e7656cbe0ea69d2a8d4e7c67314an));
         // 3.
         let kk = bits2int(t);
-        if (kk !== 0x4982d236f3ffc758838ca6f5e9fea455106af3b2bn) {
-            throw kk;
-        }
+        assertEq(kk, 0x4982d236f3ffc758838ca6f5e9fea455106af3b2bn);
         // 3. second try
         k = hmac256(k)(concat(v, x00));
-        if (k !== v256(0x75cb5c05b2a78c3d81df12d74d7be0a0e94ab19815781d4d8e2902a79d0a6699n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x75cb5c05b2a78c3d81df12d74d7be0a0e94ab19815781d4d8e2902a79d0a6699n));
         v = hmac256(k)(v);
-        if (v !== v256(0xdcb9ca126107a9c27ce77ba58ea871c8c912d835eaddc305f2445d88f66c4c43n)) {
-            throw v;
-        }
+        assertEq(v, v256(0xdcb9ca126107a9c27ce77ba58ea871c8c912d835eaddc305f2445d88f66c4c43n));
         v = hmac256(k)(v);
         t = msb.concat(empty)(v);
-        if (t !== v256(0xc70c78608a3b5be9289be90ef6e81a9e2c1516d5751d2f75f50033e45f73bdebn)) {
-            throw t;
-        }
+        assertEq(t, v256(0xc70c78608a3b5be9289be90ef6e81a9e2c1516d5751d2f75f50033e45f73bdebn));
         kk = bits2int(t);
-        if (kk !== 0x63863c30451dadf4944df4877b740d4f160a8b6abn) {
-            throw kk;
-        }
+        assertEq(kk, 0x63863c30451dadf4944df4877b740d4f160a8b6abn);
         // 3. third try
         k = hmac256(k)(concat(v, x00));
-        if (k !== v256(0x0a5a64b99c059520103686cb6f36bcfca788eb3bcf69ba66a5bb080b0593ba53n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x0a5a64b99c059520103686cb6f36bcfca788eb3bcf69ba66a5bb080b0593ba53n));
         v = hmac256(k)(v);
-        if (v !== v256(0x0b3b196811b19f6c6f729c43f35bcf0dfd725f17ca3430e8721453e55550a18fn)) {
-            throw v;
-        }
+        assertEq(v, v256(0x0b3b196811b19f6c6f729c43f35bcf0dfd725f17ca3430e8721453e55550a18fn));
         v = hmac256(k)(v);
         t = msb.concat(empty)(v);
-        if (t !== v256(0x475e80e992140567fcc3a50dab90fe84bcd7bb03638e9c4656a06f37f6508a7cn)) {
-            throw t;
-        }
+        assertEq(t, v256(0x475e80e992140567fcc3a50dab90fe84bcd7bb03638e9c4656a06f37f6508a7cn));
         kk = bits2int(t);
-        if (kk !== 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn) {
-            throw kk;
-        }
+        assertEq(kk, 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn);
     },
     computeK: () => {
         const q = 0x4000000000000000000020108a2e0cc0d99f8a5efn;
         const a = all(q);
-        if (a.qlen !== 163n) {
-            throw a.qlen;
-        }
+        assertEq(a.qlen, 163n);
         const x = 0x09a4d6792295a7f730fc3f2b49cbc0f62e862272fn;
         const k = computeK(a)(sha256)(x)(sample);
-        if (k !== 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn) {
-            throw k;
-        }
+        assertEq(k, 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn);
     },
     investigate: () => {
         const q = 0xf2c3119374ce76c9356990b465374a17f23f9ed35089bd969f61c6dde9998c1fn;
         const x = 0x69c7548c21d0dfea6b9a51c9ead4e27c33d3b3f180316e5bcab92c933f0e4dbcn;
         const a = all(q);
         const k = computeK(a)(sha384)(x)(sample);
-        if (k !== 0xc345d5ab3da0a5bcb7ec8f8fb7a7e96069e03b206371ef7d83e39068ec564920n) {
-            throw k;
-        }
+        assertEq(k, 0xc345d5ab3da0a5bcb7ec8f8fb7a7e96069e03b206371ef7d83e39068ec564920n);
     },
     kk: () => {
         const a = fromCurve(secp192r1);
         const x = 0x6fab034934e4c0fc9ae67f5b5659a9d7d1fefd187ee09fd4n;
         const m = utf8("sample");
         const kk = computeK(a)(sha224)(x)(m);
-        if (kk !== 0x4381526b3fc1e7128f202e194505592f01d5ff4c5af015d8n) {
-            throw kk;
-        }
+        assertEq(kk, 0x4381526b3fc1e7128f202e194505592f01d5ff4c5af015d8n);
     },
     a2: () => {
         const check = ({ q, x, msg0, msg1 }) => {
             const a = all(q);
             const check = (sha, expected, m) => {
                 const k = computeK(a)(sha)(x)(m);
-                if (k !== expected) {
-                    throw [k.toString(16), expected.toString(16)];
-                }
+                assertEq(k, expected, [k.toString(16), expected.toString(16)]);
             };
             const check4 = (m, h) => {
                 check(sha224, h[0], m);
@@ -410,16 +347,10 @@ export const proof = {
             const a = all(q.nf.p);
             const check = (sha, { k, r, s }, m) => {
                 const k0 = computeK(a)(sha)(x)(m);
-                if (k0 !== k) {
-                    throw [k0.toString(16), k.toString(16)];
-                }
+                assertEq(k0, k, [k0.toString(16), k.toString(16)]);
                 const [r0, s0] = sign(q)(sha)(x)(m);
-                if (r0 !== r) {
-                    throw [r0, r];
-                }
-                if (s0 !== s) {
-                    throw [s0, s];
-                }
+                assertEq(r0, r, [r0, r]);
+                assertEq(s0, s, [s0, s]);
             };
             const check4 = (m, h) => {
                 check(sha224, h[0], m);

package/{fs → fjs}/crypto/vdf/module.f.js

@@ -14,7 +14,7 @@
  * if (y === null || !sloth.verify(steps)(x)(y)) { throw y }
  * ```
  */
-import { modSqrt, prime_field } from "../../types/prime_field/module.f.js";
+import { modSqrt, prime_field } from '../../types/prime_field/module.f.js';
 /** Sloth VDF modulus (3072-bit safe prime, same as reference implementations). */
 export const p = 0xf2346eae06a233882814ff16f6a076d3b8f2161c5c92171c0b7b84eed4e9475bcce0c13bde34512afdf90f41ab9b86dcf834f85e04b27fadee712eed23a1d4e58cd1b09d9bfb10696d614f119179a40c49dc8762edc29e8115263913237e14718cbcd4dc6b35bace13f8cdb1b5156c50c47b4aaee0820c874e2864cb854367c3n;
 const repeatSeq = (steps) => (f) => (value) => {

package/{fs → fjs}/crypto/vdf/proof.f.js

@@ -1,4 +1,5 @@
-import { sloth, p } from "./module.f.js";
+import { sloth, p } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const { eval: evalVdf, verify, modSqrt, quadRes } = sloth;
 // `eval(steps)(x)` expected values for {@link p}; same Sloth algorithm as
 // https://github.com/hyperhyperspace/pulsar/blob/main/src/model/SlothVDF.ts and
@@ -14,122 +15,80 @@ const y4 = 644011502652234436942449645950841972378141575340402198193426476647825
 export const proof = {
     p: {
         matchesField: () => {
-            if (sloth.p !== p) {
-                throw [sloth.p, p];
-            }
+            assertEq(sloth.p, p, [sloth.p, p]);
         },
     },
     eval: {
         steps100: () => {
             const y = evalVdf(100n)(sampleX);
-            if (y !== sampleY) {
-                throw [y, sampleY];
-            }
+            assertEq(y, sampleY, [y, sampleY]);
         },
         steps10: () => {
             const y = evalVdf(10n)(smallX);
-            if (y !== smallY) {
-                throw [y, smallY];
-            }
+            assertEq(y, smallY, [y, smallY]);
         },
         steps6: () => {
             const y = evalVdf(6n)(largeX);
-            if (y !== y6) {
-                throw [y, y6];
-            }
+            assertEq(y, y6, [y, y6]);
         },
         steps4: () => {
             const y = evalVdf(4n)(smallX);
-            if (y !== y4) {
-                throw [y, y4];
-            }
+            assertEq(y, y4, [y, y4]);
         },
         zeroSteps: () => {
             const y = evalVdf(0n)(sampleX);
-            if (y !== sampleX % p) {
-                throw [y, sampleX % p];
-            }
+            assertEq(y, sampleX % p, [y, sampleX % p]);
         },
         negativeSteps: () => {
             const y = evalVdf(-1n)(sampleX);
-            if (y !== null) {
-                throw y;
-            }
+            assertEq(y, null);
         },
     },
     verify: {
         steps100: () => {
-            if (!verify(100n)(sampleX)(sampleY)) {
-                throw false;
-            }
+            assert(verify(100n)(sampleX)(sampleY), false);
         },
         steps10: () => {
-            if (!verify(10n)(smallX)(smallY)) {
-                throw false;
-            }
+            assert(verify(10n)(smallX)(smallY), false);
         },
         steps6: () => {
-            if (!verify(6n)(largeX)(y6)) {
-                throw false;
-            }
+            assert(verify(6n)(largeX)(y6), false);
         },
         steps4: () => {
-            if (!verify(4n)(smallX)(y4)) {
-                throw false;
-            }
+            assert(verify(4n)(smallX)(y4), false);
         },
         tampered: () => {
-            if (verify(4n)(smallX)((y4 + 1n) % p)) {
-                throw (y4 + 1n) % p;
-            }
+            assert(!(verify(4n)(smallX)((y4 + 1n) % p)), (y4 + 1n) % p);
         },
         wrongY: () => {
-            if (verify(100n)(sampleX)(sampleY + 1n)) {
-                throw sampleY + 1n;
-            }
+            assert(!(verify(100n)(sampleX)(sampleY + 1n)), sampleY + 1n);
         },
         zeroSteps: () => {
-            if (!verify(0n)(sampleX)(sampleX % p)) {
-                throw [sampleX % p];
-            }
+            assert(verify(0n)(sampleX)(sampleX % p), [sampleX % p]);
         },
         negativeSteps: () => {
-            if (verify(-1n)(sampleX)(sampleY)) {
-                throw sampleY;
-            }
+            assert(!(verify(-1n)(sampleX)(sampleY)), sampleY);
         },
         invalidY: () => {
-            if (verify(100n)(sampleX)(0n)) {
-                throw 0n;
-            }
+            assert(!(verify(100n)(sampleX)(0n)), 0n);
         },
     },
     modSqrt: {
         roundTrip: () => {
             const x = 999n;
-            if (!verify(1n)(x)(modSqrt(x))) {
-                throw modSqrt(x);
-            }
+            assert(verify(1n)(x)(modSqrt(x)), modSqrt(x));
         },
         nonResidue: () => {
-            if (quadRes(nonResidue)) {
-                throw nonResidue;
-            }
-            if (!verify(1n)(nonResidue)(modSqrt(nonResidue))) {
-                throw modSqrt(nonResidue);
-            }
+            assert(!(quadRes(nonResidue)), nonResidue);
+            assert(verify(1n)(nonResidue)(modSqrt(nonResidue)), modSqrt(nonResidue));
         },
     },
     quadRes: {
         one: () => {
-            if (!quadRes(1n)) {
-                throw 1n;
-            }
+            assert(quadRes(1n), 1n);
         },
         nonResidue: () => {
-            if (quadRes(nonResidue)) {
-                throw nonResidue;
-            }
+            assert(!(quadRes(nonResidue)), nonResidue);
         },
     },
 };

package/{fs → fjs}/dev/module.f.js

@@ -3,12 +3,12 @@
  *
  * @module
  */
-import { all, import_, readdir } from "../effects/node/module.f.js";
-import { cmp as strCmp } from "../types/string/module.f.js";
-import { unwrap } from "../types/result/module.f.js";
-import { pure } from "../effects/module.f.js";
-import { join, relativize, toPosix } from "../path/module.f.js";
-import { assert } from "../asserts/module.f.js";
+import { all, import_, readdir } from '../effects/node/module.f.js';
+import { cmp as strCmp } from '../types/string/module.f.js';
+import { unwrap } from '../types/result/module.f.js';
+import { pure } from '../effects/module.f.js';
+import { join, relativize, toPosix } from '../path/module.f.js';
+import { assert } from '../asserts/module.f.js';
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *

package/{fs → fjs}/dev/package_json/module.f.js

@@ -1,9 +1,9 @@
-import { parse as jsonParse } from "../../json/parser/module.f.js";
-import { tokenize as jsonTokenize } from "../../json/tokenizer/module.f.js";
-import { stringToList } from "../../text/utf16/module.f.js";
-import { option, record, string } from "../../types/rtti/module.f.js";
-import { validate as rttiValidate } from "../../types/rtti/validate/module.f.js";
-import { error, ok } from "../../types/result/module.f.js";
+import { parse as jsonParse } from '../../media/json/parser/module.f.js';
+import { tokenize as jsonTokenize } from '../../media/json/tokenizer/module.f.js';
+import { stringToList } from '../../text/utf16/module.f.js';
+import { option, record, string } from '../../types/rtti/module.f.js';
+import { validate as rttiValidate } from '../../types/rtti/validate/module.f.js';
+import { error, ok } from '../../types/result/module.f.js';
 export const packageJsonSchema = {
     name: option(string),
     version: option(string),