functionalscript 0.37.0 → 0.38.0

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

@@ -1,13 +1,14 @@
 import { length, maxLength, msb, vec, vec8 } from '../types/bit_vec/module.f.js';
 import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
 import { computeSync, sha256 } from '../crypto/sha2/module.f.js';
-import { fileCas, casAddFile, casUpload } from './module.f.js';
-import { pure } from '../effects/module.f.js';
+import { fileCas, casAddFile, collectRead, casUpload } from './module.f.js';
+import { decode, pure } from '../effects/module.f.js';
 import { mkdir, writeFile, rm, readFile, access } from '../effects/node/module.f.js';
 import { error, ok } from '../types/result/module.f.js';
 import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
 import { join } from '../path/module.f.js';
 import { nonEmpty, empty } from '../effects/list/module.f.js';
+import { assert, assertEq, assertNotNullish } from '../asserts/module.f.js';
 const testDir = './test-cas-cli';
 // Create a 128 KiB big file content (at the max Vec size limit)
 // This tests the boundary where files are at the chunk size limit
@@ -36,10 +37,7 @@ const testAddBigFile = () => mkdir(testDir, { recursive: true }).step(() => {
             }
             // Verify hash can be encoded/decoded
             const hashCBase32 = vecToCBase32(hash);
-            const decodedHash = cBase32ToVec(hashCBase32);
-            if (decodedHash === null) {
-                throw new Error('Failed to decode hash from base32');
-            }
+            assertNotNullish(cBase32ToVec(hashCBase32), new Error('Failed to decode hash from base32'));
             return rm(testDir).step(() => pure(undefined));
         });
     });
@@ -90,16 +88,10 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const payload = nonEmpty(ok(content), empty());
         const [state1, writeResult] = virtual(emptyState)(c.write(payload));
-        if (writeResult[0] !== 'ok') {
-            throw ['expected write ok', writeResult];
-        }
+        assert(writeResult[0] === 'ok', ['expected write ok', writeResult]);
         const hash = writeResult[1];
