Corrupted data in Lambda function URL streaming response

I have a simple lambda function that streams a large response (around 500KB), and I occasionally observe that the response received by the client is corrupted (approx 1 out of 1500 response are corrupted).

Here is the function code:

const MAX_LINES = 30000

export const handler = awslambda.streamifyResponse(async (_event, responseStream, _context) => {
  await new Promise((resolve, _reject) => {
    let i = 1

    responseStream.on('error', (err) => {
      console.error('error:', err)
      _reject(err)
    })

    responseStream.on('close', () => {
      console.log('closed')
    })

    responseStream.on('finish', () => {
      console.log('finished')
      resolve()
    })

    write()

    function write() {
      let ok = true
      do {
        if (i === MAX_LINES) {
          responseStream.end(`This is line ${i}\n`)
        } else {
          ok = responseStream.write(`This is line ${i}\n`)
        }
        i++
      } while (i <= MAX_LINES && ok)

      if (i <= MAX_LINES) {
        console.log('buffer full - waiting for drain')
        responseStream.once('drain', write)
      }
    }
  })
})

The function is configured to use a function URL, with RESPONSE_STREAM, no auth. Memory is set to 1024MB, timeout 30s, unreserved concurrency, everything else as defaults.

The function ARN is arn:aws:lambda:us-west-2:947708160692:function:streaming-test

I used this Node.js script to make requests and detect corrupted responses:

import fs from 'fs'

const expected = fs.readFileSync('expected.txt', 'utf8') // you can download this once from the function URL using curl -o to use as a comparison
let corrupted = 0
let good = 0

const url = 'https://***redacted***' // replace with the function URL

for (;;) {
  const result = await fetch(url)
  const data = await result.text()

  if (data !== expected) {
    corrupted++
    console.log('Corrupted:', corrupted, 'good:', good)
    fs.writeFileSync(`corrupted-content-${corrupted.toString().padStart(4, '0')}.txt`, data)
  } else {
    good++
    process.stdout.write('.')
  }
}

Inspecting the corrupted responses, it looks like chunks are getting transposed, so chunk N is swapped with some chunk N+M. The total amount of data returned is the correct size.

Let me know if you are able to reproduce the issue, or if I can help clarify anything about my set up.