1:1 algorithmic shuffle of massive numerical space For a personal project I'm currently tinkering on, I'm looking for a function which has the following properties:

For any number X in the range 0..MAX, there is a 1:1 random mapping with another number Y in that range.
As long as the key/algorithm remains the same, that mapping should
not change. For every X, there is one and only one Y, and for every
Y there is one and only one X.
Small changes in X should generate massive changes in Y.
Calculating X -&gt; Y should be computationally simple, even for extraordinarily large values of MAX.
Calculating Y -&gt; X should be (effectively) impossible, as should guessing the key.

In non-numerical terms: I'll be encrypting chunks of data (think 4096 bits, maybe more), and expecting an equally-sized unique output chunk for every possible input chunk. Every chunk will always be the same size.
Arbitrary values of X will be converted to Y quite often. End users will be able to choose their value of X at will and see its corresponding Y, across a vast numerical range. Cryptography is not my strong suit, but from my reading this translates as &quot;the algorithm would need to be resistant to chosen-plaintext attacks&quot;. The users should never be able to calculate Y -&gt; X, as that would spoil all the fun (to say the least).
A simple visual, for MAX=8:




X
Y




0
7


1
6


2
5


3
4


4
1


5
0


6
3


7
2




So it should be criminally easy to start with X=2 and calculate Y=5, but it should be essentially impossible to guess X=6 from Y=3 without brute forcing.
There were several promising answers here, but it was unclear how secure any of them actually would be given the conditions: https://stackoverflow.com/questions/16398843/unique-int-to-int-hash
My strong preference would be to use an existing and battle-tested encryption algorithm for this, and preferably one which exists in OpenSSL or some other library I can just plug into from Rust, but I've had trouble knowing the right vocabulary to search for what I want (I'm far from new to programming, but very very green in cryptography). It seems from my reading that block ciphers are what I'm looking for, but I have been thrown off by all the talk of IVs and counters and am unsure if CBC/CTR/etc actually work for what I'm trying to do (or if what I'm trying to do is even possible).
Any pointers in the right direction would be greatly appreciated!
There are three major options available to you, depending on the available preferences and guarantees, ordered in descending order of generality:

Format-Preserving Encryption is a class of encryption schemes that can accept arbitrary input spaces and then produce ciphertext from that input space as output. A classical example would be encryption of credit card numbers to encrypted ones that are still accepted by the database solution validating their format.
Wide Block Cipher Modes, e.g. EME* take a bit string of arbitrary length and then compute a keyed pseudo-random permutation on them, their original intended use was disk encryption where you can't store additional authentication data but want to maximize your chances of detecting modification by randomizing the data sector if the ciphertext sector is changed.
Traditional Symmetric Encryption, e.g. CBC mode with a fixed nonce / IV. Note that these suffer from the isuse that changes at bit position $n$ affect at most a constant amount of bits in front of $n$ and at most all bits following $n$ which seems to not be the avalanche effect you're looking for.

If you're wondering, the recommended baseline block cipher for the above constructions is AES.