functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/ci/proof.f.js

@@ -1,15 +1,16 @@
-import { ci, main } from "./module.f.js";
-import { functionalscript } from "./config/module.f.js";
-import { utf8, utf8ToString } from "../text/module.f.js";
-import { empty as emptyVec, isVec } from "../types/bit_vec/module.f.js";
-import { test, ubuntu, parseGitHubAction } from "./common/module.f.js";
-import { assert } from "../asserts/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
-import { parse as jsonParse } from "../json/module.f.js";
-import { unwrap } from "../types/result/module.f.js";
-import { definedValues } from "../types/object/module.f.js";
+import { ci, main } from './module.f.js';
+import { functionalscript } from './config/module.f.js';
+import { utf8, utf8ToString } from '../text/module.f.js';
+import { empty as emptyVec, isVec } from '../types/bit_vec/module.f.js';
+import { test, ubuntu, parseGitHubAction } from './common/module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
+import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
+import { parse as jsonParse } from '../media/json/module.f.js';
+import { unwrap } from '../types/result/module.f.js';
+import { definedValues } from '../types/object/module.f.js';
 const hasRun = (cmd) => (gha) => definedValues(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
+const hasExactRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run === cmd) ?? false;
 const makeState = (rust, packageJson) => ({
     ...emptyState,
     root: {
@@ -24,27 +25,25 @@ const workflow = (state) => {
     const workflows = dotGithub['workflows'];
     assert(typeof workflows === 'object' && !Array.isArray(workflows), workflows);
     const file = workflows['ci.yml'];
-    if (!Array.isArray(file) || file.length === 0) {
-        throw file;
-    }
+    assert(!(!Array.isArray(file) || file.length === 0), file);
     return unwrap(parseGitHubAction(jsonParse(utf8ToString(file[0]))));
 };
 const run = (rust, nodeExtra = () => []) => {
     const [state, result] = virtual(makeState(rust))(ci({ nodeExtra }));
-    assert(result === 0, result);
+    assertEq(result, 0);
     return workflow(state);
 };
 const runDefault = (packageJson) => {
     const [state, result] = virtual(makeState(false, packageJson))(main());
-    assert(result === 0, result);
+    assertEq(result, 0);
     return workflow(state);
 };
 export const proof = {
     matrixShape: () => {
         const gha = run(true);
-        assert(Object.keys(gha.jobs).length === 13, 'expected 13 CI jobs');
-        assert(gha.permissions.contents === 'read', 'expected read-only contents permission');
-        assert(Object.keys(gha.permissions).length === 1, 'expected least-privilege workflow permissions');
+        assertEq(Object.keys(gha.jobs).length, 13, 'expected 13 CI jobs');
+        assertEq(gha.permissions.contents, 'read', 'expected read-only contents permission');
+        assertEq(Object.keys(gha.permissions).length, 1, 'expected least-privilege workflow permissions');
         assert(hasRunInJob('ubuntu-intel', 'cargo test --target i686-unknown-linux-gnu')(gha), 'expected Ubuntu Intel i686 check');
         assert(hasRunInJob('ubuntu-intel', 'cargo test --target i686-unknown-linux-gnu --release')(gha), 'expected Ubuntu Intel i686 release check');
         assert(hasRunInJob('ubuntu-intel', 'cargo clippy --target i686-unknown-linux-gnu -- -D warnings')(gha), 'expected Ubuntu Intel i686 lint');
@@ -55,6 +54,12 @@ export const proof = {
         assert(hasRunInJob('wasm', 'cargo test --target wasm32-wasip1 --release')(gha), 'expected target-specific WASM release check');
         assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1 -- -D warnings')(gha), 'expected target-specific WASM Rust lint');
         assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1 --release -- -D warnings')(gha), 'expected target-specific WASM release lint');
+        // Wasmtime 47 removed wasi-threads: the threads target must run under
+        // Wasmer only, while Clippy (no runner) stays.
+        assert(hasRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads --config .cargo/config.wasmer.toml')(gha), 'expected Wasmer WASM threads check');
+        assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1-threads -- -D warnings')(gha), 'expected WASM threads lint');
+        assert(!hasExactRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads')(gha), 'unexpected Wasmtime WASM threads check');
+        assert(!hasExactRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads --release')(gha), 'unexpected Wasmtime WASM threads release check');
         assert(hasRunInJob('node22', 'fjs t')(gha), 'expected Node 22 FunctionalScript smoke test');
         assert(hasRunInJob('node26', 'npm pack')(gha), 'expected Node 26 package check');
         assert(!hasRun('npm publish --dry-run')(gha), 'unexpected npm publish dry-run');
@@ -104,20 +109,20 @@ export const proof = {
         functionalscriptPackage: () => {
             const gha = runDefault('{"name":"functionalscript"}');
             assert(hasRun('fjs t')(gha), 'expected fjs self-test');
-            assert(hasRun(`deno run -A npm:functionalscript@${functionalscript} t`)(gha), 'expected deno self-test');
+            assert(hasRun(`deno run -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected deno self-test');
             assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected bun self-test');
         },
         otherPackage: () => {
             const gha = runDefault('{"name":"other-package"}');
-            assert(hasRun(`deno run -A npm:functionalscript@${functionalscript} t`)(gha), 'expected canonical deno self-test');
+            assert(hasRun(`deno run -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected canonical deno self-test');
             assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected canonical bun self-test');
         },
         configuredPackageVersion: () => {
             const gha = runDefault('{"name":"other-package","version":"1.2.3"}');
             assert(hasRun(`npm install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version platform install');
-            assert(hasRun(`deno install -g -A npm:functionalscript@${functionalscript}`)(gha), 'expected configured-version deno install cache');
+            assert(hasRun(`deno install -g -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript}`)(gha), 'expected configured-version deno install cache');
             assert(hasRun('deno install --frozen')(gha), 'expected deno lock install');
-            assert(hasRun(`deno run -A npm:functionalscript@${functionalscript} t`)(gha), 'expected configured-version deno install');
+            assert(hasRun(`deno run -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected configured-version deno install');
             assert(hasRun("deno test --allow-read --allow-env --allow-sys --coverage && deno coverage --include='.*module\\.f\\.ts'")(gha), 'expected limited-permission deno coverage');
             assert(hasRun(`bun install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version bun cache');
             assert(hasRun('bun install --frozen-lockfile')(gha), 'expected bun lock install');

package/{fs → fjs}/ci/rust/module.f.js

@@ -6,8 +6,8 @@
  *
  * @module
  */
-import { wasmer, wasmtime } from "../config/module.f.js";
-import { install, test, uses } from "../common/module.f.js";
+import { wasmer, wasmtime } from '../config/module.f.js';
+import { install, test, uses } from '../common/module.f.js';
 const cargoCommand = (tool, target, config) => {
     const to = target ? ` --target ${target}` : '';
     const co = config ? ` --config ${config}` : '';
@@ -39,6 +39,14 @@ const wasmTarget = (target) => [
     ...targetChecks(target),
     ...cargoTestPair(target, '.cargo/config.wasmer.toml')
 ];
+// Wasmtime 47 removed wasi-threads, so the threads target runs under Wasmer
+// only; Clippy needs no runner and stays. See todo/blocked/wasmtime-threads.md.
+const wasmerOnlyTarget = (target) => [
+    { type: 'rust', target },
+    cargoClippy(target),
+    cargoReleaseClippy(target),
+    ...cargoTestPair(target, '.cargo/config.wasmer.toml')
+];
 const i686 = (a, v) => {
     if (a === 'intel') {
         switch (v) {
@@ -63,5 +71,5 @@ export const rustWasmSteps = [
     ...wasmTarget('wasm32-wasip1'),
     ...wasmTarget('wasm32-wasip2'),
     ...wasmTarget('wasm32-unknown-unknown'),
-    ...wasmTarget('wasm32-wasip1-threads'),
+    ...wasmerOnlyTarget('wasm32-wasip1-threads'),
 ];

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

@@ -1,6 +1,6 @@
-import { errorExit, log } from "../effects/node/module.f.js";
-import { pure } from "../effects/module.f.js";
-import { at, fromEntries } from "../types/object/module.f.js";
+import { errorExit, log } from '../effects/node/module.f.js';
+import { pure } from '../effects/module.f.js';
+import { at, fromEntries } from '../types/object/module.f.js';
 const helpMeta = { names: ['help', 'h', '?'], description: 'Print this help message' };
 export const dispatch = (commands) => (options) => {
     const [cmd, ...rest] = options.args;

package/{fs → fjs}/cli/proof.f.js

@@ -1,6 +1,7 @@
-import { pure } from "../effects/module.f.js";
-import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
-import { dispatch } from "./module.f.js";
+import { pure } from '../effects/module.f.js';
+import { defaultNodeProgramOptions, emptyState, virtual } from '../effects/node/virtual/module.f.js';
+import { dispatch } from './module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
 const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const echoCommands = [
     {
@@ -13,51 +14,31 @@ const run = (commands) => (args) => virtual(emptyState)(dispatch(commands)(makeO
 export const proof = {
     knownCommand: () => {
         const [, code] = run(echoCommands)(['echo', 'hello']);
-        if (code !== 5) {
-            throw ['expected length 5', code];
-        }
+        assertEq(code, 5, ['expected length 5', code]);
     },
     alias: () => {
         const [, code] = run(echoCommands)(['e', 'hi']);
-        if (code !== 2) {
-            throw ['expected length 2', code];
-        }
+        assertEq(code, 2, ['expected length 2', code]);
     },
     noArgs: () => {
         const [state, code] = run(echoCommands)([]);
-        if (code !== 1) {
-            throw ['expected exit 1', code];
-        }
-        if (state.stderr.length === 0) {
-            throw 'expected error in stderr';
-        }
+        assertEq(code, 1, ['expected exit 1', code]);
+        assert(state.stderr.length !== 0, 'expected error in stderr');
     },
     unknownCommand: () => {
         const [state, code] = run(echoCommands)(['bogus']);
-        if (code !== 1) {
-            throw ['expected exit 1', code];
-        }
-        if (state.stderr.length === 0) {
-            throw 'expected error in stderr';
-        }
+        assertEq(code, 1, ['expected exit 1', code]);
+        assert(state.stderr.length !== 0, 'expected error in stderr');
     },
     help: () => {
         const [state, code] = run(echoCommands)(['help']);
-        if (code !== 0) {
-            throw ['expected exit 0', code];
-        }
-        if (!state.stdout.includes('echo')) {
-            throw 'expected command name in stdout';
-        }
-        if (!state.stdout.includes('help')) {
-            throw 'expected help entry in stdout';
-        }
+        assertEq(code, 0, ['expected exit 0', code]);
+        assert(state.stdout.includes('echo'), 'expected command name in stdout');
+        assert(state.stdout.includes('help'), 'expected help entry in stdout');
     },
     errorIncludesAvailable: () => {
         const [state] = run(echoCommands)(['bogus']);
-        if (!state.stderr.includes('echo')) {
-            throw 'expected available commands in error';
-        }
+        assert(state.stderr.includes('echo'), 'expected available commands in error');
     },
     handlerReceivesRemainingArgs: () => {
         const captured = [];
@@ -70,9 +51,7 @@ export const proof = {
                 },
             }];
         run(commands)(['grab', 'a', 'b', 'c']);
-        if (captured.join(',') !== 'a,b,c') {
-            throw ['unexpected args', captured];
-        }
+        assertEq(captured.join(','), 'a,b,c', ['unexpected args', captured]);
     },
     nestedCommands: () => {
         const inner = [{
@@ -86,9 +65,7 @@ export const proof = {
                 handler: inner,
             }];
         const [, code] = run(outer)(['sub', 'ping']);
-        if (code !== 42) {
-            throw ['expected 42', code];
-        }
+        assertEq(code, 42, ['expected 42', code]);
     },
     nestedHelp: () => {
         const inner = [{
@@ -102,30 +79,18 @@ export const proof = {
                 handler: inner,
             }];
         const [state, code] = run(outer)(['sub', 'help']);
-        if (code !== 0) {
-            throw ['expected exit 0', code];
-        }
-        if (!state.stdout.includes('ping')) {
-            throw 'expected inner command in help';
-        }
+        assertEq(code, 0, ['expected exit 0', code]);
+        assert(state.stdout.includes('ping'), 'expected inner command in help');
     },
     prototypeNameIsUnknownCommand: () => {
         const [state, code] = run(echoCommands)(['toString']);
-        if (code !== 1) {
-            throw ['expected exit 1 for prototype-name command', code];
-        }
-        if (!state.stderr.includes('unknown command')) {
-            throw 'expected unknown-command error in stderr';
-        }
+        assertEq(code, 1, ['expected exit 1 for prototype-name command', code]);
+        assert(state.stderr.includes('unknown command'), 'expected unknown-command error in stderr');
     },
     helpPrototypeSafe: () => {
         const [state, code] = run(echoCommands)(['help', 'toString']);
-        if (code !== 0) {
-            throw ['expected exit 0, not a throw', code];
-        }
-        if (!state.stdout.includes('echo')) {
-            throw 'expected top-level help for unknown target';
-        }
+        assertEq(code, 0, ['expected exit 0, not a throw', code]);
+        assert(state.stdout.includes('echo'), 'expected top-level help for unknown target');
     },
     helpWithTarget: () => {
         const inner = [{
@@ -139,14 +104,8 @@ export const proof = {
                 handler: inner,
             }];
         const [state, code] = run(outer)(['help', 'sub']);
-        if (code !== 0) {
-            throw ['expected exit 0', code];
-        }
-        if (!state.stdout.includes('ping')) {
-            throw 'expected inner command in help';
-        }
-        if (state.stdout.includes('Subcommand group')) {
-            throw 'expected inner help, not outer';
-        }
+        assertEq(code, 0, ['expected exit 0', code]);
+        assert(state.stdout.includes('ping'), 'expected inner command in help');
+        assert(!(state.stdout.includes('Subcommand group')), 'expected inner help, not outer');
     },
 };

package/{fs/types → fjs/common}/monoid/module.f.d.ts

@@ -5,7 +5,7 @@
  *
  * @module
  */
-import type { Fold, Reduce } from '../function/operator/module.f.ts';
+import type { Fold, Reduce } from '../../types/function/operator/module.f.ts';
 /**
  * Represents a monoid, an algebraic structure with a binary operation
  * and an identity (neutral) element.

package/{fs/types → fjs/common}/monoid/proof.f.js

@@ -1,4 +1,5 @@
 import { repeat } from "./module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     numberAdd: () => {
         const add = {
@@ -6,13 +7,9 @@ export const proof = {
             operation: a => b => a + b,
         };
         const resultAdd = repeat(add)(10n)(2); // 20
-        if (resultAdd !== 20) {
-            throw resultAdd;
-        }
+        assertEq(resultAdd, 20);
         const id = repeat(add)(0n)(42);
-        if (id !== 0) {
-            throw id;
-        }
+        assertEq(id, 0);
     },
     stringConcat: () => {
         const concat = {
@@ -20,8 +17,6 @@ export const proof = {
             operation: a => b => a + b,
         };
         const resultConcat = repeat(concat)(3n)('ha'); // 'hahaha'
-        if (resultConcat !== 'hahaha') {
-            throw resultConcat;
-        }
+        assertEq(resultConcat, 'hahaha');
     }
 };

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

@@ -17,8 +17,8 @@
  * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
  * ```
  */
-import { length, msb, vec, vec8, repeat } from "../../types/bit_vec/module.f.js";
-import { computeSync } from "../sha2/module.f.js";
+import { length, msb, vec, vec8, repeat } from '../../types/bit_vec/module.f.js';
+import { computeSync } from '../sha2/module.f.js';
 const { concat, xor } = msb;
 /**
  * Outer padding.

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

@@ -1,34 +1,26 @@
-import { assertEq } from "../../asserts/module.f.js";
-import { utf8 } from "../../text/module.f.js";
-import { uint, vec } from "../../types/bit_vec/module.f.js";
-import { sha256, sha384, sha512 } from "../sha2/module.f.js";
-import { hmac } from "./module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
+import { utf8 } from '../../text/module.f.js';
+import { uint, vec } from '../../types/bit_vec/module.f.js';
+import { sha256, sha384, sha512 } from '../sha2/module.f.js';
+import { hmac } from './module.f.js';
 export const proof = {
     example: () => {
         const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) {
-            throw r;
-        }
+        assertEq(r, vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n));
     },
     sha256: () => {
         const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        if (uint(r) !== 0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n) {
-            throw r;
-        }
+        assertEq(uint(r), 0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n, r);
     },
     sha384: () => {
         const k = vec(384n)(0n);
         const m = vec(904n)(0x0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010069c7548c21d0dfea6b9a51c9ead4e27c33d3b3f180316e5bcab92c933f0e4dbc9a9083505bc92276aec4be312696ef7bf3bf603f4bbd381196a029f340585312n);
         const r = hmac(sha384)(k)(m);
-        if (r !== vec(384n)(0x8f858157ce005cd52fd8e8f1a46b55e6cfae21c8c183d9c2f7504bedf450609edd7d3c6171dc0bdd2d2444faa28f18ban)) {
-            throw uint(r).toString(16);
-        }
+        assertEq(r, vec(384n)(0x8f858157ce005cd52fd8e8f1a46b55e6cfae21c8c183d9c2f7504bedf450609edd7d3c6171dc0bdd2d2444faa28f18ban), uint(r).toString(16));
     },
     sha512: () => {
         const r = hmac(sha512)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        if (r !== vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an)) {
-            throw r;
-        }
+        assertEq(r, vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an));
     },
     // RFC 4231 Test Case 6: key (131 bytes of 0xaa = 1048 bits) exceeds SHA-256 block size (512 bits),
     // so the key is first compressed via the hash function before use.

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

@@ -4,9 +4,9 @@
  *
  * @module
  */
-import { mask } from "../../types/bigint/module.f.js";
-import { uint } from "../../types/bit_vec/module.f.js";
-import { computeSync, sha256 } from "../sha2/module.f.js";
+import { mask } from '../../types/bigint/module.f.js';
+import { uint } from '../../types/bit_vec/module.f.js';
+import { computeSync, sha256 } from '../sha2/module.f.js';
 const nBitsMantissa = mask(24n);
 const mantissaSign = 0x00800000n;
 const mantissaBody = 0x007fffffn;

package/fjs/crypto/pow/proof.f.js

@@ -0,0 +1,111 @@
+import { utf8 } from '../../text/module.f.js';
+import { empty, uint } from '../../types/bit_vec/module.f.js';
+import { computeSync, sha224, sha256 } from '../sha2/module.f.js';
+import { bitcoinPow, genesisNBits, genesisTarget, pow, sha256Pow, targetFromNBits } from './module.f.js';
+import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
+const p256 = sha256Pow;
+const p224 = pow(sha224);
+const sample = utf8('functionalscript pow proof');
+const emptyData = empty;
+/** Target large enough for {@link sample} under SHA-256 (`0x207fffff`). */
+const easyNBits = 0x207fffffn;
+/** Compact encoding for target `1` (`0x03000001`). */
+const hardNBits = 0x03000001n;
+/** SHA-256 of the empty message (NIST / Bitcoin block merkle uses this primitive). */
+const sha256EmptyHash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
+/** Bitcoin block #0 header hash as big-endian uint256. */
+const block0Hash = 0x000000000019d6689c085ae165831e934ff763ae46a2a6cffb388491c27dc990n;
+const expectNull = (nBits) => {
+    assertEq(targetFromNBits(nBits), null, nBits);
+};
+export const proof = {
+    targetFromNBits: {
+        genesis: () => {
+            assertEq(targetFromNBits(genesisNBits), genesisTarget, 'genesis target');
+        },
+        block0HashWithinGenesisTarget: () => {
+            assert(!(block0Hash > genesisTarget), 'block0 hash exceeds genesis target');
+        },
+        exponent3: () => {
+            assertEq(targetFromNBits(0x030000ffn), 0xffn, 'exponent 3');
+        },
+        exponent2: () => {
+            assertEq(targetFromNBits(0x02008000n), 0x80n, 'exponent 2');
+        },
+        hardTargetOne: () => {
+            assertEq(targetFromNBits(hardNBits), 1n, 'hard target');
+        },
+        zero: () => {
+            assertEq(targetFromNBits(0n), 0n, 'zero nBits');
+        },
+        negative: () => {
+            expectNull(0x01800001n);
+        },
+        negativeHighMantissa: () => {
+            expectNull(0x22ffffffn);
+        },
+        overflowExponent: () => {
+            expectNull(0x23000001n);
+        },
+        exceeds256: () => {
+            expectNull(0x227fffffn);
+        },
+    },
+    meets: {
+        easy: () => {
+            assert(p256.meets(easyNBits)(sample), 'easy nBits should pass');
+        },
+        hard: () => {
+            assert(!(p256.meets(hardNBits)(sample)), 'target 1 should fail');
+        },
+        genesisFailsSample: () => {
+            assert(!(p256.meets(genesisNBits)(sample)), 'genesis target too hard for sample');
+        },
+        zeroTargetRejectsSample: () => {
+            assert(!(p256.meets(0n)(sample)), 'non-zero hash vs zero target');
+        },
+        invalidNBits: () => {
+            assert(!(p256.meets(0x01800001n)(sample)), 'invalid nBits should not pass');
+        },
+        hashLeqTarget: () => {
+            const h = p256.hashInt(sample);
+            const target = assertNotNullish(targetFromNBits(easyNBits), 'easy nBits decode');
+            assert(!(h > target), 'hash above easy target');
+            assert(h <= target, 'hash <= target');
+        },
+    },
+    hashInt: {
+        sha256Sample: () => {
+            const digest = computeSync(sha256)([sample]);
+            assertEq(p256.hashInt(sample), uint(digest), 'sha256 sample');
+        },
+        sha256Empty: () => {
+            assertEq(p256.hashInt(emptyData), sha256EmptyHash, 'sha256 empty constant');
+            const digest = computeSync(sha256)([emptyData]);
+            assertEq(p256.hashInt(emptyData), uint(digest), 'sha256 empty');
+        },
+        sha224: () => {
+            const digest = computeSync(sha224)([sample]);
+            assertEq(p224.hashInt(sample), uint(digest), 'sha224');
+        },
+        stable: () => {
+            assertEq(p256.hashInt(sample), p256.hashInt(sample), 'stable');
+        },
+    },
+    pow: {
+        sha256Pow: () => {
+            const built = pow(sha256);
+            assertEq(sha256Pow.hashInt(sample), built.hashInt(sample), 'hashInt');
+            assertEq(sha256Pow.meets(easyNBits)(sample), built.meets(easyNBits)(sample), 'meets');
+        },
+        bitcoinPow: () => {
+            assertEq(bitcoinPow.hashInt(sample), sha256Pow.hashInt(sample), 'bitcoinPow');
+        },
+        independentInstances: () => {
+            const a = pow(sha256);
+            const b = pow(sha256);
+            assertEq(a.hashInt(sample), b.hashInt(sample), 'hashInt');
+            assertEq(a.meets(easyNBits)(sample), b.meets(easyNBits)(sample), 'meets');
+        },
+    },
+};

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

@@ -1,5 +1,5 @@
-import { prime_field, sqrt } from "../../types/prime_field/module.f.js";
-import { repeat } from "../../types/monoid/module.f.js";
+import { prime_field, sqrt } from '../../types/prime_field/module.f.js';
+import { repeat } from '../../common/monoid/module.f.js';
 /**
  * Constructs an elliptic curve with the given initialization parameters.
  *

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

@@ -1,6 +1,6 @@
-import { assert } from "../../asserts/module.f.js";
-import { prime_field } from "../../types/prime_field/module.f.js";
-import { curve, secp256k1, secp192r1, secp256r1, eq, secp384r1, secp521r1 } from "./module.f.js";
+import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
+import { prime_field } from '../../types/prime_field/module.f.js';
+import { curve, secp256k1, secp192r1, secp256r1, eq, secp384r1, secp521r1 } from './module.f.js';
 const poker = (param) => () => {
     // (c ^ x) ^ y = c ^ (x * y)
     // c ^ ((x * y) * (1/x * 1/y)) = c
@@ -44,13 +44,9 @@ const poker = (param) => () => {
     //
     let m = 0n;
     for (const p of dN) {
-        if (p === null) {
-            throw 'null';
-        }
+        assert(p !== null, 'null');
         const x = p[0] & 0x3fn;
-        if (x !== m) {
-            throw [p[0], x, m];
-        }
+        assertEq(x, m, [p[0], x, m]);
         ++m;
     }
 };
@@ -72,42 +68,25 @@ export const proof = {
         const test_curve = c => {
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n }, g } = c;
             const point_check = (p) => {
-                if (p === null) {
-                    throw 'p === null';
-                }
+                assert(p !== null, 'p === null');
                 const [x, y] = p;
-                const ye = yf(x);
-                if (ye === null) {
-                    throw 'ye === null';
-                }
-                if (abs(ye) !== abs(y)) {
-                    throw 'ye';
-                }
+                const ye = assertNotNullish(yf(x), 'ye === null');
+                assertEq(abs(ye), abs(y), 'ye');
             };
             point_check(g);
             point_check(neg(g));
             const test_mul = (p) => {
-                if (mul(0n)(p) !== null) {
-                    throw 'O';
-                }
-                if (mul(1n)(p) !== p) {
-                    throw 'p';
-                }
-                if (mul(n)(p) !== null) {
-                    throw 'n';
-                }
+                assertEq(mul(0n)(p), null, 'O');
+                assertEq(mul(1n)(p), p, 'p');
+                assertEq(mul(n)(p), null, 'n');
                 const pn = neg(p);
-                if (!eq(mul(n - 1n)(p))(pn)) {
-                    throw 'n - 1';
-                }
+                assert(eq(mul(n - 1n)(p))(pn), 'n - 1');
                 const f = s => {
                     const r = mul(s)(p);
                     point_check(r);
                     const rn = mul(s)(pn);
                     point_check(rn);
-                    if (!eq(r)(neg(rn))) {
-                        throw 'r != -rn';
-                    }
+                    assert(eq(r)(neg(rn)), 'r != -rn');
                 };
                 f(2n);
                 f(3n);
@@ -136,7 +115,7 @@ export const proof = {
     // Cover null (point at infinity) branches in neg, add, and eq.
     nullPointOps: () => {
         const c = secp256k1;
-        assert(c.neg(null) === null);
+        assertEq(c.neg(null), null);
         assert(eq(null)(null));
         assert(!eq(null)(c.g));
         assert(!eq(c.g)(null));

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

@@ -1,6 +1,6 @@
 import { mask } from "../../types/bigint/module.f.js";
-import { vec, length, empty, msb, chunkList, uint } from "../../types/bit_vec/module.f.js";
-import { fold } from "../../types/list/module.f.js";
+import { vec, length, empty, msb, chunkList, uint } from '../../types/bit_vec/module.f.js';
+import { fold } from '../../types/list/module.f.js';
 const { concat, front } = msb;
 // `chunkList(msb)` depends on neither `chunkLength` nor `v`/`state` — shared
 // across every `base(...)` config (32-bit and 64-bit SHA-2 variants).