diff --git a/doc/api/fs.md b/doc/api/fs.md
index 643efaae03..b58393cb0d 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -286,13 +286,14 @@ performance implications for some applications. See the
 
 ## Class fs.Dir
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
 A class representing a directory stream.
 
-Created by [`fs.opendir()`][], [`fs.opendirSync()`][], or
-[`fsPromises.opendir()`][].
+Created by [`fs.opendir()`][], [`fs.opendirSync()`][], or [`fsPromises.opendir()`][].
+
+Example using async interation:
 
 ```js
 const fs = require('fs');
@@ -306,9 +307,19 @@ async function print(path) {
 print('./').catch(console.error);
 ```
 
+### dir.path
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string}
+
+The read-only path of this directory as was provided to [`fs.opendir()`][],
+[`fs.opendirSync()`][], or [`fsPromises.opendir()`][].
+
 ### dir.close()
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
 * Returns: {Promise}
@@ -321,7 +332,7 @@ closed.
 
 ### dir.close(callback)
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
 * `callback` {Function}
@@ -334,104 +345,84 @@ The `callback` will be called after the resource handle has been closed.
 
 ### dir.closeSync()
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
 Synchronously close the directory's underlying resource handle.
 Subsequent reads will result in errors.
 
-### dir.path
-<!-- YAML
-added: v12.12.0
--->
-
-* {string}
-
-The read-only path of this directory as was provided to [`fs.opendir()`][],
-[`fs.opendirSync()`][], or [`fsPromises.opendir()`][].
-
-### dir.read()
+### dir.read([options])
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
-* Returns: {Promise} containing {fs.Dirent|null}
+* `options` {Object}
+  * `encoding` {string|null} **Default:** `'utf8'`
+* Returns: {Promise} containing {fs.Dirent}
 
 Asynchronously read the next directory entry via readdir(3) as an
 [`fs.Dirent`][].
 
-After the read is completed, a `Promise` is returned that will be resolved with
-an [`fs.Dirent`][], or `null` if there are no more directory entries to read.
+A `Promise` is returned that will be resolved with a [Dirent][] after the read
+is completed.
 
-Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+_Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms._
 
-### dir.read(callback)
+### dir.read([options, ]callback)
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
+* `options` {Object}
+  * `encoding` {string|null} **Default:** `'utf8'`
 * `callback` {Function}
   * `err` {Error}
-  * `dirent` {fs.Dirent|null}
+  * `dirent` {fs.Dirent}
 
 Asynchronously read the next directory entry via readdir(3) as an
 [`fs.Dirent`][].
 
-After the read is completed, the `callback` will be called with an
-[`fs.Dirent`][], or `null` if there are no more directory entries to read.
+The `callback` will be called with a [Dirent][] after the read is completed.
 
-Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+The `encoding` option sets the encoding of the `name` in the `dirent`.
 
-### dir.readSync()
+_Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms._
+
+### dir.readSync([options])
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
-* Returns: {fs.Dirent|null}
+* `options` {Object}
+  * `encoding` {string|null} **Default:** `'utf8'`
+* Returns: {fs.Dirent}
 
 Synchronously read the next directory entry via readdir(3) as an
 [`fs.Dirent`][].
 
-If there are no more directory entries to read, `null` will be returned.
+The `encoding` option sets the encoding of the `name` in the `dirent`.
 
-Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+_Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms._
 
 ### dir\[Symbol.asyncIterator\]()
 <!-- YAML
-added: v12.12.0
+added: REPLACEME
 -->
 
-* Returns: {AsyncIterator} of {fs.Dirent}
+* Returns: {AsyncIterator} to fully iterate over all entries in the directory.
 
-Asynchronously iterates over the directory via readdir(3) until all entries have
-been read.
-
-Entries returned by the async iterator are always an [`fs.Dirent`][].
-The `null` case from `dir.read()` is handled internally.
-
-See [`fs.Dir`][] for an example.
-
-Directory entries returned by this iterator are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+_Directory entries returned by this iterator are in no particular order as
+provided by the operating system's underlying directory mechanisms._
 
 ## Class: fs.Dirent
 <!-- YAML
 added: v10.10.0
 -->
 
-A representation of a directory entry, as returned by reading from an
-[`fs.Dir`][].
+A representation of a directory entry, as returned by reading from an [`fs.Dir`][].
 
 Additionally, when [`fs.readdir()`][] or [`fs.readdirSync()`][] is called with
 the `withFileTypes` option set to `true`, the resulting array is filled with
