That will cause soo much confusion. I believe there are several methods/props that Buffer override and which act differently than Uint8Array.

In particular .slice work differently. Not sure if there are others.

I'm fine with using Uint8Array for Web apis which define the type. But for node api's I think we should stick with Buffer.

It really depends on the subsystems we are targeting. It's impossible to make a generic call.

I have a big problem with Buffers. They must be killed.

1. buffer.slice() is mutable copy, uint8array.slice() is immutable. This is very bad. Recently got hit with a bug report. I was checking for the input to be instanceof Uint8Array and did array.slice(), then operated on the copy. But that doesn't work with buffers! The buffers were mutated even after copy. Why are they instance of Uint8Arrays if the behavior is different? paulmillr/noble-ed25519#45
2. They are not supported in browsers and will never be. Adding an additional in-browser shim for buffers is bad.
3. They expose private information to a global variable. Imagine you're developing some secure software. You reason about zeroing data etc. #41467

// Somewhere in your code
const privateBuf = Buffer.from(privateKey, 'hex');

// Rogue package can access
Buffer.from('1').buffer
// Which will of course show the contents of `privateBuf`
// No need in complex memory dumps!

This happens because there is 8KB shared buffer reused for all Buffer.from calls! There is zero need in making this as subtle as it is right now. Buffer.allocUnsafe seems like a good name for "using a part of global shared buffer", Buffer.from is not. Search GitHub code for the snippet and tell me how many people know about the "feature".

Hey @paulmillr can we avoid statements like "they must be killed"? it detracts from technical arguments you are making and anyone with a strong opinion the other way will automatically be put on a defensive rather than be in a learning mood.

(I'm going to read the rest of it just wanted to start with that quickly before others read it)

buffer.slice() is mutable copy, uint8array.slice() is immutable. This is very bad. Recently got hit with a bug report. I was checking for the input to be instanceof Uint8Array and did array.slice(), then operated on the copy. But that doesn't work with buffers! The buffers were mutated even after copy. Why are they instance of Uint8Arrays if the behavior is different? Regression in 1.5.0 paulmillr/noble-ed25519#45

FWIW: I agree having an API that behaves like a subclass but "lies" about keeping the same API structure is super-confusing.