Fix block perf test suite messages.

Extend time interval between check for GPU device to save mobile device cycles.

Couple more benchmarks.

Throttle back workgroup size since apparently this value works with GPUs better and we're still checking over a billion nonces per dispatch; the probability of finding a nonce at this level is over 99.9%

Refactor GPU device loading to avoid high promise stack.

Switch block back to PowGpu.

Set up canvas size for proper pow comparison testing.

Restore all block performance tests. Fix PowGl execution.

Merge redundant find function with calculate to form search function like PowGpu. Implement more of a promise-based pipeline through PowGl calculations.

Inline G mix function addition steps to eliminate a function call.

Log some more benchmarks. Switch back to PowGl for blocks, with the plan to later make PowGpu available behind a flag.

Get rid of extraneous logging in PowGl.

Rename and export PowGl for systems that don't support WebGPU. Update some other names.

Avoid loading nano-webgl-pow entirely. Upload bundle for platform testing.

Remove final unused v array pointer.

Replace v[d] indexes with pointers.

Replace v[c] indexes with pointers.

Replace v[b] indexes with pointers.

Remove replaced v[a] arguments.

Remove v array now that individual variables have been confirmed.

Try updating G mix function again; rounds need to be updated next.

Revert array pointer dereferencing to troubleshoot invalid nonces.

Revert some pointer implementations due to incorrect nonces now.

Fix variable name.

Refactor returned promises.

notes

Fix this later.

Throw more specific error during search call. Revert workload again since research is saying mobile devices should be able to handle workgroups of 256.

Upload bundle for platform testing.

Set workload dynamically based on hardware.

Eliminate redundant find function. Rename #calculate to search in order to both better represent its purpose as well as work around Safari limitation on private class methods.

Note long benchmark run.

Skip nano-webgl-pow test comparison for now.

Upload bundle for testing.

Convert first of four v accessors to pointer references.

Benchmark min and max times, and add another round of testing.

Move benchmarks notes and add new timings.

Wait a maximum of 8 seconds to load GPU.

Remove outdated documentation comment.

Eliminate m array. Fix nonce construction.

Pass literal zeros since these array indexes are never initialized.

Yep, it was an issue.

Delete unused parameter.

Update G mix rounds 6-11.

Update G mix round 5 (round 4 was done in previous commit).

Document odd difference between blake C reference implementation and nano-webgl-pow port that might need fixing later.

Update G mix round 3.

Update G mix round 2.

Intermediate update to convert m array lookups to variables. Remaining 10 rounds of G mixing must be converted still.

Substitute remaining SIGMA82 array lookups with literal values.

Push new bundle for testing.

Restore SIGMA82 definition until substitution is complete. Substitute array indexes for first 6 rounds, last 6 will come soon.

Start eliminating SIGMA index lookups.

Remove unused addition function.

Document addition steps using structure from blake reference material.

Inline 64-bit addition to eliminate a function call.

Back up rolled-up shader code.

Reintroduce workload variable to allow hardware to control workgroup size, considered most important control in that regard.

All arrays will eventually be deconstructed for performance, so start creating the variables now.

Remove logging.

Set local variable for UBO member to avoid slowly dereferencing it.

Unroll blake compression rounds.

PoW does not need to be secure, so just use basic fast PRNG.

Restart calculatino if nonce is not found, in order to accomodate smaller workgroup sizes. Suboptimal but can be improved later.

Skip original pow tests for now. Reduce test suite size.

Fix copypasta typos in threshold check.

Shortcut conditional by validating nonce prior to loading atomic. Remove redundant return statement.

Revert nonce and found swap.

Scrap in-shader loop since it is probably triggering browser watchdog timers as a long-running process on lower-end hardware, just redispatch instead.

Remove extraneous commenting. Move XOR to start of for loop.  Whitespace.

Decrease workgroup size and implement loop in shader main. Add some notes for potential changes later.

Stress test block performance with PowGpu.

Save some benchmarking notes.

Document construction and purpose of thread ID.

Change loop index variable name in G mixing function so it does not collide with other declarations elsewhere.

Push new bundles for platform testing.

Restore additional block performance tests now that PowGpu is working.

Add PowGpu performance tests outside of Block scope and Web Workers.

Reset `found` flag between executions.

Export PowGpu from main for users beyond Blocks. Small comment.

Configure UBO buffer during static initialization.

Fix threshold offset in Javascript. Tweak commenting and remove logging.

Pass in random data to initialize nonce.

Reduce block performance test for getting powgpu right.

Remove logging.

Move atomic check to start of main. Add atomic check prior to setting nonce.

Tweak logging.

Whitespace.

Do a bit reversal to create a psuedo random looking nonce even though it mathematically doesn't matter if it's truly random or not.

Bundle changes to test on other platforms.

Fix nonce output to CPU which is expecting the 32-bit values in reverse for reasons I don't fully understand, something to do with endianness I'm sure.

Remove redundant comment.

Rename variables for a little more clarity.

Change blake2b function name to align with reference implementation.

Tweak commenting and test loop size.

Only try to load GPU every tenth of a second.

Extend dispatch dimensions. Tweak commenting.

Remove unused RAF call. Warn user if pow completed without a nonce.

Ensure nonce hex string is 16 characters.

Initialize v before computation loop. Change from potentially-endless while loop to restricted for loop.