Poor performance when reading primitive types that aren't UInt8?

I am trying to read some data in a looping way, reading a mix of primitive types. Here's a simple MWE where I am just reading Int32s:

import TranscodingStreams

function writer()
    open(joinpath(homedir(), "test.dat"), write=true) do io
        write(io, rand(Int32, 1_000_000))
    end
end

function reader()
    open(TranscodingStreams.NoopStream, joinpath(homedir(), "test.dat")) do io
        for i in 1:1_000_000
            read(io, Int32)
            # read(io, UInt8)
        end
    end
end

writer()
reader()

julia> @time reader()
  0.025751 seconds (1.00 M allocations: 15.276 MiB)

This produces an allocation per read call, which becomes very slow in a tight loop! Reading 4 million UInt8s (see commented out line) has effectively zero allocations in the loop.

Is this expected behavior? Is my use-case uncommon? It does not seem to be specific to the NoopStream, since I first encountered it with the CodecZstd.ZsdtDecompressorStream.

Thanks.

Reproduce the allocation difference in the reported reader() MWE using TranscodingStreams.NoopStream, comparing read(io, Int32) with read(io, UInt8). Trace the read entry points involved in primitive-type reads and confirm that the completed work removes the per-call allocation without regressing the existing UInt8 behavior.