@@ -2701,6 +2692,46 @@ Returns an integer representing the file descriptor.
 For detailed information, see the documentation of the asynchronous version of
 this API: [`fs.open()`][].
 
+## fs.opendir(path[, options], callback)
+<!-- YAML
+added: REPLACEME
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `encoding` {string|null} **Default:** `'utf8'`
+* `callback` {Function}
+  * `err` {Error}
+  * `dir` {fs.Dir}
+
+Asynchronously open a directory. See opendir(3).
+
+Creates an [`fs.Dir`][], which contains all further functions for reading from
+and cleaning up the directory.
+
+The `encoding` option sets the encoding for the `path` while opening the
+directory and subsequent read operations (unless otherwise overriden during
+reads from the directory).
+
+## fs.opendirSync(path[, options])
+<!-- YAML
+added: REPLACEME
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `encoding` {string|null} **Default:** `'utf8'`
+* Returns: {fs.Dir}
+
+Synchronously open a directory. See opendir(3).
+
+Creates an [`fs.Dir`][], which contains all further functions for reading from
+and cleaning up the directory.
+
+The `encoding` option sets the encoding for the `path` while opening the
+directory and subsequent read operations (unless otherwise overriden during
+reads from the directory).
+
 ## fs.read(fd, buffer, offset, length, position, callback)
 <!-- YAML
 added: v0.0.2
@@ -4862,21 +4893,14 @@ by [Naming Files, Paths, and Namespaces][]. Under NTFS, if the filename contains
 a colon, Node.js will open a file system stream, as described by
 [this MSDN page][MSDN-Using-Streams].
 
-### fsPromises.opendir(path\[, options\])
+## fsPromises.opendir(path[, options])
 <!-- YAML
-added: v12.12.0
-changes:
-  - version: v13.1.0
-    pr-url: https://github.com/nodejs/node/pull/30114
-    description: The `bufferSize` option was introduced.
+added: REPLACEME
 -->
 
 * `path` {string|Buffer|URL}
 * `options` {Object}
   * `encoding` {string|null} **Default:** `'utf8'`
-  * `bufferSize` {number} Number of directory entries that are buffered
-    internally when reading from the directory. Higher values lead to better
-    performance but higher memory usage. **Default:** `32`
 * Returns: {Promise} containing {fs.Dir}
 
 Asynchronously open a directory. See opendir(3).
@@ -4885,9 +4909,10 @@ Creates an [`fs.Dir`][], which contains all further functions for reading from
 and cleaning up the directory.
 
 The `encoding` option sets the encoding for the `path` while opening the
-directory and subsequent read operations.
+directory and subsequent read operations (unless otherwise overriden during
+reads from the directory).
 
-Example using async iteration:
+Example using async interation:
 
 ```js
 const fs = require('fs');
@@ -4901,7 +4926,7 @@ async function print(path) {
 print('./').catch(console.error);
 ```
 
-### fsPromises.readdir(path\[, options\])
+### fsPromises.readdir(path[, options])
 <!-- YAML
 added: v10.0.0
 changes:
diff --git a/lib/internal/fs/dir.js b/lib/internal/fs/dir.js
index 749e22ee69..c1a25f0de3 100644
--- a/lib/internal/fs/dir.js
+++ b/lib/internal/fs/dir.js
@@ -1,9 +1,6 @@
 'use strict';
 
-const {
-  ObjectDefineProperty,
-  Symbol,
-} = primordials;
+const { Object } = primordials;
 
 const pathModule = require('path');
 const binding = internalBinding('fs');
@@ -24,16 +21,11 @@ const {
   getValidatedPath,
   handleErrorFromBinding
 } = require('internal/fs/utils');
-const {
-  validateUint32
-} = require('internal/validators');
 
 const kDirHandle = Symbol('kDirHandle');
 const kDirPath = Symbol('kDirPath');
-const kDirBufferedEntries = Symbol('kDirBufferedEntries');
 const kDirClosed = Symbol('kDirClosed');
 const kDirOptions = Symbol('kDirOptions');
-const kDirReadImpl = Symbol('kDirReadImpl');
 const kDirReadPromisified = Symbol('kDirReadPromisified');
 const kDirClosePromisified = Symbol('kDirClosePromisified');
 
