IIRC, a lot of the code could benefit from a single “ask for one chunk, read it into memory, validate against a digest” utility.

Arguably that’s a cleanup that should not block this PR…

This works.

Maybe another way to structure the consumers would be to:

defer consumeRemainingStreamsOrErrors(streamsOrErrors) // this loop, ignoring all errors. Also see elsewhere — maybe this should be a context cancellation instead.
// consume data: if there is only one chunk:
reader, err := getNextStream(streamsOrErrors) // if this contains an error, or is closed, returns an error
// Optionally, after all data is consumed: Alternatively, this can be enforced in `getBlobAt` — if we are fine with ignoring errors after all expected data is consumed, like excess chunks.
err := ensureAllDone(streamsOrErrors) // Ensure straemsOrErrors is at EOF, there are no unexpected items, there are no errors reported .

looking more into this, I don't think we should ignore errors. I'll move the code to a new function

Having to consume everything is, generally, an undesired cost.

The typical handling for that is to use a cancellable context, and to have the consumer here defer cancelTheContext; and for the goroutine to observe that context and terminate on cancellation.

Sadly that is not possible in ImageSourceSeekable (no Context parameter), but maybe we could build the streamsOrErrors the idiomatic way, and have getBlobAt deal with draining the produced output, instead of doing that in every consumer.

(I didn’t try, this might be too hard to do. Notably channel sends in getBlobAt would also have to select vs. the context terminating.)