-        if (length(hash) !== 256n) {
-            throw ['expected 256-bit hash', length(hash)];
-        }
-        if (msb.cmp(hash)(computeSync(sha256)([content])) !== 0) {
-            throw 'write hash mismatch';
-        }
+        assertEq(length(hash), 256n, ['expected 256-bit hash', length(hash)]);
+        assertEq(msb.cmp(hash)(computeSync(sha256)([content])), 0, 'write hash mismatch');
         const drain = (acc) => (stream) => stream.step((node) => {
             if (node === undefined) {
                 return pure(ok(acc));
@@ -111,24 +103,16 @@ export const proof = {
             return drain([...acc, first[1]])(tail);
         });
         const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
-        if (readResult[0] !== 'ok') {
-            throw ['expected read ok', readResult];
-        }
-        if (msb.cmp(msb.listToVec(readResult[1]))(content) !== 0) {
-            throw 'read content mismatch';
-        }
+        assert(readResult[0] === 'ok', ['expected read ok', readResult]);
+        assertEq(msb.cmp(msb.listToVec(readResult[1]))(content), 0, 'read content mismatch');
     },
     casReadMissingShard: () => {
         // A missing shard surfaces as an explicit error *item*, never as end-of-stream.
         const c = fileCas(sha256)('.');
         const hash = computeSync(sha256)([vec8(0x2an)]);
         const node = virtual(emptyState)(c.read(hash))[1];
-        if (node === undefined) {
-            throw 'missing shard must not be EOF';
-        }
-        if (node.first[0] !== 'error') {
-            throw ['expected error item', node.tail];
-        }
+        assert(node !== undefined, 'missing shard must not be EOF');
+        assert(node.first[0] === 'error', ['expected error item', node.tail]);
     },
     casWriteMultiChunk: () => {
         // A multi-chunk payload streams through `writeBytes` chunk-by-chunk (the lease is
@@ -138,13 +122,9 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const payload = chunks.reduceRight((tail, chunk) => nonEmpty(ok(chunk), tail), empty());
         const [state1, writeResult] = virtual(emptyState)(c.write(payload));
-        if (writeResult[0] !== 'ok') {
-            throw ['expected write ok', writeResult];
-        }
+        assert(writeResult[0] === 'ok', ['expected write ok', writeResult]);
         const hash = writeResult[1];
-        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
-            throw 'multi-chunk write hash mismatch';
-        }
+        assertEq(msb.cmp(hash)(computeSync(sha256)(chunks)), 0, 'multi-chunk write hash mismatch');
         const drain = (acc) => (stream) => stream.step((node) => {
             if (node === undefined) {
                 return pure(ok(acc));
@@ -156,13 +136,9 @@ export const proof = {
             return drain([...acc, first[1]])(tail);
         });
         const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
-        if (readResult[0] !== 'ok') {
-            throw ['expected read ok', readResult];
-        }
+        assert(readResult[0] === 'ok', ['expected read ok', readResult]);
         const expected = msb.concat(msb.concat(chunks[0])(chunks[1]))(chunks[2]);
-        if (msb.cmp(msb.listToVec(readResult[1]))(expected) !== 0) {
-            throw 'multi-chunk read content mismatch';
-        }
+        assertEq(msb.cmp(msb.listToVec(readResult[1]))(expected), 0, 'multi-chunk read content mismatch');
     },
     casWriteDedup: () => {
         // Same content ⇒ same hash; the second upload's replace-`rename` publishes over the
@@ -172,16 +148,10 @@ export const proof = {
         const payload = () => nonEmpty(ok(content), empty());
         const [state1, w1] = virtual(emptyState)(c.write(payload()));
         const [state2, w2] = virtual(state1)(c.write(payload()));
-        if (w1[0] !== 'ok' || w2[0] !== 'ok') {
-            throw ['expected both writes ok', w1, w2];
-        }
-        if (msb.cmp(w1[1])(w2[1]) !== 0) {
-            throw 'dedup hash mismatch';
-        }
+        assert(!(w1[0] !== 'ok' || w2[0] !== 'ok'), ['expected both writes ok', w1, w2]);
+        assertEq(msb.cmp(w1[1])(w2[1]), 0, 'dedup hash mismatch');
         const [, hashes] = virtual(state2)(c.list());
-        if (hashes.length !== 1) {
-            throw ['expected one shard after dedup', hashes.length];
-        }
+        assertEq(hashes.length, 1, ['expected one shard after dedup', hashes.length]);
     },
     casWriteErrorItemAborts: () => {
         // An error item mid-stream deletes the partial staging file and fails; nothing is
@@ -191,13 +161,9 @@ export const proof = {
         const errItem = error({ code: 'BOOM' });
         const payload = nonEmpty(okItem, nonEmpty(errItem, empty()));
         const [state1, result] = virtual(emptyState)(c.write(payload));
-        if (result[0] !== 'error') {
-            throw ['expected write error', result];
-        }
+        assert(result[0] === 'error', ['expected write error', result]);
         const [, hashes] = virtual(state1)(c.list());
-        if (hashes.length !== 0) {
-            throw ['expected nothing published on abort', hashes];
-        }
+        assertEq(hashes.length, 0, ['expected nothing published on abort', hashes]);
     },
     casWriteReadExceedsMaxLength: () => {
         // The point of streaming: a payload larger than a single `Vec`'s `maxLength`
@@ -211,13 +177,9 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const payload = chunks.reduceRight((tl, chunk) => nonEmpty(ok(chunk), tl), empty());
         const [state1, w] = virtual(emptyState)(c.write(payload));
-        if (w[0] !== 'ok') {
-            throw ['expected write ok', w];
-        }
+        assert(w[0] === 'ok', ['expected write ok', w]);
         const hash = w[1];
-        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
-            throw 'oversized write hash mismatch';
-        }
+        assertEq(msb.cmp(hash)(computeSync(sha256)(chunks)), 0, 'oversized write hash mismatch');
         // Fold the read stream straight into a fresh SHA-2 state — never one `Vec`.
         const rehash = (state) => (stream) => stream.step((node) => {
             if (node === undefined) {
@@ -230,12 +192,8 @@ export const proof = {
             return rehash(sha256.append(first[1])(state))(tail);
         });
         const [, readBack] = virtual(state1)(rehash(sha256.init)(c.read(hash)));
-        if (readBack[0] !== 'ok') {
-            throw ['expected read ok', readBack];
-        }
-        if (msb.cmp(readBack[1])(hash) !== 0) {
-            throw 'oversized read-back hash mismatch';
-        }
+        assert(readBack[0] === 'ok', ['expected read ok', readBack]);
+        assertEq(msb.cmp(readBack[1])(hash), 0, 'oversized read-back hash mismatch');
     },
     casWriteGcReclaimsExpired: () => {
         // A staging file whose deadline is in the past is reclaimed by the GC that `write`
@@ -250,45 +208,78 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const x = c.write(nonEmpty(ok(content), empty()));
         const [state1, w] = virtual(state0)(x);
-        if (w[0] !== 'ok') {
-            throw ['expected write ok', w];
-        }
+        assert(w[0] === 'ok', ['expected write ok', w]);
         const [, present] = virtual(state1)(access(stalePath));
-        if (present[0] !== 'error') {
-            throw 'expected GC to reclaim the expired staging file';
-        }
+        assert(present[0] === 'error', 'expected GC to reclaim the expired staging file');
     },
     casUploadSuccess: () => {
         // A successful upload returns the hash and deletes the source file from cas_upload/.
         const content = vec8(0x2an);
         const state0 = { ...emptyState, root: { 'cas_upload': { 'myfile': [content] } } };
         const [state1, result] = virtual(state0)(casUpload('.')('myfile'));
-        if (result[0] !== 'ok') {
-            throw ['expected casUpload ok', result];
-        }
-        if (length(result[1]) !== 256n) {
-            throw ['expected 256-bit hash', length(result[1])];
-        }
+        assert(result[0] === 'ok', ['expected casUpload ok', result]);
+        assertEq(length(result[1]), 256n, ['expected 256-bit hash', length(result[1])]);
         // Source must be deleted after successful publish.
         const srcPath = join('.', 'cas_upload', 'myfile');
         const [, srcAccess] = virtual(state1)(access(srcPath));
-        if (srcAccess[0] !== 'error') {
-            throw 'expected source to be deleted after successful upload';
-        }
+        assert(srcAccess[0] === 'error', 'expected source to be deleted after successful upload');
     },
     casUploadFailureKeepsSource: () => {
         // A missing source file causes write to fail; casUpload returns error and the
         // source is left in place (trivially: it was never there, but the upload is not published).
         const state0 = { ...emptyState, root: {} };
         const [state1, result] = virtual(state0)(casUpload('.')('nonexistent'));
-        if (result[0] !== 'error') {
-            throw ['expected casUpload to fail on missing source', result];
-        }
+        assert(result[0] === 'error', ['expected casUpload to fail on missing source', result]);
         // Nothing published to the store.
         const c = fileCas(sha256)('.');
         const [, hashes] = virtual(state1)(c.list());
-        if (hashes.length !== 0) {
-            throw ['expected nothing published on failed upload', hashes];
+        assertEq(hashes.length, 0, ['expected nothing published on failed upload', hashes]);
+    },
+    collectReadDrainsChunks: () => {
+        // The common path: every chunk is `ok`, so collectRead concatenates them all
+        // and returns the whole blob as one `Vec`.
+        const stream = nonEmpty(ok(vec8(0x11n)), nonEmpty(ok(vec8(0x22n)), empty()));
+        const d = decode(collectRead(stream));
+        assert(d.done, 'expected collectRead to finish without issuing a command');
+        assertEq(d.result[0], 'ok');
+    },
+    collectReadPropagatesErrorItem: () => {
+        // An error item mid-stream short-circuits collectRead with that same error.
+        const boom = error('boom');
+        const stream = nonEmpty(ok(vec8(0x11n)), nonEmpty(boom, empty()));
+        const d = decode(collectRead(stream));
+        assert(d.done, 'expected collectRead to finish without issuing a command');
+        assertEq(d.result[0], 'error');
+        assertEq(d.result[1], 'boom');
+    },
+    // A single `Vec` cannot exceed `maxLength` bits — feed a pure stream whose second
+    // chunk pushes the running total just over the limit so the overflow guard fires
+    // without any real I/O.
+    collectReadOverflow: () => {
+        const half = maxLength / 2n;
+        const v1 = vec(half)(0n);
+        const v2 = vec(half + 1n)(0n);
+        const stream = nonEmpty(ok(v1), nonEmpty(ok(v2), empty()));
+        const d = decode(collectRead(stream));
+        assert(d.done, 'expected collectRead to finish without issuing a command');
+        assertEq(d.result[0], 'error');
+    },
+    casListPropagatesNonNotFoundAccessError: () => {
+        // A non-ENOENT `access` failure (permissions, corruption) is a genuine storage
+        // error and must propagate out of `list`, not be swallowed as an empty store.
+        const c = fileCas(sha256)('.');
+        const boom = { code: 'EACCES' };
+        const d = decode(c.list());
+        assert(!d.done, 'expected list() to issue an access command first');
+        assertEq(d.command, 'access');
+        const continuation = d.continuation;
+        let threw;
+        try {
+            continuation(error(boom));
+        }
+        catch (e) {
+            threw = e;
         }
+        assertEq(threw, boom);
     },
 };

package/{fs → fjs}/ci/config/module.f.d.ts

@@ -19,24 +19,24 @@ export declare const images: {
         readonly arm: 'windows-11-arm';
     };
 };
-export declare const functionalscript: '0.36.0';
+export declare const functionalscript: '0.37.0';
 export declare const bun = "1.3.14";
-export declare const deno = "2.9.2";
+export declare const deno = "2.9.3";
 export declare const playwright = "1.61.1";
 export declare const node: {
     readonly default: '26.5.0';
     readonly node22: '22.23.1';
     readonly node24: '24.18.0';
 };
-export declare const wasmtime = "46.0.1";
+export declare const wasmtime = "47.0.2";
 export declare const wasmer = "7.2.0";
 export declare const actions: {
     readonly 'actions/checkout': 'v7';
-    readonly 'actions/setup-node': 'v6.4.0';
+    readonly 'actions/setup-node': 'v7.0.0';
     readonly 'actions/cache': 'v6.1.0';
     readonly 'denoland/setup-deno': 'v2.0.5';
     readonly 'oven-sh/setup-bun': 'v2.2.0';
     readonly 'bytecodealliance/actions/wasmtime/setup': 'v1.1.3';
     readonly 'wasmerio/setup-wasmer': 'v3.1';
-    readonly 'dtolnay/rust-toolchain': '1.96.1';
+    readonly 'dtolnay/rust-toolchain': '1.97.1';
 };

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

@@ -24,11 +24,11 @@ export const images = {
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.36.0';
+export const functionalscript = '0.37.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.9.2';
+export const deno = '2.9.3';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.61.1';
 // https://nodejs.org/en/download
@@ -38,7 +38,7 @@ export const node = {
     node24: '24.18.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '46.0.1';
+export const wasmtime = '47.0.2';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.2.0';
 // GitHub Action versions used by CI step builders. The key is the action
@@ -49,7 +49,7 @@ export const actions = {
     // https://github.com/marketplace/actions/checkout
     'actions/checkout': 'v7',
     // https://github.com/marketplace/actions/setup-node-js-environment
-    'actions/setup-node': 'v6.4.0',
+    'actions/setup-node': 'v7.0.0',
     // https://github.com/marketplace/actions/cache
     'actions/cache': 'v6.1.0',
     // https://github.com/marketplace/actions/setup-deno
@@ -61,5 +61,5 @@ export const actions = {
     // https://github.com/wasmerio/setup-wasmer
     'wasmerio/setup-wasmer': 'v3.1',
     // https://rust-lang.org/ - value is Rust version, not action version
-    'dtolnay/rust-toolchain': '1.96.1',
+    'dtolnay/rust-toolchain': '1.97.1',
 };

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

@@ -3,13 +3,14 @@ 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 { 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');

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

@@ -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/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 { 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 → 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/proof.f.js

@@ -6,29 +6,21 @@ 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.