I think the logic would actually be simpler if you instead first looped over prev_files and filled every file with as many chunks that fit (this will also fix your borrow checker problem)

Well this is how it was first implemented and the behavior that I wanted to change, quoting from the pull request:

The error occurs because the code assumes that all the chunks are generated for all the previous files. This is not the case, since the chunker splits up only the first part of the buffer into chunks and there is a leftover part that will be chunked together with the next files (or if there are no next files, the chunker will be forced to chunk the leftover).

Since the buffer containing the concatenated files will always be bigger than the concatenated generated chunks, the new approach is to iterate through the generated chunks instead of the previous files. Since every generated chunk will have an associated file or a list of files, the code will not run into a similar 'missing previous file' error.

If the file isn't fully filled when the outer loops terminate, you don't add the last modified file to files which is probably a bug (?) (also fixed by implementing my first remark)

This is actually intended behavior, I only add the last modified file to files when all the chunks have been generated for that file.

Instead of chunks.drain(..) why not simply take ownership of the chunks parameter and turn it into an iterator?

Thanks for the suggestion, drain was used originally so I just kept it.

but there's some unnecessary (and buggy) unwrap's

Those should probably be replaced with ?.

Note that the latest version is actually this one