Hello, I badly apologize if the question does not fit this room, but I'm having trouble understanding a piece of JavaScript code and no one could help me in regular javascript servers. The code I'm concerned with is the following (ready to use):

(async () => {
    const stream = (function* chunks(json) {
        const jsonString = JSON.stringify(json);
        const jsonBytes = new TextEncoder().encode(jsonString);
    
        let index = 0;
        while(index < jsonBytes.length) {
            const i = index;
            const j = Math.min(jsonBytes.length, i + 10);
    
            const slice = jsonBytes.slice(i, j);    // LINE (A)
            index = j;
            yield slice;
        }
    })({"Hello!": [2023, 2024 ]});
    
    const jsonBack = await new Response(new ReadableStream({
        type: "bytes",
        start: function(controller) {
            for(const chunk of stream) {
                controller.enqueue(chunk);
            }
            controller.close();
        }
    })).json();
    
    console.log(jsonBack);
})()

this code works as expected (google chrome, firefox; latest versions). However, when I replace in line A, .slice with .subarray, I get different kind of issues, telling me the JSON ends abnormally (in both browsers). I've crawled the official specification of the different API's, and I couldn't find a single clue about whether or not the version with .subarray violates the specification.

For what is worth, turning .json() to .text() confirms that in the .subarray case, only the first chunk seems to be taken into account. I assume (but not sure about it) the same happens for .json().

My question, to make it clear, is: is the current code with .slice already violating a point of the specification; and is the version with .subarray violating it and how? Could it be a browser bug, common to both Firefox and Google Chrome? Many thanks in advance! This issue puzzles me a lot for some days now

okay for what's worth, I understood what happened here. When enqueuing, the buffer is detached. This forces the length to go down to 0, which abruptly terminates my emission loop and I never emit more than 1 chunk, which is the cause of all issues. That's why I don't have the expected TypeError, since actually I never pass a detached buffer, as the loop terminates after.

I must say debugging this was kind of an adventure! Not sure if it's all clear for everyone that enqueue detaches the buffer, while reading the documentation. but I eventually found it, collecting all the pieces together