@@ -41,21 +33,14 @@ class Dir {
   constructor(handle, path, options) {
     if (handle == null) throw new ERR_MISSING_ARGS('handle');
     this[kDirHandle] = handle;
-    this[kDirBufferedEntries] = [];
     this[kDirPath] = path;
     this[kDirClosed] = false;
 
-    this[kDirOptions] = {
-      bufferSize: 32,
-      ...getOptions(options, {
-        encoding: 'utf8'
-      })
-    };
+    this[kDirOptions] = getOptions(options, {
+      encoding: 'utf8'
+    });
 
-    validateUint32(this[kDirOptions].bufferSize, 'options.bufferSize', true);
-
-    this[kDirReadPromisified] =
-        internalUtil.promisify(this[kDirReadImpl]).bind(this, false);
+    this[kDirReadPromisified] = internalUtil.promisify(this.read).bind(this);
     this[kDirClosePromisified] = internalUtil.promisify(this.close).bind(this);
   }
 
@@ -63,43 +48,29 @@ class Dir {
     return this[kDirPath];
   }
 
-  read(callback) {
-    return this[kDirReadImpl](true, callback);
-  }
-
-  [kDirReadImpl](maybeSync, callback) {
+  read(options, callback) {
     if (this[kDirClosed] === true) {
       throw new ERR_DIR_CLOSED();
     }
 
+    callback = typeof options === 'function' ? options : callback;
     if (callback === undefined) {
-      return this[kDirReadPromisified]();
+      return this[kDirReadPromisified](options);
     } else if (typeof callback !== 'function') {
       throw new ERR_INVALID_CALLBACK(callback);
     }
-
-    if (this[kDirBufferedEntries].length > 0) {
-      const [ name, type ] = this[kDirBufferedEntries].splice(0, 2);
-      if (maybeSync)
-        process.nextTick(getDirent, this[kDirPath], name, type, callback);
-      else
-        getDirent(this[kDirPath], name, type, callback);
-      return;
-    }
+    options = getOptions(options, this[kDirOptions]);
 
     const req = new FSReqCallback();
     req.oncomplete = (err, result) => {
       if (err || result === null) {
         return callback(err, result);
       }
-
-      this[kDirBufferedEntries] = result.slice(2);
       getDirent(this[kDirPath], result[0], result[1], callback);
     };
 
     this[kDirHandle].read(
-      this[kDirOptions].encoding,
-      this[kDirOptions].bufferSize,
+      options.encoding,
       req
     );
   }
@@ -109,15 +80,11 @@ class Dir {
       throw new ERR_DIR_CLOSED();
     }
 
-    if (this[kDirBufferedEntries].length > 0) {
-      const [ name, type ] = this[kDirBufferedEntries].splice(0, 2);
-      return getDirent(this[kDirPath], name, type);
-    }
+    options = getOptions(options, this[kDirOptions]);
 
     const ctx = { path: this[kDirPath] };
     const result = this[kDirHandle].read(
-      this[kDirOptions].encoding,
-      this[kDirOptions].bufferSize,
+      options.encoding,
       undefined,
       ctx
     );
@@ -127,7 +94,6 @@ class Dir {
       return result;
     }
 
-    this[kDirBufferedEntries] = result.slice(2);
     return getDirent(this[kDirPath], result[0], result[1]);
   }
 
@@ -175,7 +141,7 @@ class Dir {
   }
 }
 
