stream: proxy first own method in Readable.wrap()

The method-proxying loop in Readable.prototype.wrap() started at
index 1, silently skipping streamKeys[0] and leaving a method at the
first own-enumerable key unproxied.
This was introduced in ee9e2a2 when ArrayPrototypeForEach(
ObjectKeys(stream), ...) — which iterates from index 0 — was
rewritten as a manual for loop for performance. The faithful
translation starts at 0; a sibling loop converted in the same commit
correctly does so. The bug stayed hidden because keys[0] is usually
_events (a non-function), which the loop's typeof guard skips anyway.
Signed-off-by: Daijiro Wachi <daijiro.wachi@gmail.com>
PR-URL: #64048
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Mattias Buelens <mattias@buelens.com>

Author: watilde

lib/internal/streams/readable.js

@@ -1332,7 +1332,7 @@ Readable.prototype.wrap = function(stream) {
 
 // Proxy all the other methods. Important when wrapping filters and duplexes.
 conststreamKeys=ObjectKeys(stream);
-for(letj=1;j<streamKeys.length;j++){
+for(letj=0;j<streamKeys.length;j++){
 consti=streamKeys[j];
 if(this[i]===undefined&&typeofstream[i]==='function'){
 this[i]=stream[i].bind(stream);

test/parallel/test-stream2-readable-wrap-proxy-methods.js

@@ -0,0 +1,40 @@
+'use strict';
+constcommon=require('../common');
+constassert=require('assert');
+const{ Readable }=require('stream');
+
+// Readable.prototype.wrap() proxies the methods of the wrapped old-style
+// stream onto the new Readable. Regression test for an off-by-one that made
+// the proxy loop start at index 1, silently skipping the first own-enumerable
+// key returned by Object.keys() — so a method happening to sit at that first
+// position was never proxied.
+
+// A minimal old-style stream whose *first* own-enumerable key is a method.
+// `Object.keys()` preserves insertion order for string keys, so `firstMethod`
+// is `streamKeys[0]` — exactly the slot the bug skipped.
+constsource={
+firstMethod(){return`first:${this===source}`;},
+secondMethod(){return`second:${this===source}`;},
+on(){returnthis;},
+pause(){},
+resume(){},
+};
+
+assert.strictEqual(Object.keys(source)[0],'firstMethod');
+
+constwrapped=newReadable().wrap(source);
+
+// The method at the first key must be proxied (was `undefined` before the fix).
+assert.strictEqual(typeofwrapped.firstMethod,'function');
+assert.strictEqual(typeofwrapped.secondMethod,'function');
+
+// Proxied methods stay bound to the original stream.
+assert.strictEqual(wrapped.firstMethod(),'first:true');
+assert.strictEqual(wrapped.secondMethod(),'second:true');
+
+// Existing Readable methods must not be clobbered by the proxying.
+assert.strictEqual(wrapped.pause,Readable.prototype.pause);
+assert.strictEqual(wrapped.resume,Readable.prototype.resume);
+
+wrapped.on('end',common.mustNotCall());
+wrapped.destroy();