diff --git a/LICENSE b/LICENSE
index 18392b1d6a1a5f..4b1135ead791d5 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1584,3 +1584,28 @@ The externally maintained libraries used by Node.js are:
     OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   """
+
+- fs-extra, located at lib/internal/fs/copy, is licensed as follows:
+  """
+  (The MIT License)
+
+  Copyright (c) 2011-2021 JP Richardson
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the 'Software'), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+  """
diff --git a/doc/api/errors.md b/doc/api/errors.md
index d7df19cf7f0caa..48629508d76997 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1111,6 +1111,74 @@ added: v14.0.0
 Used when a feature that is not available
 to the current platform which is running Node.js is used.
 
+<a id="ERR_FS_COPY_DIR_TO_NON_DIR"></a>
+### `ERR_FS_COPY_DIR_TO_NON_DIR`
+<!--
+added: REPLACEME
+-->
+
+An attempt was made to copy a directory to a non-directory (file, symlink,
+etc.) using [`fs.copy()`][].
+
+<a id="ERR_FS_COPY_EEXIST"></a>
+### `ERR_FS_COPY_EEXIST`
+<!--
+added: REPLACEME
+-->
+
+An attempt was made to copy over a file that already existed with
+[`fs.copy()`][], with the `overwrite` and `errorOnExist` set to `true`.
+
+<a id="ERR_FS_COPY_FIFO_PIPE"></a>
+### `ERR_FS_COPY_FIFO_PIPE`
+<!--
+added: REPLACEME
+-->
+
+An attempt was made to copy a named pipe with [`fs.copy()`][].
+
+<a id="ERR_FS_COPY_NON_DIR_TO_DIR"></a>
+### `ERR_FS_COPY_NON_DIR_TO_DIR`
+<!--
+added: REPLACEME
+-->
+
+An attempt was made to copy a non-directory (file, symlink, etc.) to a directory
+using [`fs.copy()`][].
+
+<a id="ERR_FS_COPY_SOCKET"></a>
+### `ERR_FS_COPY_SOCKET`
+<!--
+added: REPLACEME
+-->
+
+An attempt was made to copy to a socket with [`fs.copy()`][].
+
+<a id="ERR_FS_COPY_SYMLINK_TO_SUBDIRECTORY"></a>
+### `ERR_FS_COPY_SYMLINK_TO_SUBDIRECTORY`
+<!--
+added: REPLACEME
+-->
+
+When using [`fs.copy()`][], a symlink in `dest` pointed to a subdirectory
+of `src`.
+
+<a id="ERR_FS_COPY_TO_SUBDIRECTORY"></a>
+### `ERR_FS_COPY_TO_SUBDIRECTORY`
+<!--
+added: REPLACEME
+-->
+
+When using [`fs.copy()`][], `dest` pointed to a subfolder in `src`.
+
+<a id="ERR_FS_COPY_UNKNOWN"></a>
+### `ERR_FS_COPY_UNKNOWN`
+<!--
+added: REPLACEME
+-->
+
+An attempt was made to copy to an unknown file type with [`fs.copy()`][].
+
 <a id="ERR_FS_EISDIR"></a>
 ### `ERR_FS_EISDIR`
 
@@ -2818,6 +2886,7 @@ The native call from `process.cpuUsage` could not be processed.
 [`dgram.remoteAddress()`]: dgram.md#dgram_socket_remoteaddress
 [`errno`(3) man page]: https://man7.org/linux/man-pages/man3/errno.3.html
 [`fs.Dir`]: fs.md#fs_class_fs_dir
+[`fs.copy()`]: fs.md#fs_fs_copy_src_dest_options_callback
 [`fs.readFileSync`]: fs.md#fs_fs_readfilesync_path_options
 [`fs.readdir`]: fs.md#fs_fs_readdir_path_options_callback
 [`fs.symlink()`]: fs.md#fs_fs_symlink_target_path_type_callback
diff --git a/doc/api/fs.md b/doc/api/fs.md
index ab5d7f08e1082f..debb54777ccda3 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1752,6 +1752,33 @@ through any other `fs` operation may lead to undefined behavior.
 
 See the POSIX close(2) documentation for more detail.
 
+### `fs.copy(src, dest[, options], callback)`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `src` {string|Buffer|URL} source path to copy.
+* `dest` {string|Buffer|URL} destination path to copy to.
+* `options` {Object|Function}
+  * `dereference` {boolean} dereference symlinks. **Default:** `false`.
+  * `errorOnExist` {boolean} when `overwrite` is `false`, and the destination
+    exists, throw an error. **Default:** `false`.
+  * `filter` {Function} Function to filter copied files/directories. Return
+    `true` to copy the item, `false` to ignore it. **Default:** `undefined`
+  * `overwrite` {boolean} overwrite existing file or directory. _The copy
+    operation will ignore errors if you set this to false and the destination
+    exists. Use the `errorOnExist` option to change this behavior.
+    **Default:** `true`.
+  * `preserveTimestamps` {boolean} When `true` timestamps from `src` will
+    be preserved. **Default:** `false`.
+* `callback` {Function}
+
+Asynchronously copies the entire directory structure from `src` to `dest`,
+including subdirectories and files.
+
+If a function is provided for `options`, it will be used as the `filter`
+parameter.
+
 ### `fs.copyFile(src, dest[, mode], callback)`
 <!-- YAML
 added: v8.5.0
diff --git a/lib/fs.js b/lib/fs.js
index cf3c885b31cdf8..ab1c37a81c5f73 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -107,6 +107,7 @@ const {
   stringToSymlinkType,
   toUnixTimestamp,
   validateBufferArray,
+  validateCopyOptions,
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
   validatePath,
@@ -145,6 +146,8 @@ let truncateWarn = true;
 let fs;
 
 // Lazy loaded
+let copyFn;
+let copySyncFn;
 let promises = null;
 let ReadStream;
 let WriteStream;
@@ -1075,6 +1078,12 @@ function ftruncateSync(fd, len = 0) {
   handleErrorFromBinding(ctx);
 }
 
+function lazyLoadCopy() {
+  if (copyFn === undefined) {
+    ({ copyFn } = require('internal/fs/copy/copy'));
+    ({ copySyncFn } = require('internal/fs/copy/copy-sync'));
+  }
+}
 
 function lazyLoadRimraf() {
   if (rimraf === undefined)
@@ -2741,6 +2750,55 @@ function mkdtempSync(prefix, options) {
   return result;
 }
 
+/**
+ * Asynchronously copies `src` to `dest`. `src` can be a file, directory, or
+ * symlink. The contents of directories will be copied recursively.
+ * @param {string | Buffer | URL} src
+ * @param {string | Buffer | URL} dest
+ * @param {Object} [options]
+ * @param {() => any} callback
+ * @returns {void}
+ */
+function copy(src, dest, options, callback) {
+  if (typeof options === 'function' && !callback) {
+    callback = options;
+    options = {};
+  } else if (typeof options === 'function') {
+    options = { filter: options };
+  }
+  callback = makeCallback(callback);
+  options = options || {};
+  validateCopyOptions(options);
+  src = getValidatedPath(src);
+  dest = getValidatedPath(dest);
+  src = pathModule._makeLong(src);
+  dest = pathModule._makeLong(dest);
+  lazyLoadCopy();
+  copyFn(src, dest, options, callback);
+}
+
+/**
+ * Synchronously copies `src` to `dest`. `src` can be a file, directory, or
+ * symlink. The contents of directories will be copied recursively.
+ * @param {string | Buffer | URL} src
+ * @param {string | Buffer | URL} dest
+ * @param {Object} [options]
+ * @returns {void}
+ */
+function copySync(src, dest, options) {
+  if (typeof options === 'function') {
+    options = { filter: options };
+  }
+  options = options || {};
+  validateCopyOptions(options);
+  src = getValidatedPath(src);
+  dest = getValidatedPath(dest);
+  src = pathModule._makeLong(src);
+  dest = pathModule._makeLong(dest);
+  lazyLoadCopy();
+  copySyncFn(src, dest, options);
+}
+
 /**
  * Asynchronously copies `src` to `dest`. By
  * default, `dest` is overwritten if it already exists.
@@ -2852,6 +2910,8 @@ module.exports = fs = {
   chmodSync,
   close,
   closeSync,
+  copy,
+  copySync,
   copyFile,
   copyFileSync,
   createReadStream,
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index ed3fa3787e5eec..9d35083ac76ac7 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -923,6 +923,18 @@ E('ERR_FEATURE_UNAVAILABLE_ON_PLATFORM',
   'The feature %s is unavailable on the current platform' +
   ', which is being used to run Node.js',
   TypeError);
+E('ERR_FS_COPY_DIR_TO_NON_DIR',
+  'Cannot overwrite directory with non-directory', SystemError);
+E('ERR_FS_COPY_EEXIST', 'Target already exists', SystemError);
+E('ERR_FS_COPY_FIFO_PIPE', 'Cannot copy a FIFO pipe', SystemError);
+E('ERR_FS_COPY_NON_DIR_TO_DIR',
+  'Cannot overwrite non-directory with directory', SystemError);
+E('ERR_FS_COPY_SOCKET', 'Cannot copy a socket file', SystemError);
+E('ERR_FS_COPY_SYMLINK_TO_SUBDIRECTORY',
+  'Cannot overwrite symlink in subdirectory of self', SystemError);
+E('ERR_FS_COPY_TO_SUBDIRECTORY',
+  'Cannot copy to a subdirectory of self', SystemError);
+E('ERR_FS_COPY_UNKNOWN', 'Cannot copy a unknown file type', SystemError);
 E('ERR_FS_EISDIR', 'Path is a directory', SystemError);
 E('ERR_FS_FILE_TOO_LARGE', 'File size (%s) is greater than 2 GB', RangeError);
 E('ERR_FS_INVALID_SYMLINK_TYPE',
diff --git a/lib/internal/fs/copy/copy-sync.js b/lib/internal/fs/copy/copy-sync.js
new file mode 100644
index 00000000000000..e9f2f378536e4a
--- /dev/null
+++ b/lib/internal/fs/copy/copy-sync.js
@@ -0,0 +1,342 @@
+'use strict';
+
+// This file is a modified version of the fs-extra's copySync method
+// modified in the following ways:
+//
+// - Use of the graceful-fs has been replaced with fs.
+// - Helpers from stat.js have been inlined.
+// - Formatting and style changes to match Node.js' linting rules.
+// - Parameter validation has been added.
+
+const { areIdentical, isSrcSubdir } = require('internal/fs/copy/copy');
+const console = require('console');
+const { codes } = require('internal/errors');
+const {
+  os: {
+    errno: {
+      EEXIST,
+      EISDIR,
+      EINVAL,
+      ENOTDIR,
+    }
+  }
+} = internalBinding('constants');
+const {
+  ERR_FS_COPY_DIR_TO_NON_DIR,
+  ERR_FS_COPY_EEXIST,
+  ERR_FS_COPY_FIFO_PIPE,
+  ERR_FS_COPY_NON_DIR_TO_DIR,
+  ERR_FS_COPY_SOCKET,
+  ERR_FS_COPY_SYMLINK_TO_SUBDIRECTORY,
+  ERR_FS_COPY_TO_SUBDIRECTORY,
+  ERR_FS_COPY_UNKNOWN,
+} = codes;
+const fs = require('fs');
+const {
+  chmodSync,
+  closeSync,
+  copyFileSync,
+  existsSync,
+  futimesSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readlinkSync,
+  statSync,
+  symlinkSync,
+  unlinkSync,
+} = fs;
+const path = require('path');
+const {
+  dirname,
+  join,
+  parse,
+  resolve,
+} = path;
+
+function copySyncFn(src, dest, opts) {
+  // Warn about using preserveTimestamps on 32-bit node
+  if (opts.preserveTimestamps && process.arch === 'ia32') {
+    console.warn('Using the preserveTimestamps option in 32-bit' +
+      'node is not recommended; see' +
+      'https://github.com/jprichardson/node-fs-extra/issues/269'
+    );
+  }
+  const { srcStat, destStat } = checkPathsSync(src, dest, opts);
+  checkParentPathsSync(src, srcStat, dest, 'copy');
+  return handleFilterAndCopy(destStat, src, dest, opts);
+}
+
+function checkPathsSync(src, dest, opts) {
+  const { srcStat, destStat } = getStatsSync(src, dest, opts);
+
+  if (destStat) {
+    if (areIdentical(srcStat, destStat)) {
+      throw new ERR_FS_COPY_TO_SUBDIRECTORY({
+        code: 'EINVAL',
+        message: 'src and dest cannot be the same directory',
+        path: dest,
+        syscall: 'copy',
+        errno: EINVAL,
+      });
+    }
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new ERR_FS_COPY_DIR_TO_NON_DIR({
+        code: 'EISDIR',
+        message: `cannot overwrite directory ${src} ` +
+          `with non-directory ${dest}`,
+        path: dest,
+        syscall: 'copy',
+        errno: EISDIR,
+      });
+    }
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new ERR_FS_COPY_NON_DIR_TO_DIR({
+        code: 'ENOTDIR',
+        message: `cannot overwrite non-directory ${src} ` +
+          `with directory ${dest}`,
+        path: dest,
+        syscall: 'copy',
+        errno: ENOTDIR,
+      });
+    }
+  }
+
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new ERR_FS_COPY_TO_SUBDIRECTORY({
+      code: 'EINVAL',
+      message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+      path: dest,
+      syscall: 'copy',
+      errno: EINVAL,
+    });
+  }
+  return { srcStat, destStat };
+}
+
+function getStatsSync(src, dest, opts) {
+  let destStat;
+  const statFunc = opts.dereference ?
+    (file) => statSync(file, { bigint: true }) :
+    (file) => lstatSync(file, { bigint: true });
+  const srcStat = statFunc(src);
+  try {
+    destStat = statFunc(dest);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { srcStat, destStat: null };
+    throw err;
+  }
+  return { srcStat, destStat };
+}
+
+function checkParentPathsSync(src, srcStat, dest) {
+  const srcParent = resolve(dirname(src));
+  const destParent = resolve(dirname(dest));
+  if (destParent === srcParent || destParent === parse(destParent).root) return;
+  let destStat;
+  try {
+    destStat = statSync(destParent, { bigint: true });
+  } catch (err) {
+    if (err.code === 'ENOENT') return;
+    throw err;
+  }
+  if (areIdentical(srcStat, destStat)) {
+    throw new ERR_FS_COPY_TO_SUBDIRECTORY({
+      code: 'EINVAL',
+      message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+      path: dest,
+      syscall: 'copy',
+      errno: EINVAL,
+    });
+  }
+  return checkParentPathsSync(src, srcStat, destParent);
+}
+
+function handleFilterAndCopy(destStat, src, dest, opts) {
+  if (opts.filter && !opts.filter(src, dest)) return;
+  const destParent = dirname(dest);
+  if (!existsSync(destParent)) mkdirSync(destParent, { recursive: true });
+  return getStats(destStat, src, dest, opts);
+}
+
+function startCopy(destStat, src, dest, opts) {
+  if (opts.filter && !opts.filter(src, dest)) return;
+  return getStats(destStat, src, dest, opts);
+}
+
+function getStats(destStat, src, dest, opts) {
+  const statSyncFn = opts.dereference ? statSync : lstatSync;
+  const srcStat = statSyncFn(src);
+
+  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+  else if (srcStat.isFile() ||
+           srcStat.isCharacterDevice() ||
+           srcStat.isBlockDevice()) {
+    return onFile(srcStat, destStat, src, dest, opts);
+  } else if (srcStat.isSymbolicLink()) {
+    return onLink(destStat, src, dest, opts);
+  } else if (srcStat.isSocket()) {
+    throw new ERR_FS_COPY_SOCKET({
+      code: 'EINVAL',
+      message: `cannot copy a socket file: ${dest}`,
+      path: dest,
+      syscall: 'copy',
+      errno: EINVAL,
+    });
+  } else if (srcStat.isFIFO()) {
+    throw new ERR_FS_COPY_FIFO_PIPE({
+      code: 'EINVAL',
+      message: `cannot copy a FIFO pipe: ${dest}`,
+      path: dest,
+      syscall: 'copy',
+      errno: EINVAL,
+    });
+  }
+  throw new ERR_FS_COPY_UNKNOWN({
+    code: 'EINVAL',
+    message: `cannot copy a unknown file type: ${dest}`,
+    path: dest,
+    syscall: 'copy',
+    errno: EINVAL,
+  });
+}
+
+function onFile(srcStat, destStat, src, dest, opts) {
+  if (!destStat) return copyFile(srcStat, src, dest, opts);
+  return mayCopyFile(srcStat, src, dest, opts);
+}
+
+function mayCopyFile(srcStat, src, dest, opts) {
+  if (opts.overwrite) {
+    unlinkSync(dest);
+    return copyFile(srcStat, src, dest, opts);
+  } else if (opts.errorOnExist) {
+    throw new ERR_FS_COPY_EEXIST({
+      code: 'EEXIST',
+      message: `${dest} already exists`,
+      path: dest,
+      syscall: 'copy',
+      errno: EEXIST,
+    });
+  }
+}
+
+function copyFile(srcStat, src, dest, opts) {
+  copyFileSync(src, dest);
+  if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+  return setDestMode(dest, srcStat.mode);
+}
+
+function handleTimestamps(srcMode, src, dest) {
+  // Make sure the file is writable before setting the timestamp
+  // otherwise open fails with EPERM when invoked with 'r+'
+  // (through utimes call)
+  if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+  return setDestTimestamps(src, dest);
+}
+
+function fileIsNotWritable(srcMode) {
+  return (srcMode & 0o200) === 0;
+}
+
+function makeFileWritable(dest, srcMode) {
+  return setDestMode(dest, srcMode | 0o200);
+}
+
+function setDestMode(dest, srcMode) {
+  return chmodSync(dest, srcMode);
+}
+
+function setDestTimestamps(src, dest) {
+  // The initial srcStat.atime cannot be trusted
+  // because it is modified by the read(2) system call
+  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+  const updatedSrcStat = statSync(src);
+  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+}
+
+function utimesMillisSync(path, atime, mtime) {
+  const fd = openSync(path, 'r+');
+  futimesSync(fd, atime, mtime);
+  return closeSync(fd);
+}
+
+function onDir(srcStat, destStat, src, dest, opts) {
+  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
+  return copyDir(src, dest, opts);
+}
+
+function mkDirAndCopy(srcMode, src, dest, opts) {
+  mkdirSync(dest);
+  copyDir(src, dest, opts);
+  return setDestMode(dest, srcMode);
+}
+
+function copyDir(src, dest, opts) {
+  readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+}
+
+function copyDirItem(item, src, dest, opts) {
+  const srcItem = join(src, item);
+  const destItem = join(dest, item);
+  const { destStat } = checkPathsSync(srcItem, destItem, opts);
+  return startCopy(destStat, srcItem, destItem, opts);
+}
+
+function onLink(destStat, src, dest, opts) {
+  let resolvedSrc = readlinkSync(src);
+  if (opts.dereference) {
+    resolvedSrc = resolve(process.cwd(), resolvedSrc);
+  }
+
+  if (!destStat) {
+    return symlinkSync(resolvedSrc, dest);
+  }
+  let resolvedDest;
+  try {
+    resolvedDest = readlinkSync(dest);
+  } catch (err) {
+    // Dest exists and is a regular file or directory,
+    // Windows may throw UNKNOWN error. If dest already exists,
+    // fs throws error anyway, so no need to guard against it here.
+    if (err.code === 'EINVAL' || err.code === 'UNKNOWN') {
+      return symlinkSync(resolvedSrc, dest);
+    }
+    throw err;
+  }
+  if (opts.dereference) {
+    resolvedDest = resolve(process.cwd(), resolvedDest);
+  }
+  if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+    throw new ERR_FS_COPY_TO_SUBDIRECTORY({
+      code: 'EINVAL',
+      message: `cannot copy ${resolvedSrc} to a subdirectory of self ` +
+          `${resolvedDest}`,
+      path: dest,
+      syscall: 'copy',
+      errno: EINVAL,
+    });
+  }
+
+  // Prevent copy if src is a subdir of dest since unlinking
+  // dest in this case would result in removing src contents
+  // and therefore a broken symlink would be created.
+  if (statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+    throw new ERR_FS_COPY_SYMLINK_TO_SUBDIRECTORY({
+      code: 'EINVAL',
+      message: `cannot overwrite ${resolvedDest} with ${resolvedSrc}`,
+      path: dest,
+      syscall: 'copy',
+      errno: EINVAL,
+    });
+  }
+  return copyLink(resolvedSrc, dest);
+}
+
+function copyLink(resolvedSrc, dest) {
+  unlinkSync(dest);
+  return symlinkSync(resolvedSrc, dest);
+}
+
+module.exports = { copySyncFn };
diff --git a/lib/internal/fs/copy/copy.js b/lib/internal/fs/copy/copy.js
new file mode 100644
index 00000000000000..8fa4af69dcca81
--- /dev/null
+++ b/lib/internal/fs/copy/copy.js
@@ -0,0 +1,468 @@
+'use strict';
+
+// This file is a modified version of the fs-extra's copy method
+// modified in the following ways:
+//
+// - Use of the graceful-fs has been replaced with fs.
+// - Helpers from stat.js have been inlined.
+// - Formatting and style changes to match Node.js' linting rules.
+// - Parameter validation has been added.
+
+const console = require('console');
+const { codes } = require('internal/errors');
+const {
+  ERR_FS_COPY_DIR_TO_NON_DIR,
+  ERR_FS_COPY_EEXIST,
+  ERR_FS_COPY_FIFO_PIPE,
+  ERR_FS_COPY_NON_DIR_TO_DIR,
+  ERR_FS_COPY_SOCKET,
+  ERR_FS_COPY_SYMLINK_TO_SUBDIRECTORY,
+  ERR_FS_COPY_TO_SUBDIRECTORY,
+  ERR_FS_COPY_UNKNOWN,
+} = codes;
+const {
+  os: {
+    errno: {
+      EEXIST,
+      EISDIR,
+      EINVAL,
+      ENOTDIR,
+    }
+  }
+} = internalBinding('constants');
+const fs = require('fs');
+const {
+  chmod,
+  close,
+  copyFile,
+  futimes,
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  readlink,
+  stat,
+  symlink,
+  unlink,
+} = fs;
+const path = require('path');
+const {
+  dirname,
+  join,
+  parse,
+  resolve,
+  sep,
+} = path;
+const { Promise, PromiseAll, PromiseResolve } = primordials;
+const util = require('util');
+const {
+  callbackify,
+  promisify,
+} = util;
+const statAsync = promisify(stat);
+const lstatAsync = promisify(lstat);
+
+function copyFn(src, dest, opts, cb) {
+  // Warn about using preserveTimestamps on 32-bit node
+  if (opts.preserveTimestamps && process.arch === 'ia32') {
+    console.warn('Using the preserveTimestamps option in 32-bit' +
+      'node is not recommended; see' +
+      'https://github.com/jprichardson/node-fs-extra/issues/269'
+    );
+  }
+
+  checkPaths(src, dest, opts, (err, stats) => {
+    if (err) return cb(err);
+    const { srcStat, destStat } = stats;
+    checkParentPaths(src, srcStat, dest, (err) => {
+      if (err) return cb(err);
+      if (opts.filter) {
+        return handleFilter(checkParentDir, destStat, src, dest, opts, cb);
+      }
+      return checkParentDir(destStat, src, dest, opts, cb);
+    });
+  });
+}
+
+function checkPaths(src, dest, opts, cb) {
+  getStats(src, dest, opts, (err, stats) => {
+    if (err) return cb(err);
+    const { srcStat, destStat } = stats;
+    if (destStat) {
+      if (areIdentical(srcStat, destStat)) {
+        return cb(new ERR_FS_COPY_TO_SUBDIRECTORY({
+          code: 'EINVAL',
+          message: 'src and dest cannot be the same directory',
+          path: dest,
+          syscall: 'copy',
+          errno: EINVAL,
+        }));
+      }
+      if (srcStat.isDirectory() && !destStat.isDirectory()) {
+        return cb(new ERR_FS_COPY_DIR_TO_NON_DIR({
+          code: 'EISDIR',
+          message: `cannot overwrite directory ${src} ` +
+            `with non-directory ${dest}`,
+          path: dest,
+          syscall: 'copy',
+          errno: EISDIR,
+        }));
+      }
+      if (!srcStat.isDirectory() && destStat.isDirectory()) {
+        return cb(new ERR_FS_COPY_NON_DIR_TO_DIR({
+          code: 'ENOTDIR',
+          message: `cannot overwrite non-directory ${src} ` +
+            `with directory ${dest}`,
+          path: dest,
+          syscall: 'copy',
+          errno: ENOTDIR,
+        }));
+      }
+    }
+
+    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+      return cb(new ERR_FS_COPY_TO_SUBDIRECTORY({
+        code: 'EINVAL',
+        message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+        path: dest,
+        syscall: 'copy',
+        errno: EINVAL,
+      }));
+    }
+    return cb(null, { srcStat, destStat });
+  });
+}
+
+function areIdentical(srcStat, destStat) {
+  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino &&
+    destStat.dev === srcStat.dev;
+}
+
+function getStatsAsync(src, dest, opts) {
+  const statFunc = opts.dereference ?
+    (file) => statAsync(file, { bigint: true }) :
+    (file) => lstatAsync(file, { bigint: true });
+  return PromiseAll([
+    statFunc(src),
+    statFunc(dest).catch((err) => {
+      if (err.code === 'ENOENT') return null;
+      throw err;
+    }),
+  ]).then(({ 0: srcStat, 1: destStat }) => ({ srcStat, destStat }));
+}
+const getStats = callbackify(getStatsAsync);
+
+function checkParentDir(destStat, src, dest, opts, cb) {
+  const destParent = dirname(dest);
+  pathExists(destParent, (err, dirExists) => {
+    if (err) return cb(err);
+    if (dirExists) return getStatsForCopy(destStat, src, dest, opts, cb);
+    mkdir(destParent, { recursive: true }, (err) => {
+      if (err) return cb(err);
+      return getStatsForCopy(destStat, src, dest, opts, cb);
+    });
+  });
+}
+
+function pathExists(dest, cb) {
+  stat(dest, (err, stat) => {
+    if (err) {
+      if (err.code === 'ENOENT') return cb(null, false);
+      return cb(err);
+    }
+    return cb(null, true);
+
+  });
+}
+
+// Recursively check if dest parent is a subdirectory of src.
+// It works for all file types including symlinks since it
+// checks the src and dest inodes. It starts from the deepest
+// parent and stops once it reaches the src parent or the root path.
+function checkParentPaths(src, srcStat, dest, cb) {
+  const srcParent = resolve(dirname(src));
+  const destParent = resolve(dirname(dest));
+  if (destParent === srcParent || destParent === parse(destParent).root) {
+    return cb(null);
+  }
+  stat(destParent, { bigint: true }, (err, destStat) => {
+    if (err) {
+      if (err.code === 'ENOENT') return cb(null);
+      return cb(err);
+    }
+    if (areIdentical(srcStat, destStat)) {
+      return cb(new ERR_FS_COPY_TO_SUBDIRECTORY({
+        code: 'EINVAL',
+        message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+        path: dest,
+        syscall: 'copy',
+        errno: EINVAL,
+      }));
+    }
+    return checkParentPaths(src, srcStat, destParent, cb);
+  });
+}
+
+// Return true if dest is a subdir of src, otherwise false.
+// It only checks the path strings.
+function isSrcSubdir(src, dest) {
+  const srcArr = resolve(src).split(sep).filter((i) => i);
+  const destArr = resolve(dest).split(sep).filter((i) => i);
+  return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
+}
+
+function handleFilter(onInclude, destStat, src, dest, opts, cb) {
+  PromiseResolve(opts.filter(src, dest)).then((include) => {
+    if (include) return onInclude(destStat, src, dest, opts, cb);
+    return cb(null);
+  }, (error) => cb(error));
+}
+
+function startCopy(destStat, src, dest, opts, cb) {
+  if (opts.filter) {
+    return handleFilter(getStatsForCopy, destStat, src, dest, opts, cb);
+  }
+  return getStatsForCopy(destStat, src, dest, opts, cb);
+}
+
+function getStatsForCopy(destStat, src, dest, opts, cb) {
+  const statFn = opts.dereference ? stat : lstat;
+  statFn(src, (err, srcStat) => {
+    if (err) return cb(err);
+
+    if (srcStat.isDirectory()) {
+      return onDir(srcStat, destStat, src, dest, opts, cb);
+    } else if (srcStat.isFile() ||
+             srcStat.isCharacterDevice() ||
+             srcStat.isBlockDevice()) {
+      return onFile(srcStat, destStat, src, dest, opts, cb);
+    } else if (srcStat.isSymbolicLink()) {
+      return onLink(destStat, src, dest, opts, cb);
+    } else if (srcStat.isSocket()) {
+      return cb(new ERR_FS_COPY_SOCKET({
+        code: 'EINVAL',
+        message: `cannot copy a socket file: ${dest}`,
+        path: dest,
+        syscall: 'copy',
+        errno: EINVAL,
+      }));
+    } else if (srcStat.isFIFO()) {
+      return cb(new ERR_FS_COPY_FIFO_PIPE({
+        code: 'EINVAL',
+        message: `cannot copy a FIFO pipe: ${dest}`,
+        path: dest,
+        syscall: 'copy',
+        errno: EINVAL,
+      }));
+    }
+    return cb(new ERR_FS_COPY_UNKNOWN({
+      code: 'EINVAL',
+      message: `cannot copy a unknown file type: ${dest}`,
+      path: dest,
+      syscall: 'copy',
+      errno: EINVAL,
+    }));
+  });
+}
+
+function onFile(srcStat, destStat, src, dest, opts, cb) {
+  if (!destStat) return _copyFile(srcStat, src, dest, opts, cb);
+  return mayCopyFile(srcStat, src, dest, opts, cb);
+}
+
+function mayCopyFile(srcStat, src, dest, opts, cb) {
+  if (opts.overwrite) {
+    unlink(dest, (err) => {
+      if (err) return cb(err);
+      return _copyFile(srcStat, src, dest, opts, cb);
+    });
+  } else if (opts.errorOnExist) {
+    return cb(new ERR_FS_COPY_EEXIST({
+      code: 'EEXIST',
+      message: `${dest} already exists`,
+      path: dest,
+      syscall: 'copy',
+      errno: EEXIST,
+    }));
+  } else return cb(null);
+}
+
+function _copyFile(srcStat, src, dest, opts, cb) {
+  copyFile(src, dest, (err) => {
+    if (err) return cb(err);
+    if (opts.preserveTimestamps) {
+      return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
+    }
+    return setDestMode(dest, srcStat.mode, cb);
+  });
+}
+
+function handleTimestampsAndMode(srcMode, src, dest, cb) {
+  // Make sure the file is writable before setting the timestamp
+  // otherwise open fails with EPERM when invoked with 'r+'
+  // (through utimes call)
+  if (fileIsNotWritable(srcMode)) {
+    return makeFileWritable(dest, srcMode, (err) => {
+      if (err) return cb(err);
+      return setDestTimestampsAndMode(srcMode, src, dest, cb);
+    });
+  }
+  return setDestTimestampsAndMode(srcMode, src, dest, cb);
+}
+
+function fileIsNotWritable(srcMode) {
+  return (srcMode & 0o200) === 0;
+}
+
+function makeFileWritable(dest, srcMode, cb) {
+  return setDestMode(dest, srcMode | 0o200, cb);
+}
+
+function setDestTimestampsAndMode(srcMode, src, dest, cb) {
+  setDestTimestamps(src, dest, (err) => {
+    if (err) return cb(err);
+    return setDestMode(dest, srcMode, cb);
+  });
+}
+
+function setDestMode(dest, srcMode, cb) {
+  return chmod(dest, srcMode, cb);
+}
+
+function setDestTimestamps(src, dest, cb) {
+  // The initial srcStat.atime cannot be trusted
+  // because it is modified by the read(2) system call
+  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+  stat(src, (err, updatedSrcStat) => {
+    if (err) return cb(err);
+    return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
+  });
+}
+
+function utimesMillis(path, atime, mtime, callback) {
+  open(path, 'r+', (err, fd) => {
+    if (err) return callback(err);
+    futimes(fd, atime, mtime, (futimesErr) => {
+      close(fd, (closeErr) => {
+        if (callback) callback(futimesErr || closeErr);
+      });
+    });
+  });
+}
+
+function onDir(srcStat, destStat, src, dest, opts, cb) {
+  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb);
+  return copyDir(src, dest, opts, cb);
+}
+
+function mkDirAndCopy(srcMode, src, dest, opts, cb) {
+  mkdir(dest, (err) => {
+    if (err) return cb(err);
+    copyDir(src, dest, opts, (err) => {
+      if (err) return cb(err);
+      return setDestMode(dest, srcMode, cb);
+    });
+  });
+}
+
+function copyDir(src, dest, opts, cb) {
+  readdir(src, (err, items) => {
+    if (err) return cb(err);
+    return copyDirItems(items, src, dest, opts, cb);
+  });
+}
+
+function copyDirItems(items, src, dest, opts, cb) {
+  const item = items.pop();
+  if (!item) return cb(null);
+  return copyDirItem(items, item, src, dest, opts, cb);
+}
+
+function copyDirItem(items, item, src, dest, opts, cb) {
+  const srcItem = join(src, item);
+  const destItem = join(dest, item);
+  checkPaths(srcItem, destItem, opts, (err, stats) => {
+    if (err) return cb(err);
+    const { destStat } = stats;
+    startCopy(destStat, srcItem, destItem, opts, (err) => {
+      if (err) return cb(err);
+      return copyDirItems(items, src, dest, opts, cb);
+    });
+  });
+}
+
+function onLink(destStat, src, dest, opts, cb) {
+  readlink(src, (err, resolvedSrc) => {
+    if (err) return cb(err);
+    // TODO(bcoe): I don't know how this could be called, because
+    // getStatsForCopy will have used stat. Ask during review.
+    if (opts.dereference) {
+      resolvedSrc = resolve(process.cwd(), resolvedSrc);
+    }
+
+    if (!destStat) {
+      return symlink(resolvedSrc, dest, cb);
+    }
+    readlink(dest, (err, resolvedDest) => {
+      if (err) {
+        // Dest exists and is a regular file or directory,
+        // Windows may throw UNKNOWN error. If dest already exists,
+        // fs throws error anyway, so no need to guard against it here.
+        if (err.code === 'EINVAL' || err.code === 'UNKNOWN') {
+          return symlink(resolvedSrc, dest, cb);
+        }
+        return cb(err);
+      }
+      if (opts.dereference) {
+        resolvedDest = resolve(process.cwd(), resolvedDest);
+      }
+      if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+        return cb(new ERR_FS_COPY_TO_SUBDIRECTORY({
+          code: 'EINVAL',
+          message: `cannot copy ${resolvedSrc} to a subdirectory of self ` +
+            `${resolvedDest}`,
+          path: dest,
+          syscall: 'copy',
+          errno: EINVAL,
+        }));
+      }
+
+      // Do not copy if src is a subdir of dest since unlinking
+      // dest in this case would result in removing src contents
+      // and therefore a broken symlink would be created.
+      // TODO(bcoe): I'm having trouble exercising this code in test,
+      // ask about during review.
+      if (destStat.isDirectory() &&
+          stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        return cb(new ERR_FS_COPY_SYMLINK_TO_SUBDIRECTORY({
+          code: 'EINVAL',
+          message: `cannot overwrite ${resolvedDest} with ${resolvedSrc}`,
+          path: dest,
+          syscall: 'copy',
+          errno: EINVAL,
+        }));
+      }
+      return copyLink(resolvedSrc, dest, cb);
+    });
+  });
+}
+
+function copyLink(resolvedSrc, dest, cb) {
+  unlink(dest, (err) => {
+    if (err) return cb(err);
+    return symlink(resolvedSrc, dest, cb);
+  });
+}
+
+function copyPromises(src, dest, options) {
+  return new Promise((resolve, reject) => {
+    copyFn(src, dest, options, (err) => {
+      if (err)
+        return reject(err);
+
+      resolve();
+    });
+  });
+}
+
+module.exports = { areIdentical, copyFn, copyPromises, isSrcSubdir };
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 3f802b8b33da0c..2bbad9bbe6079a 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -63,7 +63,8 @@ const {
   validateRmOptions,
   validateRmdirOptions,
   validateStringAfterArrayBufferView,
-  warnOnNonPortableTemplate
+  warnOnNonPortableTemplate,
+  validateCopyOptions
 } = require('internal/fs/utils');
 const { opendir } = require('internal/fs/dir');
 const {
@@ -99,6 +100,13 @@ const {
 const getDirectoryEntriesPromise = promisify(getDirents);
 const validateRmOptionsPromise = promisify(validateRmOptions);
 
+let copyPromises;
+function lazyLoadCopyPromises() {
+  if (copyPromises === undefined) {
+    ({ copyPromises } = require('internal/fs/copy/copy'));
+  }
+}
+
 class FileHandle extends EventEmitterMixin(JSTransferable) {
   /**
    * @param {InternalFSBinding.FileHandle | undefined} filehandle
@@ -396,6 +404,18 @@ async function access(path, mode = F_OK) {
                         kUsePromises);
 }
 
+async function copy(src, dest, options) {
+  if (typeof options === 'function') {
+    options = { filter: options };
+  }
+  options = options || {};
+  validateCopyOptions(options);
+  src = getValidatedPath(src, 'src');
+  dest = getValidatedPath(dest, 'dest');
+  lazyLoadCopyPromises();
+  return copyPromises(src, dest, options);
+}
+
 async function copyFile(src, dest, mode) {
   src = getValidatedPath(src, 'src');
   dest = getValidatedPath(dest, 'dest');
@@ -761,6 +781,7 @@ async function readFile(path, options) {
 module.exports = {
   exports: {
     access,
+    copy,
     copyFile,
     open,
     opendir: promisify(opendir),
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 322b1519ef2807..f65cedc8805ebb 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -47,6 +47,7 @@ const { toPathIfFileURL } = require('internal/url');
 const {
   validateAbortSignal,
   validateBoolean,
+  validateFunction,
   validateInt32,
   validateInteger,
   validateObject,
@@ -716,6 +717,14 @@ function warnOnNonPortableTemplate(template) {
   }
 }
 
+const defaultCopyOptions = {
+  dereference: false,
+  errorOnExist: false,
+  overwrite: true,
+  preserveTimestamps: false,
+  filter: undefined,
+};
+
 const defaultRmOptions = {
   recursive: false,
   force: false,
@@ -729,6 +738,17 @@ const defaultRmdirOptions = {
   recursive: false,
 };
 
+const validateCopyOptions = hideStackFrames((options) => {
+  options = { ...defaultCopyOptions, ...options };
+  validateBoolean(options.dereference, 'options.dereference');
+  validateBoolean(options.errorOnExist, 'options.errorOnExist');
+  validateBoolean(options.overwrite, 'options.overwrite');
+  validateBoolean(options.preserveTimestamps, 'options.preserveTimestamps');
+  if (options.filter) {
+    validateFunction(options.filter, 'options.filter');
+  }
+});
+
 const validateRmOptions = hideStackFrames((path, options, expectDir, cb) => {
   options = validateRmdirOptions(options, defaultRmOptions);
   validateBoolean(options.force, 'options.force');
@@ -902,6 +922,7 @@ module.exports = {
   Stats,
   toUnixTimestamp,
   validateBufferArray,
+  validateCopyOptions,
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
   validatePath,
diff --git a/test/fixtures/copy/kitchen-sink/README.md b/test/fixtures/copy/kitchen-sink/README.md
new file mode 100644
index 00000000000000..fec56017dc1b1a
--- /dev/null
+++ b/test/fixtures/copy/kitchen-sink/README.md
@@ -0,0 +1 @@
+# Hello
diff --git a/test/fixtures/copy/kitchen-sink/a/b/README2.md b/test/fixtures/copy/kitchen-sink/a/b/README2.md
new file mode 120000
index 00000000000000..fe840054137e2c
--- /dev/null
+++ b/test/fixtures/copy/kitchen-sink/a/b/README2.md
@@ -0,0 +1 @@
+../../README.md
\ No newline at end of file
diff --git a/test/fixtures/copy/kitchen-sink/a/b/index.js b/test/fixtures/copy/kitchen-sink/a/b/index.js
new file mode 100644
index 00000000000000..12388b0457bdda
--- /dev/null
+++ b/test/fixtures/copy/kitchen-sink/a/b/index.js
@@ -0,0 +1,3 @@
+module.exports = {
+  purpose: 'testing copy'
+};
diff --git a/test/fixtures/copy/kitchen-sink/a/c b/test/fixtures/copy/kitchen-sink/a/c
new file mode 120000
index 00000000000000..63d8dbd40c2354
--- /dev/null
+++ b/test/fixtures/copy/kitchen-sink/a/c
@@ -0,0 +1 @@
+b
\ No newline at end of file
diff --git a/test/fixtures/copy/kitchen-sink/a/index.js b/test/fixtures/copy/kitchen-sink/a/index.js
new file mode 100644
index 00000000000000..12388b0457bdda
--- /dev/null
+++ b/test/fixtures/copy/kitchen-sink/a/index.js
@@ -0,0 +1,3 @@
+module.exports = {
+  purpose: 'testing copy'
+};
diff --git a/test/fixtures/copy/kitchen-sink/index.js b/test/fixtures/copy/kitchen-sink/index.js
new file mode 100644
index 00000000000000..12388b0457bdda
--- /dev/null
+++ b/test/fixtures/copy/kitchen-sink/index.js
@@ -0,0 +1,3 @@
+module.exports = {
+  purpose: 'testing copy'
+};
diff --git a/test/parallel/test-copy.js b/test/parallel/test-copy.js
new file mode 100644
index 00000000000000..b710400079ee46
--- /dev/null
+++ b/test/parallel/test-copy.js
@@ -0,0 +1,197 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto) { common.skip('missing crypto'); }
+
+const assert = require('assert');
+const { randomUUID } = require('crypto');
+const fs = require('fs');
+const {
+  copy,
+  copySync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  symlinkSync,
+} = fs;
+const net = require('net');
+const { dirname, join } = require('path');
+
+const isWindows = process.platform === 'win32';
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+let dirc = 0;
+function nextdir() {
+  return join(tmpdir.path, `copy_${++dirc}`);
+}
+
+// Async version of copy.
+
+// It copies a nested folder structure with files, folders, symlinks.
+{
+  const src = dirname(require.resolve('../fixtures/copy/kitchen-sink'));
+  const dest = nextdir();
+  copy(src, dest, common.mustCall((err) => {
+    assert.strictEqual(err, null);
+    assertDirEquivalent(src, dest);
+  }));
+}
+
+// It throws error if existing symlink in dest is in subdirectory src.
+// TODO(bcoe): this behavior seemed strange to me, ask about it in review.
+{
+  const src = dirname(require.resolve('../fixtures/copy/kitchen-sink'));
+  const dest = nextdir();
+  copySync(src, dest);
+  copy(src, dest, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_FS_COPY_TO_SUBDIRECTORY');
+    assertDirEquivalent(src, dest);
+  }));
+}
+
+// It does not fail if the same directory is copied to dest twice,
+// when dereference is true, and overwrite true.
+{
+  const src = dirname(require.resolve('../fixtures/copy/kitchen-sink'));
+  const dest = nextdir();
+  const destFile = join(dest, 'a/b/README2.md');
+  copy(src, dest, { dereference: true }, common.mustCall((err) => {
+    assert.strictEqual(err, null);
+    const stat = lstatSync(destFile);
+    assert(stat.isFile());
+  }));
+}
+
+// It copies file itself, rather than symlink, when dereference is true.
+{
+  const src = require.resolve('../fixtures/copy/kitchen-sink');
+  const dest = nextdir();
+  const destFile = join(dest, 'foo.js');
+  copy(src, destFile, { dereference: true }, common.mustCall((err) => {
+    assert.strictEqual(err, null);
+    const stat = lstatSync(destFile);
+    assert(stat.isFile());
+  }));
+}
+
+// It returns error when src and dest are identical.
+{
+  const src = dirname(require.resolve('../fixtures/copy/kitchen-sink'));
+  copy(src, src, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_FS_COPY_TO_SUBDIRECTORY');
+  }));
+}
+
+// It returns error if part of dest path is symlink to src.
+{
+  const src = nextdir();
+  mkdirSync(join(src, 'a'), { recursive: true });
+  const dest = nextdir();
+  // Create symlink in dest pointing to src.
+  const destLink = join(dest, 'b');
+  mkdirSync(dest, { recursive: true });
+  symlinkSync(src, destLink);
+  copy(src, join(dest, 'b', 'c'), common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_FS_COPY_TO_SUBDIRECTORY');
+  }));
+}
+
+// It returns error if attempt is made to copy directory to file.
+{
+  const src = nextdir();
+  mkdirSync(src, { recursive: true });
+  const dest = require.resolve('../fixtures/copy/kitchen-sink');
+  copy(src, dest, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_FS_COPY_DIR_TO_NON_DIR');
+  }));
+}
+
+// It allows file to be copied to a file path.
+{
+  const srcFile = require.resolve('../fixtures/copy/kitchen-sink');
+  const destFile = join(nextdir(), 'index.js');
+  copy(srcFile, destFile, { dereference: true }, common.mustCall((err) => {
+    assert.strictEqual(err, null);
+    const stat = lstatSync(destFile);
+    assert(stat.isFile());
+  }));
+}
+
+// It returns error if attempt is made to copy file to directory.
+{
+  const src = require.resolve('../fixtures/copy/kitchen-sink');
+  const dest = nextdir();
+  mkdirSync(dest, { recursive: true });
+  copy(src, dest, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_FS_COPY_NON_DIR_TO_DIR');
+  }));
+}
+
+// It returns error if attempt is made to copy to subdirectory of self.
+{
+  const src = dirname(require.resolve('../fixtures/copy/kitchen-sink'));
+  const dest = dirname(
+    require.resolve('../fixtures/copy/kitchen-sink/a')
+  );
+  copy(src, dest, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_FS_COPY_TO_SUBDIRECTORY');
+  }));
+}
+
+// It returns an error if attempt is made to copy socket.
+{
+  const dest = nextdir();
+  const sid = randomUUID();
+  const sock = isWindows ? `\\\\.\\pipe\\${sid}` : `${sid}.sock`;
+  const server = net.createServer();
+  server.listen(sock);
+  copy(sock, dest, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_FS_COPY_SOCKET');
+    server.close();
+  }));
+}
+
+// It copies timestamps from src to dest if preserveTimestamps is true.
+{
+  const src = dirname(require.resolve('../fixtures/copy/kitchen-sink'));
+  const dest = nextdir();
+  copy(src, dest, { preserveTimestamps: true }, common.mustCall((err) => {
+    assert.strictEqual(err, null);
+    assertDirEquivalent(src, dest);
+    const srcStat = lstatSync(join(src, 'index.js'));
+    const destStat = lstatSync(join(dest, 'index.js'));
+    assert.strictEqual(srcStat.mtime.getTime(), destStat.mtime.getTime());
+  }));
+}
+
+function assertDirEquivalent(dir1, dir2) {
+  const dir1Entries = [];
+  collectEntries(dir1, dir1Entries);
+  const dir2Entries = [];
+  collectEntries(dir2, dir2Entries);
+  assert.strictEqual(dir1Entries.length, dir2Entries.length);
+  for (const entry1 of dir1Entries) {
+    const entry2 = dir2Entries.find((entry) => {
+      return entry.name === entry1.name;
+    });
+    assert(entry2, `entry ${entry2.name} not copied`);
+    if (entry1.isFile()) {
+      assert(entry2.isFile(), `${entry2.name} was not file`);
+    } else if (entry1.isDirectory()) {
+      assert(entry2.isDirectory(), `${entry2.name} was not directory`);
+    } else if (entry1.isSymbolicLink()) {
+      assert(entry2.isSymbolicLink(), `${entry2.name} was not symlink`);
+    }
+  }
+}
+
+function collectEntries(dir, dirEntries) {
+  const newEntries = [...readdirSync(dir, { withFileTypes: true })];
+  for (const entry of newEntries) {
+    if (entry.isDirectory()) {
+      collectEntries(join(dir, entry.name), dirEntries);
+    }
+  }
+  dirEntries.push.apply(dirEntries, newEntries);
+}