Class: Buffer do not follow when the underlying ArrayBuffer is resized

[klebom]

Version

v21.7.1

Platform

Microsoft Windows NT 10.0.22631.0 x64

Subsystem

Class: Buffer

What steps will reproduce the bug?

const arraybuffer = new ArrayBuffer(4, { maxByteLength: 4096 });

const uint8array = new Uint8Array(arraybuffer);

uint8array.set([0,1,2,3]);

const buffer = Buffer.from(arraybuffer);

console.error(uint8array);
console.error(buffer);

arraybuffer.resize(8);
uint8array.set([4,5,6,7],4);

uint8array[0]=0xff;

console.error(uint8array);
console.error(buffer);

Output:

Uint8Array(4) [ 0, 1, 2, 3 ]
<Buffer 00 01 02 03>
Uint8Array(8) [
  255, 1, 2, 3,
    4, 5, 6, 7
]
<Buffer ff 01 02 03>

How often does it reproduce? Is there a required condition?

always

What is the expected behavior? Why is that the expected behavior?

Expecting buffer to be resized and output to be:

<Buffer ff 01 02 03 04 05 06 07>

What do you see instead?

<Buffer ff 01 02 03>

Additional information

If the resolution to this is that Buffer isn't going to support ArrayBuffer.resize() that should be reflected in the documentation.

[targos]

Behavior comes from:

node/lib/buffer.js

Lines 476 to 505 in bae14b7

	function fromArrayBuffer(obj, byteOffset, length) {
	// Convert byteOffset to integer
	if (byteOffset === undefined) {
	byteOffset = 0;
	} else {
	byteOffset = +byteOffset;
	if (NumberIsNaN(byteOffset))
	byteOffset = 0;
	}
	const maxLength = obj.byteLength - byteOffset;
	if (maxLength < 0)
	throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');
	if (length === undefined) {
	length = maxLength;
	} else {
	// Convert length to non-negative integer.
	length = +length;
	if (length > 0) {
	if (length > maxLength)
	throw new ERR_BUFFER_OUT_OF_BOUNDS('length');
	} else {
	length = 0;
	}
	}
	return new FastBuffer(obj, byteOffset, length);
	}

byteOffset and length are initially undefined, but the function ensures they are numbers, and if they are specified, the typed array's length stays fixed.

/cc @nodejs/buffer

[jasnell]

Buffer has always been assumed to be non-resizable. I'm wondering if the right fix for now shouldn't be to forbid creating a Buffer from a resizable ArrayBuffer until we can make sure that all of Buffer's APIs handle it appropriately

[ronag]

I'm wondering if the right fix for now shouldn't be to forbid creating a Buffer from a resizable ArrayBuffer until we can make sure that all of Buffer's APIs handle it appropriately

This will break me. Please don't.