fix(ext/node): expose internal/js_stream_socket and add default read path (#34088)

## Summary

Implements the `internal/js_stream_socket` Node compat polyfill so test
fixtures and library code can `require('internal/js_stream_socket')` to
wrap arbitrary `Duplex` streams in a `net.Socket` interface.

The class itself already existed (used internally by `_tls_wrap.js` for
TLS-over-Duplex), but two things prevented the 10 listed tests from
running:

1. **It was not registered as a require()-able builtin.** Add it to the
   builtin module map in `ext/node/polyfills/01_require.js`.
2. **The non-TLS read path was unimplemented.** The handle's
   `readBuffer`/`emitEOF` were stubbed `null` and only populated by
   `TLSWrap.attachJsStream()`. For a bare `new JSStreamSocket(duplex)`,
   data read from the underlying Duplex was silently dropped and EOF
   never propagated, so the wrapping `Socket` never emitted `'data'` or
   `'end'`. Default both to forward through the standard `onread`
callback installed by `net._initSocketHandle`;
`TLSWrap.attachJsStream()`
   still overrides them when needed.

Small follow-ups uncovered by the now-runnable tests:

- Emit `ERR_STREAM_WRAP` (Node-style error code with the standard
  message) instead of a plain `Error` when the wrapped stream is in
  string/objectMode.
- Attach `StreamWrap` as a self-reference on `JSStreamSocket` so both
  `const StreamWrap = require('internal/js_stream_socket')` and
  `const { StreamWrap } = require('internal/js_stream_socket')` patterns
  work — Node's module exports the class and self-references the name.
- `Socket.prototype.bufferSize` returns `undefined` (not `0`) after the
  handle is gone, matching Node.

## Tests

8 of the 10 tests from denoland/orchid#90 now pass and are added to
`tests/node_compat/config.jsonc`:

- `parallel/test-stream-wrap-drain.js`
- `parallel/test-stream-wrap-encoding.js`
- `parallel/test-stream-wrap.js`
- `parallel/test-tls-streamwrap-buffersize.js`
- `parallel/test-wrap-js-stream-destroy.js`
- `parallel/test-wrap-js-stream-duplex.js`
- `parallel/test-wrap-js-stream-exceptions.js`
- `parallel/test-wrap-js-stream-read-stop.js`

Two tests still fail because of unrelated polyfill gaps and are left out
of `config.jsonc`:

- `parallel/test-tls-generic-stream.js` — asserts
  `TLSSocket._handle.writeQueueSize > 0` after a buffered write. The
  Rust `TLSWrap` op doesn't expose `writeQueueSize`.
- `parallel/test-http-agent-domain-reused-gc.js` — relies on
  `handle.asyncReset(new ReusedHandle(...))` firing an `init` async hook
  for the `ReusedHandle` resource and a matching `before` hook on reuse.
  Our handles don't implement `asyncReset` and `_http_agent.js` short-
  circuits when the method is missing, so the hook never fires.

Both are pre-existing Deno limitations beyond the scope of implementing
`internal/js_stream_socket`.

## Test plan

- [x] `cargo test -p node_compat_tests test-stream-wrap` — 3 pass
- [x] `cargo test -p node_compat_tests test-wrap-js-stream` — 4 pass
- [x] `cargo test -p node_compat_tests test-tls-streamwrap` — 1 pass
- [x] Existing `test-net-buffersize.js`, `test-net-after-close.js`,
      `test-tls-buffersize.js`, `test-net-pingpong.js`,
      `test-tls-handshake-error.js`, `test-tls-server-verify.js` still
      pass (`bufferSize` getter change verified non-regressing)
- [x] `./x fmt` clean
- [x] `./x lint-js` clean

Closes denoland/orchid#90

Author: divybot

ext/node/polyfills/01_require.js

@@ -215,6 +215,9 @@ const internalStreamsState =
 const internalSocketAddress = core.loadExtScript(
   "ext:deno_node/internal/socketaddress.js",
 );
+const internalJsStreamSocket = core.loadExtScript(
+  "ext:deno_node/internal/js_stream_socket.js",
+).default;
 const internalTestBinding = core.loadExtScript(
   "ext:deno_node/internal/test/binding.ts",
 );
@@ -346,6 +349,7 @@ function setupBuiltinModules() {
     "internal/streams/lazy_transform": internalStreamsLazyTransform,
     "internal/streams/state": internalStreamsState,
     "internal/socketaddress": internalSocketAddress,
+    "internal/js_stream_socket": internalJsStreamSocket,
     "internal/test/binding": internalTestBinding,
     "internal/timers": internalTimers,
     "internal/url": internalUrl,

ext/node/polyfills/internal/js_stream_socket.js

@@ -17,11 +17,16 @@ const { codeMap, UV_ECANCELED } = core.loadExtScript(
   "ext:deno_node/internal_binding/uv.ts",
 );
 const {
+  kArrayBufferOffset,
   kBytesWritten,
   kLastWriteWasAsync,
+  kReadBytesOrError,
   streamBaseState,
 } = core.loadExtScript("ext:deno_node/internal_binding/stream_wrap.ts");
 const { Buffer } = core.loadExtScript("ext:deno_node/internal/buffer.mjs");
+const { ERR_STREAM_WRAP } = core.loadExtScript(
+  "ext:deno_node/internal/errors.ts",
+);
 
 const kCurrentWriteRequest = Symbol("kCurrentWriteRequest");
 const kCurrentShutdownRequest = Symbol("kCurrentShutdownRequest");
@@ -126,9 +131,23 @@ class JSStreamSocket extends lazyNet().Socket {
       shutdown(req) {
         return handle[kOwner].doShutdown(req);
       },
-      // These are set by TLSWrap after attachJsStream()
-      readBuffer: null,
-      emitEOF: null,
+      // Default read path: forward bytes from the underlying Duplex into
+      // the wrapping Socket's readable side via the standard onread
+      // callback (set by net._initSocketHandle).
+      // TLSWrap.attachJsStream() overrides these to route data through
+      // the TLS engine instead.
+      readBuffer(chunk) {
+        if (!handle.onread) return;
+        const len = chunk.byteLength ?? chunk.length ?? 0;
+        if (len === 0) return;
+        streamBaseState[kArrayBufferOffset] = chunk.byteOffset ?? 0;
+        streamBaseState[kReadBytesOrError] = len;
+        handle.onread.call(handle, chunk, len);
+      },
+      emitEOF() {
+        if (!handle.onread) return;
+        handle.onread.call(handle, null, codeMap.get("EOF"));
+      },
       reading: false,
     };
 
@@ -142,7 +161,7 @@ class JSStreamSocket extends lazyNet().Socket {
         // Make sure that no further `data` events will happen.
         stream.pause();
         stream.removeListener("data", ondata);
-        this.emit("error", new Error("Stream is not in binary mode"));
+        this.emit("error", new ERR_STREAM_WRAP());
         return;
       }
 
@@ -289,5 +308,11 @@ class JSStreamSocket extends lazyNet().Socket {
   }
 }
 
+// Node's lib/internal/js_stream_socket exports the class as the module
+// itself, with `StreamWrap` as a self-reference so destructuring works:
+//   const StreamWrap = require('internal/js_stream_socket');
+//   const { StreamWrap } = require('internal/js_stream_socket');
+JSStreamSocket.StreamWrap = JSStreamSocket;
+
 return { JSStreamSocket, kJSStreamHandle, kOwner, default: JSStreamSocket };
 })();