-ObjectDefineProperty(Dir.prototype, Symbol.asyncIterator, {
+Object.defineProperty(Dir.prototype, Symbol.asyncIterator, {
   value: Dir.prototype.entries,
   enumerable: false,
   writable: true,
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index cc3f98268c..e0f522bdc1 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -512,33 +512,29 @@ async function readFile(path, options) {
 }
 
 module.exports = {
-  exports: {
-    access,
-    copyFile,
-    open,
-    opendir: promisify(opendir),
-    rename,
-    truncate,
-    rmdir,
-    mkdir,
-    readdir,
-    readlink,
-    symlink,
-    lstat,
-    stat,
-    link,
-    unlink,
-    chmod,
-    lchmod,
-    lchown,
-    chown,
-    utimes,
-    realpath,
-    mkdtemp,
-    writeFile,
-    appendFile,
-    readFile,
-  },
-
-  FileHandle
+  access,
+  copyFile,
+  open,
+  opendir: promisify(opendir),
+  rename,
+  truncate,
+  rmdir,
+  mkdir,
+  readdir,
+  readlink,
+  symlink,
+  lstat,
+  stat,
+  link,
+  unlink,
+  chmod,
+  lchmod,
+  lchown,
+  chown,
+  utimes,
+  realpath,
+  mkdtemp,
+  writeFile,
+  appendFile,
+  readFile
 };
diff --git a/src/node_dir.cc b/src/node_dir.cc
index ec53d8216b..c9df7e67e8 100644
--- a/src/node_dir.cc
+++ b/src/node_dir.cc
@@ -1,11 +1,10 @@
 #include "node_dir.h"
-#include "node_file-inl.h"
 #include "node_process.h"
-#include "memory_tracker-inl.h"
 #include "util.h"
 
 #include "tracing/trace_event.h"
 
+#include "req_wrap-inl.h"
 #include "string_bytes.h"
 
 #include <fcntl.h>
@@ -37,7 +36,6 @@ using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Null;
-using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::String;
@@ -61,8 +59,8 @@ DirHandle::DirHandle(Environment* env, Local<Object> obj, uv_dir_t* dir)
       dir_(dir) {
   MakeWeak();
 
-  dir_->nentries = 0;
-  dir_->dirents = nullptr;
+  dir_->nentries = 1;
+  dir_->dirents = &dirent_;
 }
 
 DirHandle* DirHandle::New(Environment* env, uv_dir_t* dir) {
@@ -86,10 +84,6 @@ DirHandle::~DirHandle() {
   CHECK(closed_);    // We have to be closed at the point
 }
 
-void DirHandle::MemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackFieldWithSize("dir", sizeof(*dir_));
-}
-
 // Close the directory handle if it hasn't already been closed. A process
 // warning will be emitted using a SetImmediate to avoid calling back to
 // JS during GC. If closing the fd fails at this point, a fatal exception
@@ -166,37 +160,7 @@ void DirHandle::Close(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
-static MaybeLocal<Array> DirentListToArray(
-    Environment* env,
-    uv_dirent_t* ents,
-    int num,
-    enum encoding encoding,
-    Local<Value>* err_out) {
-  MaybeStackBuffer<Local<Value>, 64> entries(num * 2);
-
-  // Return an array of all read filenames.
-  int j = 0;
-  for (int i = 0; i < num; i++) {
-    Local<Value> filename;
-    Local<Value> error;
-    const size_t namelen = strlen(ents[i].name);
-    if (!StringBytes::Encode(env->isolate(),
-                             ents[i].name,
-                             namelen,
-                             encoding,
-                             &error).ToLocal(&filename)) {
-      *err_out = error;
-      return MaybeLocal<Array>();
-    }
-
-    entries[j++] = filename;
-    entries[j++] = Integer::New(env->isolate(), ents[i].type);
-  }
-
-  return Array::New(env->isolate(), entries.out(), j);
-}
-
-static void AfterDirRead(uv_fs_t* req) {
+void AfterDirReadSingle(uv_fs_t* req) {
   FSReqBase* req_wrap = FSReqBase::from_req(req);
   FSReqAfterScope after(req_wrap, req);
 
@@ -206,6 +170,7 @@ static void AfterDirRead(uv_fs_t* req) {
 
   Environment* env = req_wrap->env();
   Isolate* isolate = env->isolate();
+  Local<Value> error;
 
   if (req->result == 0) {
     // Done
@@ -217,17 +182,26 @@ static void AfterDirRead(uv_fs_t* req) {
   uv_dir_t* dir = static_cast<uv_dir_t*>(req->ptr);
   req->ptr = nullptr;
 
-  Local<Value> error;
-  Local<Array> js_array;
-  if (!DirentListToArray(env,
-                         dir->dirents,
-                         req->result,
-                         req_wrap->encoding(),
-                         &error).ToLocal(&js_array)) {
+  // Single entries are returned without an array wrapper
+  const uv_dirent_t& ent = dir->dirents[0];
+
+  MaybeLocal<Value> filename =
+    StringBytes::Encode(isolate,
+                        ent.name,
+                        req_wrap->encoding(),
+                        &error);
+  if (filename.IsEmpty())
     return req_wrap->Reject(error);
-  }
 
-  req_wrap->Resolve(js_array);
+
+  Local<Array> result = Array::New(isolate, 2);
+  result->Set(env->context(),
+              0,
+              filename.ToLocalChecked()).FromJust();
+  result->Set(env->context(),
+              1,
+              Integer::New(isolate, ent.type)).FromJust();
+  req_wrap->Resolve(result);
 }
 
 
@@ -236,31 +210,22 @@ void DirHandle::Read(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = env->isolate();
 
   const int argc = args.Length();
-  CHECK_GE(argc, 3);
+  CHECK_GE(argc, 2);
 
   const enum encoding encoding = ParseEncoding(isolate, args[0], UTF8);
 
   DirHandle* dir;
   ASSIGN_OR_RETURN_UNWRAP(&dir, args.Holder());
 
-  CHECK(args[1]->IsNumber());
-  uint64_t buffer_size = args[1].As<Number>()->Value();
-
-  if (buffer_size != dir->dirents_.size()) {
-    dir->dirents_.resize(buffer_size);
-    dir->dir_->nentries = buffer_size;
-    dir->dir_->dirents = dir->dirents_.data();
-  }
-
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
-  if (req_wrap_async != nullptr) {  // dir.read(encoding, bufferSize, req)
+  FSReqBase* req_wrap_async = static_cast<FSReqBase*>(GetReqWrap(env, args[1]));
+  if (req_wrap_async != nullptr) {  // dir.read(encoding, req)
     AsyncCall(env, req_wrap_async, args, "readdir", encoding,
-              AfterDirRead, uv_fs_readdir, dir->dir());
-  } else {  // dir.read(encoding, bufferSize, undefined, ctx)
-    CHECK_EQ(argc, 4);
+              AfterDirReadSingle, uv_fs_readdir, dir->dir());
+  } else {  // dir.read(encoding, undefined, ctx)
+    CHECK_EQ(argc, 3);
     FSReqWrapSync req_wrap_sync;
     FS_DIR_SYNC_TRACE_BEGIN(readdir);
-    int err = SyncCall(env, args[3], &req_wrap_sync, "readdir", uv_fs_readdir,
+    int err = SyncCall(env, args[2], &req_wrap_sync, "readdir", uv_fs_readdir,
                        dir->dir());
     FS_DIR_SYNC_TRACE_END(readdir);
     if (err < 0) {
@@ -275,20 +240,28 @@ void DirHandle::Read(const FunctionCallbackInfo<Value>& args) {
     }
 
     CHECK_GE(req_wrap_sync.req.result, 0);
+    const uv_dirent_t& ent = dir->dir()->dirents[0];
 
     Local<Value> error;
-    Local<Array> js_array;
-    if (!DirentListToArray(env,
-                           dir->dir()->dirents,
-                           req_wrap_sync.req.result,
-                           encoding,
-                           &error).ToLocal(&js_array)) {
+    MaybeLocal<Value> filename =
+      StringBytes::Encode(isolate,
+                          ent.name,
+                          encoding,
+                          &error);
+    if (filename.IsEmpty()) {
       Local<Object> ctx = args[2].As<Object>();
-      USE(ctx->Set(env->context(), env->error_string(), error));
+      ctx->Set(env->context(), env->error_string(), error).FromJust();
       return;
     }
 
-    args.GetReturnValue().Set(js_array);
+    Local<Array> result = Array::New(isolate, 2);
+    result->Set(env->context(),
+                0,
+                filename.ToLocalChecked()).FromJust();
+    result->Set(env->context(),
+                1,
+                Integer::New(isolate, ent.type)).FromJust();
+    args.GetReturnValue().Set(result);
   }
 }
 
@@ -301,6 +274,7 @@ void AfterOpenDir(uv_fs_t* req) {
   }
 
   Environment* env = req_wrap->env();
+  Local<Value> error;
 
   uv_dir_t* dir = static_cast<uv_dir_t*>(req->ptr);
   DirHandle* handle = DirHandle::New(env, dir);
@@ -320,7 +294,7 @@ static void OpenDir(const FunctionCallbackInfo<Value>& args) {
 
   const enum encoding encoding = ParseEncoding(isolate, args[1], UTF8);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = static_cast<FSReqBase*>(GetReqWrap(env, args[2]));
   if (req_wrap_async != nullptr) {  // openDir(path, encoding, req)
     AsyncCall(env, req_wrap_async, args, "opendir", encoding, AfterOpenDir,
               uv_fs_opendir, *path);
diff --git a/src/node_dir.h b/src/node_dir.h
index b55245d5b8..e099fe5510 100644
--- a/src/node_dir.h
+++ b/src/node_dir.h
@@ -4,6 +4,8 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "node_file.h"
+#include "node.h"
+#include "req_wrap-inl.h"
 
 namespace node {
 
@@ -18,12 +20,17 @@ class DirHandle : public AsyncWrap {
   ~DirHandle() override;
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Open(const v8::FunctionCallbackInfo<Value>& args);
+  static void Read(const v8::FunctionCallbackInfo<Value>& args);
+  static void Close(const v8::FunctionCallbackInfo<Value>& args);
 
   inline uv_dir_t* dir() { return dir_; }
+  AsyncWrap* GetAsyncWrap() { return this; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackFieldWithSize("dir", sizeof(*dir_));
+  }
 
-  void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(DirHandle)
   SET_SELF_SIZE(DirHandle)
 
@@ -39,8 +46,7 @@ class DirHandle : public AsyncWrap {
   void GCClose();
 
   uv_dir_t* dir_;
-  // Multiple entries are read through a single libuv call.
-  std::vector<uv_dirent_t> dirents_;
+  uv_dirent_t dirent_;
   bool closing_ = false;
   bool closed_ = false;
 };
diff --git a/src/node_file.h b/src/node_file.h
index 1042baaf8f..14bf063708 100644
--- a/src/node_file.h
+++ b/src/node_file.h
@@ -6,6 +6,8 @@
 #include "node.h"
 #include "aliased_buffer.h"
 #include "stream_base.h"
+#include "memory_tracker-inl.h"
+#include "req_wrap-inl.h"
 #include <iostream>
 
 namespace node {
@@ -314,23 +316,53 @@ class FSReqWrapSync {
 // that nullptr indicates a synchronous call, rather than a failure.
 // Failure conditions should be disambiguated and handled appropriately.
 inline FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
-                             bool use_bigint = false);
+                             bool use_bigint = false) {
+  if (value->IsObject()) {
+    return Unwrap<FSReqBase>(value.As<Object>());
+  } else if (value->StrictEquals(env->fs_use_promises_symbol())) {
+    if (use_bigint) {
+      return FSReqPromise<AliasedBigUint64Array>::New(env, use_bigint);
+    } else {
+      return FSReqPromise<AliasedFloat64Array>::New(env, use_bigint);
+    }
+  }
+  return nullptr;
+}
 
 // Returns nullptr if the operation fails from the start.
 template <typename Func, typename... Args>
 inline FSReqBase* AsyncDestCall(Environment* env, FSReqBase* req_wrap,
-                                const v8::FunctionCallbackInfo<v8::Value>& args,
+                                const v8::FunctionCallbackInfo<Value>& args,
                                 const char* syscall, const char* dest,
                                 size_t len, enum encoding enc, uv_fs_cb after,
-                                Func fn, Args... fn_args);
+                                Func fn, Args... fn_args) {
+  CHECK_NOT_NULL(req_wrap);
+  req_wrap->Init(syscall, dest, len, enc);
+  int err = req_wrap->Dispatch(fn, fn_args..., after);
+  if (err < 0) {
+    uv_fs_t* uv_req = req_wrap->req();
+    uv_req->result = err;
+    uv_req->path = nullptr;
+    after(uv_req);  // after may delete req_wrap if there is an error
+    req_wrap = nullptr;
+  } else {
+    req_wrap->SetReturnValue(args);
+  }
+
+  return req_wrap;
+}
 
 // Returns nullptr if the operation fails from the start.
 template <typename Func, typename... Args>
 inline FSReqBase* AsyncCall(Environment* env,
                             FSReqBase* req_wrap,
-                            const v8::FunctionCallbackInfo<v8::Value>& args,
+                            const v8::FunctionCallbackInfo<Value>& args,
                             const char* syscall, enum encoding enc,
-                            uv_fs_cb after, Func fn, Args... fn_args);
+                            uv_fs_cb after, Func fn, Args... fn_args) {
+  return AsyncDestCall(env, req_wrap, args,
+                       syscall, nullptr, 0, enc,
+                       after, fn, fn_args...);
+}
 
 // Template counterpart of SYNC_CALL, except that it only puts
 // the error number and the syscall in the context instead of
@@ -339,7 +371,22 @@ inline FSReqBase* AsyncCall(Environment* env,
 template <typename Func, typename... Args>
 inline int SyncCall(Environment* env, v8::Local<v8::Value> ctx,
                     FSReqWrapSync* req_wrap, const char* syscall,
-                    Func fn, Args... args);
+                    Func fn, Args... args) {
+  env->PrintSyncTrace();
+  int err = fn(env->event_loop(), &(req_wrap->req), args..., nullptr);
+  if (err < 0) {
+    v8::Local<Context> context = env->context();
+    v8::Local<Object> ctx_obj = ctx.As<v8::Object>();
+    v8::Isolate* isolate = env->isolate();
+    ctx_obj->Set(context,
+                 env->errno_string(),
+                 v8::Integer::New(isolate, err)).Check();
+    ctx_obj->Set(context,
+                 env->syscall_string(),
+                 OneByteString(isolate, syscall)).Check();
+  }
+  return err;
+}
 
 }  // namespace fs
 
diff --git a/test/parallel/test-fs-opendir.js b/test/parallel/test-fs-opendir.js
index abfbb2bb70..c9a6d657ed 100644
--- a/test/parallel/test-fs-opendir.js
+++ b/test/parallel/test-fs-opendir.js
@@ -33,11 +33,6 @@ const dirclosedError = {
   code: 'ERR_DIR_CLOSED'
 };
 
-const invalidCallbackObj = {
-  code: 'ERR_INVALID_CALLBACK',
-  name: 'TypeError'
-};
-
 // Check the opendir Sync version
 {
   const dir = fs.opendirSync(testDir);
@@ -63,27 +58,17 @@ const invalidCallbackObj = {
 // Check the opendir async version
 fs.opendir(testDir, common.mustCall(function(err, dir) {
   assert.ifError(err);
-  let sync = true;
-  dir.read(common.mustCall((err, dirent) => {
-    assert(!sync);
+  dir.read(common.mustCall(function(err, dirent) {
     assert.ifError(err);
 
     // Order is operating / file system dependent
     assert(files.includes(dirent.name), `'files' should include ${dirent}`);
     assertDirent(dirent);
 
-    let syncInner = true;
-    dir.read(common.mustCall((err, dirent) => {
-      assert(!syncInner);
+    dir.close(common.mustCall(function(err) {
       assert.ifError(err);
-
-      dir.close(common.mustCall(function(err) {
-        assert.ifError(err);
-      }));
     }));
-    syncInner = false;
   }));
-  sync = false;
 }));
 
 // opendir() on file should throw ENOTDIR
@@ -91,10 +76,6 @@ assert.throws(function() {
   fs.opendirSync(__filename);
 }, /Error: ENOTDIR: not a directory/);
 
-assert.throws(function() {
-  fs.opendir(__filename);
-}, /TypeError \[ERR_INVALID_CALLBACK\]: Callback must be a function/);
-
 fs.opendir(__filename, common.mustCall(function(e) {
   assert.strictEqual(e.code, 'ENOTDIR');
 }));
@@ -191,42 +172,3 @@ async function doAsyncIterThrowTest() {
   await assert.rejects(async () => dir.read(), dirclosedError);
 }
 doAsyncIterThrowTest().then(common.mustCall());
-
-// Check error thrown on invalid values of bufferSize
-for (const bufferSize of [-1, 0, 0.5, 1.5, Infinity, NaN]) {
-  assert.throws(
-    () => fs.opendirSync(testDir, { bufferSize }),
-    {
-      code: 'ERR_OUT_OF_RANGE'
-    });
-}
-for (const bufferSize of ['', '1', null]) {
-  assert.throws(
-    () => fs.opendirSync(testDir, { bufferSize }),
-    {
-      code: 'ERR_INVALID_ARG_TYPE'
-    });
-}
-
-// Check that passing a positive integer as bufferSize works
-{
-  const dir = fs.opendirSync(testDir, { bufferSize: 1024 });
-  assertDirent(dir.readSync());
-  dir.close();
-}
-
-// Check that when passing a string instead of function - throw an exception
-async function doAsyncIterInvalidCallbackTest() {
-  const dir = await fs.promises.opendir(testDir);
-  assert.throws(() => dir.close('not function'), invalidCallbackObj);
-}
-doAsyncIterInvalidCallbackTest().then(common.mustCall());
-
-// Check if directory already closed - throw an exception
-async function doAsyncIterDirClosedTest() {
-  const dir = await fs.promises.opendir(testDir);
-  await dir.close();
-
-  assert.throws(() => dir.close(), dirclosedError);
-}
-doAsyncIterDirClosedTest().then(common.mustCall());