ext/node/polyfills/net.ts

@@ -1621,8 +1621,7 @@ Object.defineProperty(Socket.prototype, "bufferSize", {
     if (this._handle) {
       return this.writableLength;
     }
-
-    return 0;
+    return undefined;
   },
 });
 

tests/node_compat/config.jsonc

@@ -3340,6 +3340,9 @@
     "parallel/test-stream-unpipe-event.js": {},
     "parallel/test-stream-unshift-empty-chunk.js": {},
     "parallel/test-stream-unshift-read-race.js": {},
+    "parallel/test-stream-wrap-drain.js": {},
+    "parallel/test-stream-wrap-encoding.js": {},
+    "parallel/test-stream-wrap.js": {},
     "parallel/test-stream-writable-aborted.js": {},
     "parallel/test-stream-writable-change-default-encoding.js": {},
     "parallel/test-stream-writable-clear-buffer.js": {},
@@ -3579,6 +3582,7 @@
     "parallel/test-tls-socket-close.js": {},
     "parallel/test-tls-socket-constructor-alpn-options-parsing.js": {},
     "parallel/test-tls-socket-destroy.js": {},
+    "parallel/test-tls-streamwrap-buffersize.js": {},
     "parallel/test-tls-writewrap-leak.js": {},
     "parallel/test-tls-timeout-server-2.js": {},
     "parallel/test-tls-tlswrap-segfault-2.js": {},
@@ -3591,6 +3595,10 @@
     "parallel/test-tls-wrap-event-emmiter.js": {},
     "parallel/test-tls-wrap-timeout.js": {},
     "parallel/test-tls-zero-clear-in.js": {},
+    "parallel/test-wrap-js-stream-destroy.js": {},
+    "parallel/test-wrap-js-stream-duplex.js": {},
+    "parallel/test-wrap-js-stream-exceptions.js": {},
+    "parallel/test-wrap-js-stream-read-stop.js": {},
     "parallel/test-trace-events-api.js": {
       "ignore": true,
       "reason": "Deno's node:trace_events polyfill is a stub (createTracing returns an object without .enable/.disable, getEnabledCategories returns \"\" instead of undefined). These tests were silently skipping via try/catch(require('trace_events')) until that lookup was fixed."