diff --git a/doc/api/console.md b/doc/api/console.md
index 42968d2eb9ab0d..cd229c0a0f81df 100644
--- a/doc/api/console.md
+++ b/doc/api/console.md
@@ -88,6 +88,9 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/19372
     description: The `Console` constructor now supports an `options` argument,
                  and the `colorMode` option was introduced.
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/24978
+    description: The `inspectOptions` option is introduced.
 -->
 
 * `options` {Object}
@@ -98,8 +101,11 @@ changes:
   * `colorMode` {boolean|string} Set color support for this `Console` instance.
     Setting to `true` enables coloring while inspecting values, setting to
     `'auto'` will make color support depend on the value of the `isTTY` property
-    and the value returned by `getColorDepth()` on the respective stream.
+    and the value returned by `getColorDepth()` on the respective stream. This
+    option can not be used, if `inspectOptions.colors` is set as well.
     **Default:** `'auto'`.
+  * `inspectOptions` {Object} Specifies options that are passed along to
+    [`util.inspect()`][].
 
 Creates a new `Console` with one or two writable stream instances. `stdout` is a
 writable stream to print log or info output. `stderr` is used for warning or
diff --git a/doc/api/errors.md b/doc/api/errors.md
index b867dc4f1207c1..68e6955925c117 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1141,6 +1141,12 @@ is set for the `Http2Stream`.
 `http2.connect()` was passed a URL that uses any protocol other than `http:` or
 `https:`.
 
+<a id="ERR_INCOMPATIBLE_OPTION_PAIR"></a>
+### ERR_INCOMPATIBLE_OPTION_PAIR
+
+An option pair is incompatible with each other and can not be used at the same
+time.
+
 <a id="ERR_INSPECTOR_ALREADY_CONNECTED"></a>
 ### ERR_INSPECTOR_ALREADY_CONNECTED
 
@@ -1804,20 +1810,6 @@ An attempt was made to load a module with an unknown or unsupported format.
 An invalid or unknown process signal was passed to an API expecting a valid
 signal (such as [`subprocess.kill()`][]).
 
-<a id="ERR_UNKNOWN_STDIN_TYPE"></a>
-### ERR_UNKNOWN_STDIN_TYPE
-
-An attempt was made to launch a Node.js process with an unknown `stdin` file
-type. This error is usually an indication of a bug within Node.js itself,
-although it is possible for user code to trigger it.
-
-<a id="ERR_UNKNOWN_STREAM_TYPE"></a>
-### ERR_UNKNOWN_STREAM_TYPE
-
-An attempt was made to launch a Node.js process with an unknown `stdout` or
-`stderr` file type. This error is usually an indication of a bug within Node.js
-itself, although it is possible for user code to trigger it.
-
 <a id="ERR_V8BREAKITERATOR"></a>
 ### ERR_V8BREAKITERATOR
 
@@ -2074,6 +2066,28 @@ kind of internal Node.js error that should not typically be triggered by user
 code. Instances of this error point to an internal bug within the Node.js
 binary itself.
 
+<a id="ERR_UNKNOWN_STDIN_TYPE"></a>
+### ERR_UNKNOWN_STDIN_TYPE
+<!-- YAML
+added: v8.0.0
+removed: REPLACEME
+-->
+
+An attempt was made to launch a Node.js process with an unknown `stdin` file
+type. This error is usually an indication of a bug within Node.js itself,
+although it is possible for user code to trigger it.
+
+<a id="ERR_UNKNOWN_STREAM_TYPE"></a>
+### ERR_UNKNOWN_STREAM_TYPE
+<!-- YAML
+added: v8.0.0
+removed: REPLACEME
+-->
+
+An attempt was made to launch a Node.js process with an unknown `stdout` or
+`stderr` file type. This error is usually an indication of a bug within Node.js
+itself, although it is possible for user code to trigger it.
+
 <a id="ERR_VALUE_OUT_OF_RANGE"></a>
 ### ERR_VALUE_OUT_OF_RANGE
 <!-- YAML
diff --git a/doc/api/util.md b/doc/api/util.md
index 7c5a0d2cd5921c..2dd0d0912bccea 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -375,6 +375,9 @@ stream.write('With ES6');
 <!-- YAML
 added: v0.3.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/25006
+    description: ArrayBuffers now also show their binary contents.
   - version: v11.5.0
     pr-url: https://github.com/nodejs/node/pull/24852
     description: The `getters` option is supported now.
diff --git a/lib/_http_agent.js b/lib/_http_agent.js
index e3d307133864f4..17f6856bc703ad 100644
--- a/lib/_http_agent.js
+++ b/lib/_http_agent.js
@@ -48,7 +48,7 @@ function Agent(options) {
   this.defaultPort = 80;
   this.protocol = 'http:';
 
-  this.options = util._extend({}, options);
+  this.options = { ...options };
 
   // Don't confuse net and make it think that we're connecting to a pipe
   this.options.path = null;
@@ -146,8 +146,7 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
     };
   }
 
-  options = util._extend({}, options);
-  util._extend(options, this.options);
+  options = { ...options, ...this.options };
   if (options.socketPath)
     options.path = options.socketPath;
 
@@ -194,8 +193,7 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
 };
 
 Agent.prototype.createSocket = function createSocket(req, options, cb) {
-  options = util._extend({}, options);
-  util._extend(options, this.options);
+  options = { ...options, ...this.options };
   if (options.socketPath)
     options.path = options.socketPath;
 
diff --git a/lib/_http_client.js b/lib/_http_client.js
index 5dd75090361c7e..cbc406f5e8b8d0 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -93,11 +93,11 @@ function ClientRequest(input, options, cb) {
 
   if (typeof options === 'function') {
     cb = options;
-    options = null;
+    options = input || {};
+  } else {
+    options = Object.assign(input || {}, options);
   }
 
-  options = util._extend(input || {}, options || {});
-
   var agent = options.agent;
   var defaultAgent = options._defaultAgent || Agent.globalAgent;
   if (agent === false) {
diff --git a/lib/_http_server.js b/lib/_http_server.js
index cfcaf9f34c2ca1..c0172ccf52d1d9 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -280,7 +280,7 @@ function Server(options, requestListener) {
     requestListener = options;
     options = {};
   } else if (options == null || typeof options === 'object') {
-    options = util._extend({}, options);
+    options = { ...options };
   }
 
   this[kIncomingMessage] = options.IncomingMessage || IncomingMessage;
diff --git a/lib/_tls_wrap.js b/lib/_tls_wrap.js
index bffefe452c0aea..ac5bdf9d5b9b4c 100644
--- a/lib/_tls_wrap.js
+++ b/lib/_tls_wrap.js
@@ -1108,9 +1108,9 @@ function SNICallback(servername, callback) {
 //
 //
 function normalizeConnectArgs(listArgs) {
-  var args = net._normalizeArgs(listArgs);
-  var options = args[0];
-  var cb = args[1];
+  const args = net._normalizeArgs(listArgs);
+  const options = args[0];
+  const cb = args[1];
 
   // If args[0] was options, then normalize dealt with it.
   // If args[0] is port, or args[0], args[1] is host, port, we need to
@@ -1118,12 +1118,12 @@ function normalizeConnectArgs(listArgs) {
   // the host/port/path args that it knows about, not the tls options.
   // This means that options.host overrides a host arg.
   if (listArgs[1] !== null && typeof listArgs[1] === 'object') {
-    util._extend(options, listArgs[1]);
+    Object.assign(options, listArgs[1]);
   } else if (listArgs[2] !== null && typeof listArgs[2] === 'object') {
-    util._extend(options, listArgs[2]);
+    Object.assign(options, listArgs[2]);
   }
 
-  return (cb) ? [options, cb] : [options];
+  return cb ? [options, cb] : [options];
 }
 
 function onConnectSecure() {
@@ -1204,14 +1204,14 @@ exports.connect = function connect(...args) {
                         'certificate verification.');
   }
 
-  var defaults = {
+  options = {
     rejectUnauthorized: !allowUnauthorized,
     ciphers: tls.DEFAULT_CIPHERS,
     checkServerIdentity: tls.checkServerIdentity,
-    minDHSize: 1024
+    minDHSize: 1024,
+    ...options
   };
 
-  options = util._extend(defaults, options || {});
   if (!options.keepAlive)
     options.singleUse = true;
 
diff --git a/lib/buffer.js b/lib/buffer.js
index 83deacd1fb0ce1..343c187b09c65c 100644
--- a/lib/buffer.js
+++ b/lib/buffer.js
@@ -37,7 +37,13 @@ const {
   kMaxLength,
   kStringMaxLength
 } = internalBinding('buffer');
-const { isAnyArrayBuffer } = internalBinding('types');
+const {
+  getOwnNonIndexProperties,
+  propertyFilter: {
+    ALL_PROPERTIES,
+    ONLY_ENUMERABLE
+  }
+} = internalBinding('util');
 const {
   customInspectSymbol,
   isInsideNodeModules,
@@ -45,12 +51,16 @@ const {
   kIsEncodingSymbol
 } = require('internal/util');
 const {
+  isAnyArrayBuffer,
   isArrayBufferView,
   isUint8Array
 } = require('internal/util/types');
+
 const {
-  pendingDeprecation
-} = internalBinding('config');
+  formatProperty,
+  kObjectType
+} = require('internal/util/inspect');
+
 const {
   ERR_BUFFER_OUT_OF_BOUNDS,
   ERR_OUT_OF_RANGE,
@@ -138,7 +148,7 @@ const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
 function showFlaggedDeprecation() {
   if (bufferWarningAlreadyEmitted ||
       ++nodeModulesCheckCounter > 10000 ||
-      (!pendingDeprecation &&
+      (!require('internal/options').getOptionValue('--pending-deprecation') &&
        isInsideNodeModules())) {
     // We don't emit a warning, because we either:
     // - Already did so, or
@@ -670,10 +680,20 @@ Buffer.prototype.equals = function equals(otherBuffer) {
 Buffer.prototype[customInspectSymbol] = function inspect(recurseTimes, ctx) {
   const max = exports.INSPECT_MAX_BYTES;
   const actualMax = Math.min(max, this.length);
-  let str = this.hexSlice(0, actualMax).replace(/(.{2})/g, '$1 ').trim();
   const remaining = this.length - max;
+  let str = this.hexSlice(0, actualMax).replace(/(.{2})/g, '$1 ').trim();
   if (remaining > 0)
     str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+  // Inspect special properties as well, if possible.
+  if (ctx) {
+    const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+    str += getOwnNonIndexProperties(this, filter).reduce((str, key) => {
+      // Using `formatProperty()` expects an indentationLvl to be set.
+      ctx.indentationLvl = 0;
+      str += `, ${formatProperty(ctx, this, recurseTimes, key, kObjectType)}`;
+      return str;
+    }, '');
+  }
   return `<${this.constructor.name} ${str}>`;
 };
 Buffer.prototype.inspect = Buffer.prototype[customInspectSymbol];
diff --git a/lib/child_process.js b/lib/child_process.js
index 108254f4a3c2b3..1a5411c8164c10 100644
--- a/lib/child_process.js
+++ b/lib/child_process.js
@@ -79,7 +79,7 @@ exports.fork = function fork(modulePath /* , args, options */) {
       throw new ERR_INVALID_ARG_VALUE(`arguments[${pos}]`, arguments[pos]);
     }
 
-    options = util._extend({}, arguments[pos++]);
+    options = { ...arguments[pos++] };
   }
 
   // Prepare arguments for fork:
@@ -176,20 +176,12 @@ Object.defineProperty(exports.exec, util.promisify.custom, {
 });
 
 exports.execFile = function execFile(file /* , args, options, callback */) {
-  var args = [];
-  var callback;
-  var options = {
-    encoding: 'utf8',
-    timeout: 0,
-    maxBuffer: 200 * 1024,
-    killSignal: 'SIGTERM',
-    cwd: null,
-    env: null,
-    shell: false
-  };
+  let args = [];
+  let callback;
+  let options;
 
   // Parse the optional positional parameters.
-  var pos = 1;
+  let pos = 1;
   if (pos < arguments.length && Array.isArray(arguments[pos])) {
     args = arguments[pos++];
   } else if (pos < arguments.length && arguments[pos] == null) {
@@ -197,7 +189,7 @@ exports.execFile = function execFile(file /* , args, options, callback */) {
   }
 
   if (pos < arguments.length && typeof arguments[pos] === 'object') {
-    util._extend(options, arguments[pos++]);
+    options = arguments[pos++];
   } else if (pos < arguments.length && arguments[pos] == null) {
     pos++;
   }
@@ -210,6 +202,17 @@ exports.execFile = function execFile(file /* , args, options, callback */) {
     throw new ERR_INVALID_ARG_VALUE('args', arguments[pos]);
   }
 
+  options = {
+    encoding: 'utf8',
+    timeout: 0,
+    maxBuffer: 200 * 1024,
+    killSignal: 'SIGTERM',
+    cwd: null,
+    env: null,
+    shell: false,
+    ...options
+  };
+
   // Validate the timeout, if present.
   validateTimeout(options.timeout);
 
@@ -580,7 +583,7 @@ function spawnSync(file, args, options) {
   options.stdio = _validateStdio(options.stdio || 'pipe', true).stdio;
 
   if (options.input) {
-    var stdin = options.stdio[0] = util._extend({}, options.stdio[0]);
+    var stdin = options.stdio[0] = { ...options.stdio[0] };
     stdin.input = options.input;
   }
 
@@ -588,7 +591,7 @@ function spawnSync(file, args, options) {
   for (var i = 0; i < options.stdio.length; i++) {
     var input = options.stdio[i] && options.stdio[i].input;
     if (input != null) {
-      var pipe = options.stdio[i] = util._extend({}, options.stdio[i]);
+      var pipe = options.stdio[i] = { ...options.stdio[i] };
       if (isArrayBufferView(input)) {
         pipe.input = input;
       } else if (typeof input === 'string') {
diff --git a/lib/console.js b/lib/console.js
index f0b9a74cfc7df8..85a89ecc990b8b 100644
--- a/lib/console.js
+++ b/lib/console.js
@@ -21,554 +21,4 @@
 
 'use strict';
 
-const { trace } = internalBinding('trace_events');
-const {
-  isStackOverflowError,
-  codes: {
-    ERR_CONSOLE_WRITABLE_STREAM,
-    ERR_INVALID_ARG_TYPE,
-    ERR_INVALID_ARG_VALUE,
-  },
-} = require('internal/errors');
-const { previewEntries } = internalBinding('util');
-const { Buffer: { isBuffer } } = require('buffer');
-const util = require('util');
-const {
-  isTypedArray, isSet, isMap, isSetIterator, isMapIterator,
-} = util.types;
-const kCounts = Symbol('counts');
-
-const kTraceConsoleCategory = 'node,node.console';
-const kTraceCount = 'C'.charCodeAt(0);
-const kTraceBegin = 'b'.charCodeAt(0);
-const kTraceEnd = 'e'.charCodeAt(0);
-const kTraceInstant = 'n'.charCodeAt(0);
-
-const {
-  keys: ObjectKeys,
-  values: ObjectValues,
-} = Object;
-const hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);
-
-const {
-  isArray: ArrayIsArray,
-  from: ArrayFrom,
-} = Array;
-
-// Lazy loaded for startup performance.
-let cliTable;
-
-// Track amount of indentation required via `console.group()`.
-const kGroupIndent = Symbol('kGroupIndent');
-const kFormatForStderr = Symbol('kFormatForStderr');
-const kFormatForStdout = Symbol('kFormatForStdout');
-const kGetInspectOptions = Symbol('kGetInspectOptions');
-const kColorMode = Symbol('kColorMode');
-const kIsConsole = Symbol('kIsConsole');
-const kWriteToConsole = Symbol('kWriteToConsole');
-const kBindProperties = Symbol('kBindProperties');
-const kBindStreamsEager = Symbol('kBindStreamsEager');
-const kBindStreamsLazy = Symbol('kBindStreamsLazy');
-const kUseStdout = Symbol('kUseStdout');
-const kUseStderr = Symbol('kUseStderr');
-
-// This constructor is not used to construct the global console.
-// It's exported for backwards compatibility.
-function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
-  // We have to test new.target here to see if this function is called
-  // with new, because we need to define a custom instanceof to accommodate
-  // the global console.
-  if (!new.target) {
-    return new Console(...arguments);
-  }
-
-  if (!options || typeof options.write === 'function') {
-    options = {
-      stdout: options,
-      stderr: arguments[1],
-      ignoreErrors: arguments[2]
-    };
-  }
-
-  const {
-    stdout,
-    stderr = stdout,
-    ignoreErrors = true,
-    colorMode = 'auto'
-  } = options;
-
-  if (!stdout || typeof stdout.write !== 'function') {
-    throw new ERR_CONSOLE_WRITABLE_STREAM('stdout');
-  }
-  if (!stderr || typeof stderr.write !== 'function') {
-    throw new ERR_CONSOLE_WRITABLE_STREAM('stderr');
-  }
-
-  if (typeof colorMode !== 'boolean' && colorMode !== 'auto')
-    throw new ERR_INVALID_ARG_VALUE('colorMode', colorMode);
-
-  // Bind the prototype functions to this Console instance
-  var keys = Object.keys(Console.prototype);
-  for (var v = 0; v < keys.length; v++) {
-    var k = keys[v];
-    // We have to bind the methods grabbed from the instance instead of from
-    // the prototype so that users extending the Console can override them
-    // from the prototype chain of the subclass.
-    this[k] = this[k].bind(this);
-  }
-
-  this[kBindStreamsEager](stdout, stderr);
-  this[kBindProperties](ignoreErrors, colorMode);
-}
-
-const consolePropAttributes = {
-  writable: true,
-  enumerable: false,
-  configurable: true
-};
-
-// Fixup global.console instanceof global.console.Console
-Object.defineProperty(Console, Symbol.hasInstance, {
-  value(instance) {
-    return instance[kIsConsole];
-  }
-});
-
-// Eager version for the Console constructor
-Console.prototype[kBindStreamsEager] = function(stdout, stderr) {
-  Object.defineProperties(this, {
-    '_stdout': { ...consolePropAttributes, value: stdout },
-    '_stderr': { ...consolePropAttributes, value: stderr }
-  });
-};
-
-// Lazily load the stdout and stderr from an object so we don't
-// create the stdio streams when they are not even accessed
-Console.prototype[kBindStreamsLazy] = function(object) {
-  let stdout;
-  let stderr;
-  Object.defineProperties(this, {
-    '_stdout': {
-      enumerable: false,
-      configurable: true,
-      get() {
-        if (!stdout) stdout = object.stdout;
-        return stdout;
-      },
-      set(value) { stdout = value; }
-    },
-    '_stderr': {
-      enumerable: false,
-      configurable: true,
-      get() {
-        if (!stderr) { stderr = object.stderr; }
-        return stderr;
-      },
-      set(value) { stderr = value; }
-    }
-  });
-};
-
-Console.prototype[kBindProperties] = function(ignoreErrors, colorMode) {
-  Object.defineProperties(this, {
-    '_stdoutErrorHandler': {
-      ...consolePropAttributes,
-      value: createWriteErrorHandler(this, kUseStdout)
-    },
-    '_stderrErrorHandler': {
-      ...consolePropAttributes,
-      value: createWriteErrorHandler(this, kUseStderr)
-    },
-    '_ignoreErrors': {
-      ...consolePropAttributes,
-      value: Boolean(ignoreErrors)
-    },
-    '_times': { ...consolePropAttributes, value: new Map() }
-  });
-
-  // TODO(joyeecheung): use consolePropAttributes for these
-  // Corresponds to https://console.spec.whatwg.org/#count-map
-  this[kCounts] = new Map();
-  this[kColorMode] = colorMode;
-  this[kIsConsole] = true;
-  this[kGroupIndent] = '';
-};
-
-// Make a function that can serve as the callback passed to `stream.write()`.
-function createWriteErrorHandler(instance, streamSymbol) {
-  return (err) => {
-    // This conditional evaluates to true if and only if there was an error
-    // that was not already emitted (which happens when the _write callback
-    // is invoked asynchronously).
-    const stream = streamSymbol === kUseStdout ?
-      instance._stdout : instance._stderr;
-    if (err !== null && !stream._writableState.errorEmitted) {
-      // If there was an error, it will be emitted on `stream` as
-      // an `error` event. Adding a `once` listener will keep that error
-      // from becoming an uncaught exception, but since the handler is
-      // removed after the event, non-console.* writes won't be affected.
-      // we are only adding noop if there is no one else listening for 'error'
-      if (stream.listenerCount('error') === 0) {
-        stream.on('error', noop);
-      }
-    }
-  };
-}
-
-Console.prototype[kWriteToConsole] = function(streamSymbol, string) {
-  const ignoreErrors = this._ignoreErrors;
-  const groupIndent = this[kGroupIndent];
-
-  const useStdout = streamSymbol === kUseStdout;
-  const stream = useStdout ? this._stdout : this._stderr;
-  const errorHandler = useStdout ?
-    this._stdoutErrorHandler : this._stderrErrorHandler;
-
-  if (groupIndent.length !== 0) {
-    if (string.indexOf('\n') !== -1) {
-      string = string.replace(/\n/g, `\n${groupIndent}`);
-    }
-    string = groupIndent + string;
-  }
-  string += '\n';
-
-  if (ignoreErrors === false) return stream.write(string);
-
-  // There may be an error occurring synchronously (e.g. for files or TTYs
-  // on POSIX systems) or asynchronously (e.g. pipes on POSIX systems), so
-  // handle both situations.
-  try {
-    // Add and later remove a noop error handler to catch synchronous errors.
-    stream.once('error', noop);
-
-    stream.write(string, errorHandler);
-  } catch (e) {
-    // Console is a debugging utility, so it swallowing errors is not desirable
-    // even in edge cases such as low stack space.
-    if (isStackOverflowError(e))
-      throw e;
-    // Sorry, there's no proper way to pass along the error here.
-  } finally {
-    stream.removeListener('error', noop);
-  }
-};
-
-const kColorInspectOptions = { colors: true };
-const kNoColorInspectOptions = {};
-Console.prototype[kGetInspectOptions] = function(stream) {
-  let color = this[kColorMode];
-  if (color === 'auto') {
-    color = stream.isTTY && (
-      typeof stream.getColorDepth === 'function' ?
-        stream.getColorDepth() > 2 : true);
-  }
-
-  return color ? kColorInspectOptions : kNoColorInspectOptions;
-};
-
-Console.prototype[kFormatForStdout] = function(args) {
-  const opts = this[kGetInspectOptions](this._stdout);
-  return util.formatWithOptions(opts, ...args);
-};
-
-Console.prototype[kFormatForStderr] = function(args) {
-  const opts = this[kGetInspectOptions](this._stderr);
-  return util.formatWithOptions(opts, ...args);
-};
-
-Console.prototype.log = function log(...args) {
-  this[kWriteToConsole](kUseStdout, this[kFormatForStdout](args));
-};
-
-Console.prototype.debug = Console.prototype.log;
-Console.prototype.info = Console.prototype.log;
-Console.prototype.dirxml = Console.prototype.log;
-
-Console.prototype.warn = function warn(...args) {
-  this[kWriteToConsole](kUseStderr, this[kFormatForStderr](args));
-};
-
-Console.prototype.error = Console.prototype.warn;
-
-Console.prototype.dir = function dir(object, options) {
-  options = {
-    customInspect: false,
-    ...this[kGetInspectOptions](this._stdout),
-    ...options
-  };
-  this[kWriteToConsole](kUseStdout, util.inspect(object, options));
-};
-
-Console.prototype.time = function time(label = 'default') {
-  // Coerces everything other than Symbol to a string
-  label = `${label}`;
-  if (this._times.has(label)) {
-    process.emitWarning(`Label '${label}' already exists for console.time()`);
-    return;
-  }
-  trace(kTraceBegin, kTraceConsoleCategory, `time::${label}`, 0);
-  this._times.set(label, process.hrtime());
-};
-
-Console.prototype.timeEnd = function timeEnd(label = 'default') {
-  // Coerces everything other than Symbol to a string
-  label = `${label}`;
-  const hasWarned = timeLogImpl(this, 'timeEnd', label);
-  trace(kTraceEnd, kTraceConsoleCategory, `time::${label}`, 0);
-  if (!hasWarned) {
-    this._times.delete(label);
-  }
-};
-
-Console.prototype.timeLog = function timeLog(label = 'default', ...data) {
-  // Coerces everything other than Symbol to a string
-  label = `${label}`;
-  timeLogImpl(this, 'timeLog', label, data);
-  trace(kTraceInstant, kTraceConsoleCategory, `time::${label}`, 0);
-};
-
-// Returns true if label was not found
-function timeLogImpl(self, name, label, data) {
-  const time = self._times.get(label);
-  if (!time) {
-    process.emitWarning(`No such label '${label}' for console.${name}()`);
-    return true;
-  }
-  const duration = process.hrtime(time);
-  const ms = duration[0] * 1000 + duration[1] / 1e6;
-  if (data === undefined) {
-    self.log('%s: %sms', label, ms.toFixed(3));
-  } else {
-    self.log('%s: %sms', label, ms.toFixed(3), ...data);
-  }
-  return false;
-}
-
-Console.prototype.trace = function trace(...args) {
-  const err = {
-    name: 'Trace',
-    message: this[kFormatForStderr](args)
-  };
-  Error.captureStackTrace(err, trace);
-  this.error(err.stack);
-};
-
-Console.prototype.assert = function assert(expression, ...args) {
-  if (!expression) {
-    args[0] = `Assertion failed${args.length === 0 ? '' : `: ${args[0]}`}`;
-    this.warn(...args);  // the arguments will be formatted in warn() again
-  }
-};
-
-// Defined by: https://console.spec.whatwg.org/#clear
-Console.prototype.clear = function clear() {
-  // It only makes sense to clear if _stdout is a TTY.
-  // Otherwise, do nothing.
-  if (this._stdout.isTTY) {
-    // The require is here intentionally to avoid readline being
-    // required too early when console is first loaded.
-    const { cursorTo, clearScreenDown } = require('readline');
-    cursorTo(this._stdout, 0, 0);
-    clearScreenDown(this._stdout);
-  }
-};
-
-// Defined by: https://console.spec.whatwg.org/#count
-Console.prototype.count = function count(label = 'default') {
-  // Ensures that label is a string, and only things that can be
-  // coerced to strings. e.g. Symbol is not allowed
-  label = `${label}`;
-  const counts = this[kCounts];
-  let count = counts.get(label);
-  if (count === undefined)
-    count = 1;
-  else
-    count++;
-  counts.set(label, count);
-  trace(kTraceCount, kTraceConsoleCategory, `count::${label}`, 0, count);
-  this.log(`${label}: ${count}`);
-};
-
-// Defined by: https://console.spec.whatwg.org/#countreset
-Console.prototype.countReset = function countReset(label = 'default') {
-  const counts = this[kCounts];
-  if (!counts.has(label)) {
-    process.emitWarning(`Count for '${label}' does not exist`);
-    return;
-  }
-  trace(kTraceCount, kTraceConsoleCategory, `count::${label}`, 0, 0);
-  counts.delete(`${label}`);
-};
-
-Console.prototype.group = function group(...data) {
-  if (data.length > 0) {
-    this.log(...data);
-  }
-  this[kGroupIndent] += '  ';
-};
-Console.prototype.groupCollapsed = Console.prototype.group;
-
-Console.prototype.groupEnd = function groupEnd() {
-  this[kGroupIndent] =
-    this[kGroupIndent].slice(0, this[kGroupIndent].length - 2);
-};
-
-const keyKey = 'Key';
-const valuesKey = 'Values';
-const indexKey = '(index)';
-const iterKey = '(iteration index)';
-
-const isArray = (v) => ArrayIsArray(v) || isTypedArray(v) || isBuffer(v);
-
-// https://console.spec.whatwg.org/#table
-Console.prototype.table = function(tabularData, properties) {
-  if (properties !== undefined && !ArrayIsArray(properties))
-    throw new ERR_INVALID_ARG_TYPE('properties', 'Array', properties);
-
-  if (tabularData === null || typeof tabularData !== 'object')
-    return this.log(tabularData);
-
-  if (cliTable === undefined) cliTable = require('internal/cli_table');
-  const final = (k, v) => this.log(cliTable(k, v));
-
-  const inspect = (v) => {
-    const opt = { depth: 0, maxArrayLength: 3 };
-    if (v !== null && typeof v === 'object' &&
-      !isArray(v) && ObjectKeys(v).length > 2)
-      opt.depth = -1;
-    Object.assign(opt, this[kGetInspectOptions](this._stdout));
-    return util.inspect(v, opt);
-  };
-  const getIndexArray = (length) => ArrayFrom({ length }, (_, i) => inspect(i));
-
-  const mapIter = isMapIterator(tabularData);
-  let isKeyValue = false;
-  let i = 0;
-  if (mapIter) {
-    const res = previewEntries(tabularData, true);
-    tabularData = res[0];
-    isKeyValue = res[1];
-  }
-
-  if (isKeyValue || isMap(tabularData)) {
-    const keys = [];
-    const values = [];
-    let length = 0;
-    if (mapIter) {
-      for (; i < tabularData.length / 2; ++i) {
-        keys.push(inspect(tabularData[i * 2]));
-        values.push(inspect(tabularData[i * 2 + 1]));
-        length++;
-      }
-    } else {
-      for (const [k, v] of tabularData) {
-        keys.push(inspect(k));
-        values.push(inspect(v));
-        length++;
-      }
-    }
-    return final([
-      iterKey, keyKey, valuesKey
-    ], [
-      getIndexArray(length),
-      keys,
-      values,
-    ]);
-  }
-
-  const setIter = isSetIterator(tabularData);
-  if (setIter)
-    tabularData = previewEntries(tabularData);
-
-  const setlike = setIter || (mapIter && !isKeyValue) || isSet(tabularData);
-  if (setlike) {
-    const values = [];
-    let length = 0;
-    for (const v of tabularData) {
-      values.push(inspect(v));
-      length++;
-    }
-    return final([setlike ? iterKey : indexKey, valuesKey], [
-      getIndexArray(length),
-      values,
-    ]);
-  }
-
-  const map = {};
-  let hasPrimitives = false;
-  const valuesKeyArray = [];
-  const indexKeyArray = ObjectKeys(tabularData);
-
-  for (; i < indexKeyArray.length; i++) {
-    const item = tabularData[indexKeyArray[i]];
-    const primitive = item === null ||
-        (typeof item !== 'function' && typeof item !== 'object');
-    if (properties === undefined && primitive) {
-      hasPrimitives = true;
-      valuesKeyArray[i] = inspect(item);
-    } else {
-      const keys = properties || ObjectKeys(item);
-      for (const key of keys) {
-        if (map[key] === undefined)
-          map[key] = [];
-        if ((primitive && properties) || !hasOwnProperty(item, key))
-          map[key][i] = '';
-        else
-          map[key][i] = item == null ? item : inspect(item[key]);
-      }
-    }
-  }
-
-  const keys = ObjectKeys(map);
-  const values = ObjectValues(map);
-  if (hasPrimitives) {
-    keys.push(valuesKey);
-    values.push(valuesKeyArray);
-  }
-  keys.unshift(indexKey);
-  values.unshift(indexKeyArray);
-
-  return final(keys, values);
-};
-
-function noop() {}
-
-// See https://console.spec.whatwg.org/#console-namespace
-// > For historical web-compatibility reasons, the namespace object
-// > for console must have as its [[Prototype]] an empty object,
-// > created as if by ObjectCreate(%ObjectPrototype%),
-// > instead of %ObjectPrototype%.
-
-// Since in Node.js, the Console constructor has been exposed through
-// require('console'), we need to keep the Console constructor but
-// we cannot actually use `new Console` to construct the global console.
-// Therefore, the console.Console.prototype is not
-// in the global console prototype chain anymore.
-
-// TODO(joyeecheung):
-// - Move the Console constructor into internal/console.js
-// - Move the global console creation code along with the inspector console
-//   wrapping code in internal/bootstrap/node.js into a separate file.
-// - Make this file a simple re-export of those two files.
-// This is only here for v11.x conflict resolution.
-const globalConsole = Object.create(Console.prototype);
-
-// Since Console is not on the prototype chain of the global console,
-// the symbol properties on Console.prototype have to be looked up from
-// the global console itself. In addition, we need to make the global
-// console a namespace by binding the console methods directly onto
-// the global console with the receiver fixed.
-for (const prop of Reflect.ownKeys(Console.prototype)) {
-  if (prop === 'constructor') { continue; }
-  const desc = Reflect.getOwnPropertyDescriptor(Console.prototype, prop);
-  if (typeof desc.value === 'function') { // fix the receiver
-    desc.value = desc.value.bind(globalConsole);
-  }
-  Reflect.defineProperty(globalConsole, prop, desc);
-}
-
-globalConsole[kBindStreamsLazy](process);
-globalConsole[kBindProperties](true, 'auto');
-
-module.exports = globalConsole;
-module.exports.Console = Console;
+module.exports = require('internal/console/global');
diff --git a/lib/domain.js b/lib/domain.js
index bd59a709298345..a60147b49eacbd 100644
--- a/lib/domain.js
+++ b/lib/domain.js
@@ -350,11 +350,9 @@ Domain.prototype.run = function(fn) {
 function intercepted(_this, self, cb, fnargs) {
   if (fnargs[0] && fnargs[0] instanceof Error) {
     var er = fnargs[0];
-    util._extend(er, {
-      domainBound: cb,
-      domainThrown: false,
-      domain: self
-    });
+    er.domainBound = cb;
+    er.domainThrown = false;
+    er.domain = self;
     self.emit('error', er);
     return;
   }
diff --git a/lib/fs.js b/lib/fs.js
index 57b3bed1e6e883..fcedb4eb07844f 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -39,10 +39,9 @@ const {
   O_SYMLINK
 } = constants;
 
-const { _extend } = require('util');
 const pathModule = require('path');
 const { isArrayBufferView } = require('internal/util/types');
-const binding = process.binding('fs');
+const binding = internalBinding('fs');
 const { Buffer, kMaxLength } = require('buffer');
 const errors = require('internal/errors');
 const {
@@ -1294,21 +1293,20 @@ function watchFile(filename, options, listener) {
   filename = pathModule.resolve(filename);
   let stat;
 
-  const defaults = {
+  if (options === null || typeof options !== 'object') {
+    listener = options;
+    options = null;
+  }
+
+  options = {
     // Poll interval in milliseconds. 5007 is what libev used to use. It's
     // a little on the slow side but let's stick with it for now to keep
     // behavioral changes to a minimum.
     interval: 5007,
-    persistent: true
+    persistent: true,
+    ...options
   };
 
-  if (options !== null && typeof options === 'object') {
-    options = _extend(defaults, options);
-  } else {
-    listener = options;
-    options = defaults;
-  }
-
   if (typeof listener !== 'function') {
     throw new ERR_INVALID_ARG_TYPE('listener', 'Function', listener);
   }
diff --git a/lib/https.js b/lib/https.js
index 06b37c2143da9d..96111176994a25 100644
--- a/lib/https.js
+++ b/lib/https.js
@@ -46,7 +46,7 @@ function Server(opts, requestListener) {
     requestListener = opts;
     opts = undefined;
   }
-  opts = util._extend({}, opts);
+  opts = { ...opts };
 
   if (!opts.ALPNProtocols) {
     // http/1.0 is not defined as Protocol IDs in IANA
@@ -110,9 +110,10 @@ function createConnection(port, host, options) {
     const session = this._getSession(options._agentKey);
     if (session) {
       debug('reuse session for %j', options._agentKey);
-      options = util._extend({
-        session: session
-      }, options);
+      options = {
+        session,
+        ...options
+      };
     }
   }
 
@@ -291,7 +292,7 @@ function request(...args) {
   }
 
   if (args[0] && typeof args[0] !== 'function') {
-    options = util._extend(options, args.shift());
+    Object.assign(options, args.shift());
   }
 
   options._defaultAgent = module.exports.globalAgent;
diff --git a/lib/inspector.js b/lib/inspector.js
index 6988eccf82c9ef..aac864901c92bc 100644
--- a/lib/inspector.js
+++ b/lib/inspector.js
@@ -11,8 +11,7 @@ const {
 } = require('internal/errors').codes;
 const { validateString } = require('internal/validators');
 const util = require('util');
-const { Connection, open, url } = process.binding('inspector');
-const { originalConsole } = require('internal/process/per_thread');
+const { Connection, open, url } = internalBinding('inspector');
 
 if (!Connection)
   throw new ERR_INSPECTOR_NOT_AVAILABLE();
@@ -103,6 +102,8 @@ module.exports = {
   open: (port, host, wait) => open(port, host, !!wait),
   close: process._debugEnd,
   url: url,
-  console: originalConsole,
+  // This is dynamically added during bootstrap,
+  // where the console from the VM is still available
+  console: require('internal/console/inspector').consoleFromVM,
   Session
 };
diff --git a/lib/internal/bootstrap/loaders.js b/lib/internal/bootstrap/loaders.js
index 5c0a5b6aa1fb80..cc3822995411f7 100644
--- a/lib/internal/bootstrap/loaders.js
+++ b/lib/internal/bootstrap/loaders.js
@@ -39,327 +39,331 @@
 
 'use strict';
 
-(function bootstrapInternalLoaders(process, getBinding, getLinkedBinding,
-                                   getInternalBinding, debugBreak) {
-  if (debugBreak)
-    debugger; // eslint-disable-line no-debugger
-
-  const {
-    apply: ReflectApply,
-    deleteProperty: ReflectDeleteProperty,
-    get: ReflectGet,
-    getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
-    has: ReflectHas,
-    set: ReflectSet,
-  } = Reflect;
-  const {
-    prototype: {
-      hasOwnProperty: ObjectHasOwnProperty,
-    },
-    create: ObjectCreate,
-    defineProperty: ObjectDefineProperty,
-    keys: ObjectKeys,
-  } = Object;
-
-  // Set up process.moduleLoadList.
-  const moduleLoadList = [];
-  ObjectDefineProperty(process, 'moduleLoadList', {
-    value: moduleLoadList,
-    configurable: true,
-    enumerable: true,
-    writable: false
-  });
-
-  // internalBindingWhitelist contains the name of internalBinding modules
-  // that are whitelisted for access via process.binding()... This is used
-  // to provide a transition path for modules that are being moved over to
-  // internalBinding.
-  const internalBindingWhitelist = [
-    'async_wrap',
-    'buffer',
-    'cares_wrap',
-    'constants',
-    'config',
-    'contextify',
-    'crypto',
-    'fs_event_wrap',
-    'http_parser',
-    'icu',
-    'js_stream',
-    'natives',
-    'os',
-    'pipe_wrap',
-    'process_wrap',
-    'signal_wrap',
-    'spawn_sync',
-    'stream_wrap',
-    'tcp_wrap',
-    'tls_wrap',
-    'tty_wrap',
-    'udp_wrap',
-    'url',
-    'util',
-    'uv',
-    'v8',
-    'zlib'
-  ];
-  // We will use a lazy loaded SafeSet in internalBindingWhitelistHas
-  // for checking existence in this list.
-  let internalBindingWhitelistSet;
-
-  // Set up process.binding() and process._linkedBinding().
-  {
-    const bindingObj = ObjectCreate(null);
-
-    process.binding = function binding(module) {
-      module = String(module);
-      // Deprecated specific process.binding() modules, but not all, allow
-      // selective fallback to internalBinding for the deprecated ones.
-      if (internalBindingWhitelistHas(module)) {
-        return internalBinding(module);
-      }
-      let mod = bindingObj[module];
-      if (typeof mod !== 'object') {
-        mod = bindingObj[module] = getBinding(module);
-        moduleLoadList.push(`Binding ${module}`);
-      }
-      return mod;
-    };
-
-    process._linkedBinding = function _linkedBinding(module) {
-      module = String(module);
-      let mod = bindingObj[module];
-      if (typeof mod !== 'object')
-        mod = bindingObj[module] = getLinkedBinding(module);
-      return mod;
-    };
-  }
+// This file is compiled as if it's wrapped in a function with arguments
+// passed by node::LoadEnvironment()
+/* global process, getBinding, getLinkedBinding, getInternalBinding */
+/* global debugBreak */
+
+if (debugBreak)
+  debugger; // eslint-disable-line no-debugger
+
+const {
+  apply: ReflectApply,
+  deleteProperty: ReflectDeleteProperty,
+  get: ReflectGet,
+  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
+  has: ReflectHas,
+  set: ReflectSet,
+} = Reflect;
+const {
+  prototype: {
+    hasOwnProperty: ObjectHasOwnProperty,
+  },
+  create: ObjectCreate,
+  defineProperty: ObjectDefineProperty,
+  keys: ObjectKeys,
+} = Object;
+
+// Set up process.moduleLoadList.
+const moduleLoadList = [];
+ObjectDefineProperty(process, 'moduleLoadList', {
+  value: moduleLoadList,
+  configurable: true,
+  enumerable: true,
+  writable: false
+});
 
-  // Set up internalBinding() in the closure.
-  let internalBinding;
-  {
-    const bindingObj = ObjectCreate(null);
-    internalBinding = function internalBinding(module) {
-      let mod = bindingObj[module];
-      if (typeof mod !== 'object') {
-        mod = bindingObj[module] = getInternalBinding(module);
-        moduleLoadList.push(`Internal Binding ${module}`);
-      }
-      return mod;
-    };
-  }
 
-  // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
-  internalBinding('module_wrap').callbackMap = new WeakMap();
-
-  // Set up NativeModule.
-  function NativeModule(id) {
-    this.filename = `${id}.js`;
-    this.id = id;
-    this.exports = {};
-    this.reflect = undefined;
-    this.exportKeys = undefined;
-    this.loaded = false;
-    this.loading = false;
-  }
+// internalBindingWhitelist contains the name of internalBinding modules
+// that are whitelisted for access via process.binding()... This is used
+// to provide a transition path for modules that are being moved over to
+// internalBinding.
+const internalBindingWhitelist = [
+  'async_wrap',
+  'buffer',
+  'cares_wrap',
+  'config',
+  'constants',
+  'contextify',
+  'crypto',
+  'fs',
+  'fs_event_wrap',
+  'http_parser',
+  'icu',
+  'inspector',
+  'js_stream',
+  'natives',
+  'os',
+  'pipe_wrap',
+  'process_wrap',
+  'signal_wrap',
+  'spawn_sync',
+  'stream_wrap',
+  'tcp_wrap',
+  'tls_wrap',
+  'tty_wrap',
+  'udp_wrap',
+  'url',
+  'util',
+  'uv',
+  'v8',
+  'zlib'
+];
+// We will use a lazy loaded SafeSet in internalBindingWhitelistHas
+// for checking existence in this list.
+let internalBindingWhitelistSet;
+
+// Set up process.binding() and process._linkedBinding().
+{
+  const bindingObj = ObjectCreate(null);
+
+  process.binding = function binding(module) {
+    module = String(module);
+    // Deprecated specific process.binding() modules, but not all, allow
+    // selective fallback to internalBinding for the deprecated ones.
+    if (internalBindingWhitelistHas(module)) {
+      return internalBinding(module);
+    }
+    let mod = bindingObj[module];
+    if (typeof mod !== 'object') {
+      mod = bindingObj[module] = getBinding(module);
+      moduleLoadList.push(`Binding ${module}`);
+    }
+    return mod;
+  };
 
-  NativeModule._source = getInternalBinding('natives');
-  NativeModule._cache = {};
+  process._linkedBinding = function _linkedBinding(module) {
+    module = String(module);
+    let mod = bindingObj[module];
+    if (typeof mod !== 'object')
+      mod = bindingObj[module] = getLinkedBinding(module);
+    return mod;
+  };
+}
+
+// Set up internalBinding() in the closure.
+let internalBinding;
+{
+  const bindingObj = ObjectCreate(null);
+  internalBinding = function internalBinding(module) {
+    let mod = bindingObj[module];
+    if (typeof mod !== 'object') {
+      mod = bindingObj[module] = getInternalBinding(module);
+      moduleLoadList.push(`Internal Binding ${module}`);
+    }
+    return mod;
+  };
+}
+
+// Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
+internalBinding('module_wrap').callbackMap = new WeakMap();
+
+// Set up NativeModule.
+function NativeModule(id) {
+  this.filename = `${id}.js`;
+  this.id = id;
+  this.exports = {};
+  this.reflect = undefined;
+  this.exportKeys = undefined;
+  this.loaded = false;
+  this.loading = false;
+}
+
+NativeModule._source = getInternalBinding('natives');
+NativeModule._cache = {};
+
+const config = getInternalBinding('config');
+
+// Think of this as module.exports in this file even though it is not
+// written in CommonJS style.
+const loaderExports = { internalBinding, NativeModule };
+const loaderId = 'internal/bootstrap/loaders';
+
+NativeModule.require = function(id) {
+  if (id === loaderId) {
+    return loaderExports;
+  }
 
-  const config = getInternalBinding('config');
+  const cached = NativeModule.getCached(id);
+  if (cached && (cached.loaded || cached.loading)) {
+    return cached.exports;
+  }
 
-  // Think of this as module.exports in this file even though it is not
-  // written in CommonJS style.
-  const loaderExports = { internalBinding, NativeModule };
-  const loaderId = 'internal/bootstrap/loaders';
+  if (!NativeModule.exists(id)) {
+    // Model the error off the internal/errors.js model, but
+    // do not use that module given that it could actually be
+    // the one causing the error if there's a bug in Node.js.
+    // eslint-disable-next-line no-restricted-syntax
+    const err = new Error(`No such built-in module: ${id}`);
+    err.code = 'ERR_UNKNOWN_BUILTIN_MODULE';
+    err.name = 'Error [ERR_UNKNOWN_BUILTIN_MODULE]';
+    throw err;
+  }
 
-  NativeModule.require = function(id) {
-    if (id === loaderId) {
-      return loaderExports;
-    }
+  moduleLoadList.push(`NativeModule ${id}`);
 
-    const cached = NativeModule.getCached(id);
-    if (cached && (cached.loaded || cached.loading)) {
-      return cached.exports;
-    }
+  const nativeModule = new NativeModule(id);
 
-    if (!NativeModule.exists(id)) {
-      // Model the error off the internal/errors.js model, but
-      // do not use that module given that it could actually be
-      // the one causing the error if there's a bug in Node.js.
-      // eslint-disable-next-line no-restricted-syntax
-      const err = new Error(`No such built-in module: ${id}`);
-      err.code = 'ERR_UNKNOWN_BUILTIN_MODULE';
-      err.name = 'Error [ERR_UNKNOWN_BUILTIN_MODULE]';
-      throw err;
-    }
+  nativeModule.cache();
+  nativeModule.compile();
 
-    moduleLoadList.push(`NativeModule ${id}`);
+  return nativeModule.exports;
+};
 
-    const nativeModule = new NativeModule(id);
+NativeModule.isDepsModule = function(id) {
+  return id.startsWith('node-inspect/') || id.startsWith('v8/');
+};
 
-    nativeModule.cache();
-    nativeModule.compile();
+NativeModule.requireForDeps = function(id) {
+  if (!NativeModule.exists(id) ||
+      // TODO(TimothyGu): remove when DEP0084 reaches end of life.
+      NativeModule.isDepsModule(id)) {
+    id = `internal/deps/${id}`;
+  }
+  return NativeModule.require(id);
+};
 
-    return nativeModule.exports;
-  };
+NativeModule.getCached = function(id) {
+  return NativeModule._cache[id];
+};
 
-  NativeModule.isDepsModule = function(id) {
-    return id.startsWith('node-inspect/') || id.startsWith('v8/');
-  };
+NativeModule.exists = function(id) {
+  return NativeModule._source.hasOwnProperty(id);
+};
 
-  NativeModule.requireForDeps = function(id) {
-    if (!NativeModule.exists(id) ||
-        // TODO(TimothyGu): remove when DEP0084 reaches end of life.
-        NativeModule.isDepsModule(id)) {
-      id = `internal/deps/${id}`;
+if (config.exposeInternals) {
+  NativeModule.nonInternalExists = function(id) {
+    // Do not expose this to user land even with --expose-internals.
+    if (id === loaderId) {
+      return false;
     }
-    return NativeModule.require(id);
+    return NativeModule.exists(id);
   };
 
-  NativeModule.getCached = function(id) {
-    return NativeModule._cache[id];
+  NativeModule.isInternal = function(id) {
+    // Do not expose this to user land even with --expose-internals.
+    return id === loaderId;
   };
-
-  NativeModule.exists = function(id) {
-    return NativeModule._source.hasOwnProperty(id);
+} else {
+  NativeModule.nonInternalExists = function(id) {
+    return NativeModule.exists(id) && !NativeModule.isInternal(id);
   };
 
-  if (config.exposeInternals) {
-    NativeModule.nonInternalExists = function(id) {
-      // Do not expose this to user land even with --expose-internals.
-      if (id === loaderId) {
-        return false;
-      }
-      return NativeModule.exists(id);
-    };
-
-    NativeModule.isInternal = function(id) {
-      // Do not expose this to user land even with --expose-internals.
-      return id === loaderId;
-    };
-  } else {
-    NativeModule.nonInternalExists = function(id) {
-      return NativeModule.exists(id) && !NativeModule.isInternal(id);
-    };
-
-    NativeModule.isInternal = function(id) {
-      return id.startsWith('internal/') ||
-          (id === 'worker_threads' && !config.experimentalWorker);
-    };
-  }
-
-  NativeModule.getSource = function(id) {
-    return NativeModule._source[id];
+  NativeModule.isInternal = function(id) {
+    return id.startsWith('internal/') ||
+        (id === 'worker_threads' && !config.experimentalWorker);
   };
-
-  const getOwn = (target, property, receiver) => {
-    return ReflectApply(ObjectHasOwnProperty, target, [property]) ?
-      ReflectGet(target, property, receiver) :
-      undefined;
+}
+
+NativeModule.getSource = function(id) {
+  return NativeModule._source[id];
+};
+
+const getOwn = (target, property, receiver) => {
+  return ReflectApply(ObjectHasOwnProperty, target, [property]) ?
+    ReflectGet(target, property, receiver) :
+    undefined;
+};
+
+// Provide named exports for all builtin libraries so that the libraries
+// may be imported in a nicer way for ESM users. The default export is left
+// as the entire namespace (module.exports) and wrapped in a proxy such
+// that APMs and other behavior are still left intact.
+NativeModule.prototype.proxifyExports = function() {
+  this.exportKeys = ObjectKeys(this.exports);
+
+  const update = (property, value) => {
+    if (this.reflect !== undefined &&
+        ReflectApply(ObjectHasOwnProperty,
+                     this.reflect.exports, [property]))
+      this.reflect.exports[property].set(value);
   };
 
-  // Provide named exports for all builtin libraries so that the libraries
-  // may be imported in a nicer way for ESM users. The default export is left
-  // as the entire namespace (module.exports) and wrapped in a proxy such
-  // that APMs and other behavior are still left intact.
-  NativeModule.prototype.proxifyExports = function() {
-    this.exportKeys = ObjectKeys(this.exports);
-
-    const update = (property, value) => {
-      if (this.reflect !== undefined &&
-          ReflectApply(ObjectHasOwnProperty,
-                       this.reflect.exports, [property]))
-        this.reflect.exports[property].set(value);
-    };
-
-    const handler = {
-      __proto__: null,
-      defineProperty: (target, prop, descriptor) => {
-        // Use `Object.defineProperty` instead of `Reflect.defineProperty`
-        // to throw the appropriate error if something goes wrong.
-        ObjectDefineProperty(target, prop, descriptor);
-        if (typeof descriptor.get === 'function' &&
-            !ReflectHas(handler, 'get')) {
-          handler.get = (target, prop, receiver) => {
-            const value = ReflectGet(target, prop, receiver);
-            if (ReflectApply(ObjectHasOwnProperty, target, [prop]))
-              update(prop, value);
-            return value;
-          };
-        }
-        update(prop, getOwn(target, prop));
+  const handler = {
+    __proto__: null,
+    defineProperty: (target, prop, descriptor) => {
+      // Use `Object.defineProperty` instead of `Reflect.defineProperty`
+      // to throw the appropriate error if something goes wrong.
+      ObjectDefineProperty(target, prop, descriptor);
+      if (typeof descriptor.get === 'function' &&
+          !ReflectHas(handler, 'get')) {
+        handler.get = (target, prop, receiver) => {
+          const value = ReflectGet(target, prop, receiver);
+          if (ReflectApply(ObjectHasOwnProperty, target, [prop]))
+            update(prop, value);
+          return value;
+        };
+      }
+      update(prop, getOwn(target, prop));
+      return true;
+    },
+    deleteProperty: (target, prop) => {
+      if (ReflectDeleteProperty(target, prop)) {
+        update(prop, undefined);
         return true;
-      },
-      deleteProperty: (target, prop) => {
-        if (ReflectDeleteProperty(target, prop)) {
-          update(prop, undefined);
-          return true;
-        }
-        return false;
-      },
-      set: (target, prop, value, receiver) => {
-        const descriptor = ReflectGetOwnPropertyDescriptor(target, prop);
-        if (ReflectSet(target, prop, value, receiver)) {
-          if (descriptor && typeof descriptor.set === 'function') {
-            for (const key of this.exportKeys) {
-              update(key, getOwn(target, key, receiver));
-            }
-          } else {
-            update(prop, getOwn(target, prop, receiver));
+      }
+      return false;
+    },
+    set: (target, prop, value, receiver) => {
+      const descriptor = ReflectGetOwnPropertyDescriptor(target, prop);
+      if (ReflectSet(target, prop, value, receiver)) {
+        if (descriptor && typeof descriptor.set === 'function') {
+          for (const key of this.exportKeys) {
+            update(key, getOwn(target, key, receiver));
           }
-          return true;
+        } else {
+          update(prop, getOwn(target, prop, receiver));
         }
-        return false;
+        return true;
       }
-    };
-
-    this.exports = new Proxy(this.exports, handler);
+      return false;
+    }
   };
 
-  const { compileFunction } = getInternalBinding('native_module');
-  NativeModule.prototype.compile = function() {
-    const id = this.id;
+  this.exports = new Proxy(this.exports, handler);
+};
 
-    this.loading = true;
+const { compileFunction } = getInternalBinding('native_module');
+NativeModule.prototype.compile = function() {
+  const id = this.id;
 
-    try {
-      const requireFn = this.id.startsWith('internal/deps/') ?
-        NativeModule.requireForDeps :
-        NativeModule.require;
+  this.loading = true;
 
-      const fn = compileFunction(id);
-      fn(this.exports, requireFn, this, process, internalBinding);
+  try {
+    const requireFn = this.id.startsWith('internal/deps/') ?
+      NativeModule.requireForDeps :
+      NativeModule.require;
 
-      if (config.experimentalModules && !NativeModule.isInternal(this.id)) {
-        this.proxifyExports();
-      }
+    const fn = compileFunction(id);
+    fn(this.exports, requireFn, this, process, internalBinding);
 
-      this.loaded = true;
-    } finally {
-      this.loading = false;
+    if (config.experimentalModules && !NativeModule.isInternal(this.id)) {
+      this.proxifyExports();
     }
-  };
 
-  NativeModule.prototype.cache = function() {
-    NativeModule._cache[this.id] = this;
-  };
-
-  // Coverage must be turned on early, so that we can collect
-  // it for Node.js' own internal libraries.
-  if (process.env.NODE_V8_COVERAGE) {
-    NativeModule.require('internal/process/coverage').setup();
+    this.loaded = true;
+  } finally {
+    this.loading = false;
   }
-
-  function internalBindingWhitelistHas(name) {
-    if (!internalBindingWhitelistSet) {
-      const { SafeSet } = NativeModule.require('internal/safe_globals');
-      internalBindingWhitelistSet = new SafeSet(internalBindingWhitelist);
-    }
-    return internalBindingWhitelistSet.has(name);
+};
+
+NativeModule.prototype.cache = function() {
+  NativeModule._cache[this.id] = this;
+};
+
+// Coverage must be turned on early, so that we can collect
+// it for Node.js' own internal libraries.
+if (process.env.NODE_V8_COVERAGE) {
+  NativeModule.require('internal/process/coverage').setup();
+}
+
+function internalBindingWhitelistHas(name) {
+  if (!internalBindingWhitelistSet) {
+    const { SafeSet } = NativeModule.require('internal/safe_globals');
+    internalBindingWhitelistSet = new SafeSet(internalBindingWhitelist);
   }
+  return internalBindingWhitelistSet.has(name);
+}
 
-  // This will be passed to the bootstrapNodeJSCore function in
-  // bootstrap/node.js.
-  return loaderExports;
-});
+// This will be passed to internal/bootstrap/node.js.
+return loaderExports;
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index d7e8ff5016f763..3f730f984ee4ae 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -12,733 +12,695 @@
 // into this bootstrapper to bootstrap Node.js core.
 'use strict';
 
-(function bootstrapNodeJSCore(process,
-                              // bootstrapper properties... destructured to
-                              // avoid retaining a reference to the bootstrap
-                              // object.
-                              { _setupTraceCategoryState,
-                                _setupNextTick,
-                                _setupPromises, _chdir, _cpuUsage,
-                                _hrtime, _hrtimeBigInt,
-                                _memoryUsage, _rawDebug,
-                                _umask, _initgroups, _setegid, _seteuid,
-                                _setgid, _setuid, _setgroups,
-                                _shouldAbortOnUncaughtToggle },
-                              { internalBinding, NativeModule },
-                              triggerFatalException) {
-  const exceptionHandlerState = { captureFn: null };
-  const isMainThread = internalBinding('worker').threadId === 0;
-
-  function startup() {
-    setupTraceCategoryState();
-
-    setupProcessObject();
-
-    // Do this good and early, since it handles errors.
-    setupProcessFatal();
-
-    setupProcessICUVersions();
-
-    setupGlobalVariables();
-
-    // Bootstrappers for all threads, including worker threads and main thread
-    const perThreadSetup = NativeModule.require('internal/process/per_thread');
-    // Bootstrappers for the main thread only
-    let mainThreadSetup;
-    // Bootstrappers for the worker threads only
-    let workerThreadSetup;
-    if (isMainThread) {
-      mainThreadSetup = NativeModule.require(
-        'internal/process/main_thread_only'
-      );
-    } else {
-      workerThreadSetup = NativeModule.require(
-        'internal/process/worker_thread_only'
-      );
-    }
-
-    perThreadSetup.setupAssert();
-    perThreadSetup.setupConfig(NativeModule._source);
-
-    if (isMainThread) {
-      mainThreadSetup.setupSignalHandlers(internalBinding);
-    }
+// This file is compiled as if it's wrapped in a function with arguments
+// passed by node::LoadEnvironment()
+/* global process, bootstrappers, loaderExports, triggerFatalException */
+const {
+  _setupTraceCategoryState,
+  _setupNextTick,
+  _setupPromises, _chdir, _cpuUsage,
+  _hrtime, _hrtimeBigInt,
+  _memoryUsage, _rawDebug,
+  _umask, _initgroups, _setegid, _seteuid,
+  _setgid, _setuid, _setgroups,
+  _shouldAbortOnUncaughtToggle
+} = bootstrappers;
+const { internalBinding, NativeModule } = loaderExports;
+
+const exceptionHandlerState = { captureFn: null };
+const isMainThread = internalBinding('worker').threadId === 0;
+
+function startup() {
+  setupTraceCategoryState();
+
+  setupProcessObject();
+
+  // Do this good and early, since it handles errors.
+  setupProcessFatal();
+
+  setupProcessICUVersions();
+
+  setupGlobalVariables();
+
+  // Bootstrappers for all threads, including worker threads and main thread
+  const perThreadSetup = NativeModule.require('internal/process/per_thread');
+  // Bootstrappers for the main thread only
+  let mainThreadSetup;
+  // Bootstrappers for the worker threads only
+  let workerThreadSetup;
+  if (isMainThread) {
+    mainThreadSetup = NativeModule.require(
+      'internal/process/main_thread_only'
+    );
+  } else {
+    workerThreadSetup = NativeModule.require(
+      'internal/process/worker_thread_only'
+    );
+  }
 
-    perThreadSetup.setupUncaughtExceptionCapture(exceptionHandlerState,
-                                                 _shouldAbortOnUncaughtToggle);
+  perThreadSetup.setupAssert();
+  perThreadSetup.setupConfig(NativeModule._source);
 
-    NativeModule.require('internal/process/warning').setup();
-    NativeModule.require('internal/process/next_tick').setup(_setupNextTick,
-                                                             _setupPromises);
+  if (isMainThread) {
+    mainThreadSetup.setupSignalHandlers(internalBinding);
+  }
 
-    if (isMainThread) {
-      mainThreadSetup.setupStdio();
-      mainThreadSetup.setupProcessMethods(
-        _chdir, _umask, _initgroups, _setegid, _seteuid,
-        _setgid, _setuid, _setgroups
-      );
-    } else {
-      workerThreadSetup.setupStdio();
-    }
+  perThreadSetup.setupUncaughtExceptionCapture(exceptionHandlerState,
+                                               _shouldAbortOnUncaughtToggle);
+
+  NativeModule.require('internal/process/warning').setup();
+  NativeModule.require('internal/process/next_tick').setup(_setupNextTick,
+                                                           _setupPromises);
+
+  if (isMainThread) {
+    mainThreadSetup.setupStdio();
+    mainThreadSetup.setupProcessMethods(
+      _chdir, _umask, _initgroups, _setegid, _seteuid,
+      _setgid, _setuid, _setgroups
+    );
+  } else {
+    workerThreadSetup.setupStdio();
+  }
 
-    const perf = internalBinding('performance');
-    const {
-      NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE,
-    } = perf.constants;
+  const perf = internalBinding('performance');
+  const {
+    NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE,
+  } = perf.constants;
 
-    perThreadSetup.setupRawDebug(_rawDebug);
-    perThreadSetup.setupHrtime(_hrtime, _hrtimeBigInt);
-    perThreadSetup.setupCpuUsage(_cpuUsage);
-    perThreadSetup.setupMemoryUsage(_memoryUsage);
-    perThreadSetup.setupKillAndExit();
+  perThreadSetup.setupRawDebug(_rawDebug);
+  perThreadSetup.setupHrtime(_hrtime, _hrtimeBigInt);
+  perThreadSetup.setupCpuUsage(_cpuUsage);
+  perThreadSetup.setupMemoryUsage(_memoryUsage);
+  perThreadSetup.setupKillAndExit();
 
-    if (global.__coverage__)
-      NativeModule.require('internal/process/write-coverage').setup();
+  if (global.__coverage__)
+    NativeModule.require('internal/process/write-coverage').setup();
 
-    if (process.env.NODE_V8_COVERAGE) {
-      NativeModule.require('internal/process/coverage').setupExitHooks();
-    }
+  if (process.env.NODE_V8_COVERAGE) {
+    NativeModule.require('internal/process/coverage').setupExitHooks();
+  }
 
-    if (process.config.variables.v8_enable_inspector) {
-      NativeModule.require('internal/inspector_async_hook').setup();
-    }
+  if (process.config.variables.v8_enable_inspector) {
+    NativeModule.require('internal/inspector_async_hook').setup();
+  }
 
-    const { getOptionValue } = NativeModule.require('internal/options');
+  const { getOptionValue } = NativeModule.require('internal/options');
 
-    if (getOptionValue('--help')) {
-      NativeModule.require('internal/print_help').print(process.stdout);
-      return;
-    }
+  if (getOptionValue('--help')) {
+    NativeModule.require('internal/print_help').print(process.stdout);
+    return;
+  }
 
-    if (getOptionValue('--completion-bash')) {
-      NativeModule.require('internal/bash_completion').print(process.stdout);
-      return;
-    }
+  if (getOptionValue('--completion-bash')) {
+    NativeModule.require('internal/bash_completion').print(process.stdout);
+    return;
+  }
 
-    if (isMainThread) {
-      mainThreadSetup.setupChildProcessIpcChannel();
-    }
+  if (isMainThread) {
+    mainThreadSetup.setupChildProcessIpcChannel();
+  }
 
-    const browserGlobals = !process._noBrowserGlobals;
-    if (browserGlobals) {
-      // We are setting this here to forward it to the inspector later
-      perThreadSetup.originalConsole = global.console;
-      setupGlobalTimeouts();
-      setupGlobalConsole();
-      setupGlobalURL();
-      setupGlobalEncoding();
-      setupQueueMicrotask();
-    }
+  const browserGlobals = !process._noBrowserGlobals;
+  if (browserGlobals) {
+    setupGlobalTimeouts();
+    setupGlobalConsole();
+    setupGlobalURL();
+    setupGlobalEncoding();
+    setupQueueMicrotask();
+  }
 
-    if (getOptionValue('--experimental-worker')) {
-      setupDOMException();
-    }
+  if (getOptionValue('--experimental-worker')) {
+    setupDOMException();
+  }
 
-    // On OpenBSD process.execPath will be relative unless we
-    // get the full path before process.execPath is used.
-    if (process.platform === 'openbsd') {
-      const { realpathSync } = NativeModule.require('fs');
-      process.execPath = realpathSync.native(process.execPath);
-    }
+  // On OpenBSD process.execPath will be relative unless we
+  // get the full path before process.execPath is used.
+  if (process.platform === 'openbsd') {
+    const { realpathSync } = NativeModule.require('fs');
+    process.execPath = realpathSync.native(process.execPath);
+  }
 
-    Object.defineProperty(process, 'argv0', {
-      enumerable: true,
-      configurable: false,
-      value: process.argv[0]
-    });
-    process.argv[0] = process.execPath;
+  Object.defineProperty(process, 'argv0', {
+    enumerable: true,
+    configurable: false,
+    value: process.argv[0]
+  });
+  process.argv[0] = process.execPath;
+
+  // Handle `--debug*` deprecation and invalidation.
+  if (process._invalidDebug) {
+    process.emitWarning(
+      '`node --debug` and `node --debug-brk` are invalid. ' +
+      'Please use `node --inspect` or `node --inspect-brk` instead.',
+      'DeprecationWarning', 'DEP0062', startup, true);
+    process.exit(9);
+  } else if (process._deprecatedDebugBrk) {
+    process.emitWarning(
+      '`node --inspect --debug-brk` is deprecated. ' +
+      'Please use `node --inspect-brk` instead.',
+      'DeprecationWarning', 'DEP0062', startup, true);
+  }
 
-    // Handle `--debug*` deprecation and invalidation.
-    if (process._invalidDebug) {
+  const experimentalModules = getOptionValue('--experimental-modules');
+  const experimentalVMModules = getOptionValue('--experimental-vm-modules');
+  if (experimentalModules || experimentalVMModules) {
+    if (experimentalModules) {
       process.emitWarning(
-        '`node --debug` and `node --debug-brk` are invalid. ' +
-        'Please use `node --inspect` or `node --inspect-brk` instead.',
-        'DeprecationWarning', 'DEP0062', startup, true);
-      process.exit(9);
-    } else if (process._deprecatedDebugBrk) {
-      process.emitWarning(
-        '`node --inspect --debug-brk` is deprecated. ' +
-        'Please use `node --inspect-brk` instead.',
-        'DeprecationWarning', 'DEP0062', startup, true);
+        'The ESM module loader is experimental.',
+        'ExperimentalWarning', undefined);
     }
+    NativeModule.require('internal/process/esm_loader').setup();
+  }
 
-    const experimentalModules = getOptionValue('--experimental-modules');
-    const experimentalVMModules = getOptionValue('--experimental-vm-modules');
-    if (experimentalModules || experimentalVMModules) {
-      if (experimentalModules) {
-        process.emitWarning(
-          'The ESM module loader is experimental.',
-          'ExperimentalWarning', undefined);
-      }
-      NativeModule.require('internal/process/esm_loader').setup();
+  const { deprecate } = NativeModule.require('internal/util');
+  {
+    // Install legacy getters on the `util` binding for typechecking.
+    // TODO(addaleax): Turn into a full runtime deprecation.
+    const pendingDeprecation = getOptionValue('--pending-deprecation');
+    const utilBinding = internalBinding('util');
+    const types = NativeModule.require('internal/util/types');
+    for (const name of [
+      'isArrayBuffer', 'isArrayBufferView', 'isAsyncFunction',
+      'isDataView', 'isDate', 'isExternal', 'isMap', 'isMapIterator',
+      'isNativeError', 'isPromise', 'isRegExp', 'isSet', 'isSetIterator',
+      'isTypedArray', 'isUint8Array', 'isAnyArrayBuffer'
+    ]) {
+      utilBinding[name] = pendingDeprecation ?
+        deprecate(types[name],
+                  'Accessing native typechecking bindings of Node ' +
+                  'directly is deprecated. ' +
+                  `Please use \`util.types.${name}\` instead.`,
+                  'DEP0103') :
+        types[name];
     }
+  }
 
-    const { deprecate } = NativeModule.require('internal/util');
-    {
-      // Install legacy getters on the `util` binding for typechecking.
-      // TODO(addaleax): Turn into a full runtime deprecation.
-      const { pendingDeprecation } = internalBinding('config');
-      const utilBinding = internalBinding('util');
-      const types = internalBinding('types');
-      for (const name of [
-        'isArrayBuffer', 'isArrayBufferView', 'isAsyncFunction',
-        'isDataView', 'isDate', 'isExternal', 'isMap', 'isMapIterator',
-        'isNativeError', 'isPromise', 'isRegExp', 'isSet', 'isSetIterator',
-        'isTypedArray', 'isUint8Array', 'isAnyArrayBuffer'
-      ]) {
-        utilBinding[name] = pendingDeprecation ?
-          deprecate(types[name],
-                    'Accessing native typechecking bindings of Node ' +
-                    'directly is deprecated. ' +
-                    `Please use \`util.types.${name}\` instead.`,
-                    'DEP0103') :
-          types[name];
-      }
+  // TODO(jasnell): The following have been globals since around 2012.
+  // That's just silly. The underlying perfctr support has been removed
+  // so these are now deprecated non-ops that can be removed after one
+  // major release cycle.
+  if (process.platform === 'win32') {
+    const names = [
+      'NET_SERVER_CONNECTION',
+      'NET_SERVER_CONNECTION_CLOSE',
+      'HTTP_SERVER_REQUEST',
+      'HTTP_SERVER_RESPONSE',
+      'HTTP_CLIENT_REQUEST',
+      'HTTP_CLIENT_RESPONSE'
+    ];
+    for (var n = 0; n < names.length; n++) {
+      Object.defineProperty(global, `COUNTER_${names[n]}`, {
+        configurable: true,
+        enumerable: false,
+        value: deprecate(noop,
+                         `COUNTER_${names[n]}() is deprecated.`,
+                         'DEP0120')
+      });
     }
+  }
 
-    // TODO(jasnell): The following have been globals since around 2012.
-    // That's just silly. The underlying perfctr support has been removed
-    // so these are now deprecated non-ops that can be removed after one
-    // major release cycle.
-    if (process.platform === 'win32') {
-      const names = [
-        'NET_SERVER_CONNECTION',
-        'NET_SERVER_CONNECTION_CLOSE',
-        'HTTP_SERVER_REQUEST',
-        'HTTP_SERVER_RESPONSE',
-        'HTTP_CLIENT_REQUEST',
-        'HTTP_CLIENT_RESPONSE'
-      ];
-      for (var n = 0; n < names.length; n++) {
-        Object.defineProperty(global, `COUNTER_${names[n]}`, {
-          configurable: true,
-          enumerable: false,
-          value: deprecate(noop,
-                           `COUNTER_${names[n]}() is deprecated.`,
-                           'DEP0120')
-        });
-      }
-    }
+  perf.markMilestone(NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);
 
-    perf.markMilestone(NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);
+  perThreadSetup.setupAllowedFlags();
 
-    perThreadSetup.setupAllowedFlags();
+  startExecution();
+}
 
-    startExecution();
+// There are various modes that Node can run in. The most common two
+// are running from a script and running the REPL - but there are a few
+// others like the debugger or running --eval arguments. Here we decide
+// which mode we run in.
+function startExecution() {
+  // This means we are in a Worker context, and any script execution
+  // will be directed by the worker module.
+  if (internalBinding('worker').getEnvMessagePort() !== undefined) {
+    NativeModule.require('internal/worker').setupChild(evalScript);
+    return;
   }
 
-  // There are various modes that Node can run in. The most common two
-  // are running from a script and running the REPL - but there are a few
-  // others like the debugger or running --eval arguments. Here we decide
-  // which mode we run in.
-  function startExecution() {
-    // This means we are in a Worker context, and any script execution
-    // will be directed by the worker module.
-    if (internalBinding('worker').getEnvMessagePort() !== undefined) {
-      NativeModule.require('internal/worker').setupChild(evalScript);
-      return;
-    }
+  // To allow people to extend Node in different ways, this hook allows
+  // one to drop a file lib/_third_party_main.js into the build
+  // directory which will be executed instead of Node's normal loading.
+  if (NativeModule.exists('_third_party_main')) {
+    process.nextTick(() => {
+      NativeModule.require('_third_party_main');
+    });
+    return;
+  }
 
-    // To allow people to extend Node in different ways, this hook allows
-    // one to drop a file lib/_third_party_main.js into the build
-    // directory which will be executed instead of Node's normal loading.
-    if (NativeModule.exists('_third_party_main')) {
-      process.nextTick(() => {
-        NativeModule.require('_third_party_main');
-      });
-      return;
+  // `node inspect ...` or `node debug ...`
+  if (process.argv[1] === 'inspect' || process.argv[1] === 'debug') {
+    if (process.argv[1] === 'debug') {
+      process.emitWarning(
+        '`node debug` is deprecated. Please use `node inspect` instead.',
+        'DeprecationWarning', 'DEP0068');
     }
 
-    // `node inspect ...` or `node debug ...`
-    if (process.argv[1] === 'inspect' || process.argv[1] === 'debug') {
-      if (process.argv[1] === 'debug') {
-        process.emitWarning(
-          '`node debug` is deprecated. Please use `node inspect` instead.',
-          'DeprecationWarning', 'DEP0068');
-      }
+    // Start the debugger agent.
+    process.nextTick(() => {
+      NativeModule.require('internal/deps/node-inspect/lib/_inspect').start();
+    });
+    return;
+  }
 
-      // Start the debugger agent.
-      process.nextTick(() => {
-        NativeModule.require('internal/deps/node-inspect/lib/_inspect').start();
-      });
-      return;
-    }
+  // `node --prof-process`
+  // TODO(joyeecheung): use internal/options instead of process.profProcess
+  if (process.profProcess) {
+    NativeModule.require('internal/v8_prof_processor');
+    return;
+  }
 
-    // `node --prof-process`
-    // TODO(joyeecheung): use internal/options instead of process.profProcess
-    if (process.profProcess) {
-      NativeModule.require('internal/v8_prof_processor');
-      return;
-    }
+  // There is user code to be run.
+  prepareUserCodeExecution();
+  executeUserCode();
+}
+
+function prepareUserCodeExecution() {
+  // If this is a worker in cluster mode, start up the communication
+  // channel. This needs to be done before any user code gets executed
+  // (including preload modules).
+  if (process.argv[1] && process.env.NODE_UNIQUE_ID) {
+    const cluster = NativeModule.require('cluster');
+    cluster._setupWorker();
+    // Make sure it's not accidentally inherited by child processes.
+    delete process.env.NODE_UNIQUE_ID;
+  }
 
-    // There is user code to be run.
-    prepareUserCodeExecution();
-    executeUserCode();
+  // For user code, we preload modules if `-r` is passed
+  // TODO(joyeecheung): use internal/options instead of
+  // process._preload_modules
+  if (process._preload_modules) {
+    const {
+      _preloadModules
+    } = NativeModule.require('internal/modules/cjs/loader');
+    _preloadModules(process._preload_modules);
+  }
+}
+
+function executeUserCode() {
+  // User passed `-e` or `--eval` arguments to Node without `-i` or
+  // `--interactive`.
+  // Note that the name `forceRepl` is merely an alias of `interactive`
+  // in code.
+  // TODO(joyeecheung): use internal/options instead of
+  // process._eval/process._forceRepl
+  if (process._eval != null && !process._forceRepl) {
+    const {
+      addBuiltinLibsToObject
+    } = NativeModule.require('internal/modules/cjs/helpers');
+    addBuiltinLibsToObject(global);
+    evalScript('[eval]', wrapForBreakOnFirstLine(process._eval));
+    return;
   }
 
-  function prepareUserCodeExecution() {
-    // If this is a worker in cluster mode, start up the communication
-    // channel. This needs to be done before any user code gets executed
-    // (including preload modules).
-    if (process.argv[1] && process.env.NODE_UNIQUE_ID) {
-      const cluster = NativeModule.require('cluster');
-      cluster._setupWorker();
-      // Make sure it's not accidentally inherited by child processes.
-      delete process.env.NODE_UNIQUE_ID;
-    }
+  // If the first argument is a file name, run it as a main script
+  if (process.argv[1] && process.argv[1] !== '-') {
+    // Expand process.argv[1] into a full path.
+    const path = NativeModule.require('path');
+    process.argv[1] = path.resolve(process.argv[1]);
 
-    // For user code, we preload modules if `-r` is passed
-    // TODO(joyeecheung): use internal/options instead of
-    // process._preload_modules
-    if (process._preload_modules) {
-      const {
-        _preloadModules
-      } = NativeModule.require('internal/modules/cjs/loader');
-      _preloadModules(process._preload_modules);
-    }
-  }
+    const CJSModule = NativeModule.require('internal/modules/cjs/loader');
 
-  function executeUserCode() {
-    // User passed `-e` or `--eval` arguments to Node without `-i` or
-    // `--interactive`.
-    // Note that the name `forceRepl` is merely an alias of `interactive`
-    // in code.
+    // If user passed `-c` or `--check` arguments to Node, check its syntax
+    // instead of actually running the file.
     // TODO(joyeecheung): use internal/options instead of
-    // process._eval/process._forceRepl
-    if (process._eval != null && !process._forceRepl) {
-      const {
-        addBuiltinLibsToObject
-      } = NativeModule.require('internal/modules/cjs/helpers');
-      addBuiltinLibsToObject(global);
-      evalScript('[eval]', wrapForBreakOnFirstLine(process._eval));
-      return;
-    }
+    // process._syntax_check_only
+    if (process._syntax_check_only != null) {
+      const fs = NativeModule.require('fs');
+      // Read the source.
+      const filename = CJSModule._resolveFilename(process.argv[1]);
+      const source = fs.readFileSync(filename, 'utf-8');
+      checkScriptSyntax(source, filename);
+      process.exit(0);
+    }
+
+    // Note: this actually tries to run the module as a ESM first if
+    // --experimental-modules is on.
+    // TODO(joyeecheung): can we move that logic to here? Note that this
+    // is an undocumented method available via `require('module').runMain`
+    CJSModule.runMain();
+    return;
+  }
 
-    // If the first argument is a file name, run it as a main script
-    if (process.argv[1] && process.argv[1] !== '-') {
-      // Expand process.argv[1] into a full path.
-      const path = NativeModule.require('path');
-      process.argv[1] = path.resolve(process.argv[1]);
-
-      const CJSModule = NativeModule.require('internal/modules/cjs/loader');
-
-      // If user passed `-c` or `--check` arguments to Node, check its syntax
-      // instead of actually running the file.
-      // TODO(joyeecheung): use internal/options instead of
-      // process._syntax_check_only
-      if (process._syntax_check_only != null) {
-        const fs = NativeModule.require('fs');
-        // Read the source.
-        const filename = CJSModule._resolveFilename(process.argv[1]);
-        const source = fs.readFileSync(filename, 'utf-8');
-        checkScriptSyntax(source, filename);
-        process.exit(0);
+  // Create the REPL if `-i` or `--interactive` is passed, or if
+  // stdin is a TTY.
+  // Note that the name `forceRepl` is merely an alias of `interactive`
+  // in code.
+  if (process._forceRepl || NativeModule.require('tty').isatty(0)) {
+    const cliRepl = NativeModule.require('internal/repl');
+    cliRepl.createInternalRepl(process.env, (err, repl) => {
+      if (err) {
+        throw err;
       }
-
-      // Note: this actually tries to run the module as a ESM first if
-      // --experimental-modules is on.
-      // TODO(joyeecheung): can we move that logic to here? Note that this
-      // is an undocumented method available via `require('module').runMain`
-      CJSModule.runMain();
-      return;
-    }
-
-    // Create the REPL if `-i` or `--interactive` is passed, or if
-    // stdin is a TTY.
-    // Note that the name `forceRepl` is merely an alias of `interactive`
-    // in code.
-    if (process._forceRepl || NativeModule.require('tty').isatty(0)) {
-      const cliRepl = NativeModule.require('internal/repl');
-      cliRepl.createInternalRepl(process.env, (err, repl) => {
-        if (err) {
-          throw err;
+      repl.on('exit', () => {
+        if (repl._flushing) {
+          repl.pause();
+          return repl.once('flushHistory', () => {
+            process.exit();
+          });
         }
-        repl.on('exit', () => {
-          if (repl._flushing) {
-            repl.pause();
-            return repl.once('flushHistory', () => {
-              process.exit();
-            });
-          }
-          process.exit();
-        });
+        process.exit();
       });
+    });
 
-      // User passed '-e' or '--eval' along with `-i` or `--interactive`
-      if (process._eval != null) {
-        evalScript('[eval]', wrapForBreakOnFirstLine(process._eval));
-      }
-      return;
+    // User passed '-e' or '--eval' along with `-i` or `--interactive`
+    if (process._eval != null) {
+      evalScript('[eval]', wrapForBreakOnFirstLine(process._eval));
     }
-
-    // Stdin is not a TTY, we will read it and execute it.
-    readAndExecuteStdin();
+    return;
   }
 
-  function readAndExecuteStdin() {
-    process.stdin.setEncoding('utf8');
+  // Stdin is not a TTY, we will read it and execute it.
+  readAndExecuteStdin();
+}
 
-    let code = '';
-    process.stdin.on('data', (d) => {
-      code += d;
-    });
+function readAndExecuteStdin() {
+  process.stdin.setEncoding('utf8');
 
-    process.stdin.on('end', () => {
-      if (process._syntax_check_only != null) {
-        checkScriptSyntax(code, '[stdin]');
-      } else {
-        process._eval = code;
-        evalScript('[stdin]', wrapForBreakOnFirstLine(process._eval));
-      }
-    });
-  }
+  let code = '';
+  process.stdin.on('data', (d) => {
+    code += d;
+  });
 
-  function setupTraceCategoryState() {
-    const { traceCategoryState } = internalBinding('trace_events');
-    const kCategoryAsyncHooks = 0;
-    let traceEventsAsyncHook;
-
-    function toggleTraceCategoryState() {
-      // Dynamically enable/disable the traceEventsAsyncHook
-      const asyncHooksEnabled = !!traceCategoryState[kCategoryAsyncHooks];
-
-      if (asyncHooksEnabled) {
-        // Lazy load internal/trace_events_async_hooks only if the async_hooks
-        // trace event category is enabled.
-        if (!traceEventsAsyncHook) {
-          traceEventsAsyncHook =
-            NativeModule.require('internal/trace_events_async_hooks');
-        }
-        traceEventsAsyncHook.enable();
-      } else if (traceEventsAsyncHook) {
-        traceEventsAsyncHook.disable();
+  process.stdin.on('end', () => {
+    if (process._syntax_check_only != null) {
+      checkScriptSyntax(code, '[stdin]');
+    } else {
+      process._eval = code;
+      evalScript('[stdin]', wrapForBreakOnFirstLine(process._eval));
+    }
+  });
+}
+
+function setupTraceCategoryState() {
+  const { traceCategoryState } = internalBinding('trace_events');
+  const kCategoryAsyncHooks = 0;
+  let traceEventsAsyncHook;
+
+  function toggleTraceCategoryState() {
+    // Dynamically enable/disable the traceEventsAsyncHook
+    const asyncHooksEnabled = !!traceCategoryState[kCategoryAsyncHooks];
+
+    if (asyncHooksEnabled) {
+      // Lazy load internal/trace_events_async_hooks only if the async_hooks
+      // trace event category is enabled.
+      if (!traceEventsAsyncHook) {
+        traceEventsAsyncHook =
+          NativeModule.require('internal/trace_events_async_hooks');
       }
+      traceEventsAsyncHook.enable();
+    } else if (traceEventsAsyncHook) {
+      traceEventsAsyncHook.disable();
     }
-
-    toggleTraceCategoryState();
-    _setupTraceCategoryState(toggleTraceCategoryState);
   }
 
-  function setupProcessObject() {
-    const EventEmitter = NativeModule.require('events');
-    const origProcProto = Object.getPrototypeOf(process);
-    Object.setPrototypeOf(origProcProto, EventEmitter.prototype);
-    EventEmitter.call(process);
+  toggleTraceCategoryState();
+  _setupTraceCategoryState(toggleTraceCategoryState);
+}
+
+function setupProcessObject() {
+  const EventEmitter = NativeModule.require('events');
+  const origProcProto = Object.getPrototypeOf(process);
+  Object.setPrototypeOf(origProcProto, EventEmitter.prototype);
+  EventEmitter.call(process);
+}
+
+function setupGlobalVariables() {
+  Object.defineProperty(global, Symbol.toStringTag, {
+    value: 'global',
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+  global.process = process;
+  const util = NativeModule.require('util');
+
+  function makeGetter(name) {
+    return util.deprecate(function() {
+      return this;
+    }, `'${name}' is deprecated, use 'global'`, 'DEP0016');
   }
 
-  function setupGlobalVariables() {
-    Object.defineProperty(global, Symbol.toStringTag, {
-      value: 'global',
-      writable: false,
-      enumerable: false,
-      configurable: true
-    });
-    global.process = process;
-    const util = NativeModule.require('util');
-
-    function makeGetter(name) {
-      return util.deprecate(function() {
-        return this;
-      }, `'${name}' is deprecated, use 'global'`, 'DEP0016');
-    }
-
-    function makeSetter(name) {
-      return util.deprecate(function(value) {
-        Object.defineProperty(this, name, {
-          configurable: true,
-          writable: true,
-          enumerable: true,
-          value: value
-        });
-      }, `'${name}' is deprecated, use 'global'`, 'DEP0016');
-    }
-
-    Object.defineProperties(global, {
-      GLOBAL: {
-        configurable: true,
-        get: makeGetter('GLOBAL'),
-        set: makeSetter('GLOBAL')
-      },
-      root: {
+  function makeSetter(name) {
+    return util.deprecate(function(value) {
+      Object.defineProperty(this, name, {
         configurable: true,
-        get: makeGetter('root'),
-        set: makeSetter('root')
-      }
-    });
-
-    // This, as side effect, removes `setupBufferJS` from the buffer binding,
-    // and exposes it on `internal/buffer`.
-    NativeModule.require('internal/buffer');
-
-    global.Buffer = NativeModule.require('buffer').Buffer;
-    process.domain = null;
-    process._exiting = false;
-  }
-
-  function setupGlobalTimeouts() {
-    const timers = NativeModule.require('timers');
-    global.clearImmediate = timers.clearImmediate;
-    global.clearInterval = timers.clearInterval;
-    global.clearTimeout = timers.clearTimeout;
-    global.setImmediate = timers.setImmediate;
-    global.setInterval = timers.setInterval;
-    global.setTimeout = timers.setTimeout;
+        writable: true,
+        enumerable: true,
+        value: value
+      });
+    }, `'${name}' is deprecated, use 'global'`, 'DEP0016');
   }
 
-  function setupGlobalConsole() {
-    const originalConsole = global.console;
-    // Setup Node.js global.console.
-    const wrappedConsole = NativeModule.require('console');
-    Object.defineProperty(global, 'console', {
+  Object.defineProperties(global, {
+    GLOBAL: {
       configurable: true,
-      enumerable: false,
-      value: wrappedConsole,
-      writable: true
-    });
-    setupInspector(originalConsole, wrappedConsole);
-  }
-
-  function setupGlobalURL() {
-    const { URL, URLSearchParams } = NativeModule.require('internal/url');
-    Object.defineProperties(global, {
-      URL: {
-        value: URL,
-        writable: true,
-        configurable: true,
-        enumerable: false
-      },
-      URLSearchParams: {
-        value: URLSearchParams,
-        writable: true,
-        configurable: true,
-        enumerable: false
-      }
-    });
+      get: makeGetter('GLOBAL'),
+      set: makeSetter('GLOBAL')
+    },
+    root: {
+      configurable: true,
+      get: makeGetter('root'),
+      set: makeSetter('root')
+    }
+  });
+
+  // This, as side effect, removes `setupBufferJS` from the buffer binding,
+  // and exposes it on `internal/buffer`.
+  NativeModule.require('internal/buffer');
+
+  global.Buffer = NativeModule.require('buffer').Buffer;
+  process.domain = null;
+  process._exiting = false;
+}
+
+function setupGlobalTimeouts() {
+  const timers = NativeModule.require('timers');
+  global.clearImmediate = timers.clearImmediate;
+  global.clearInterval = timers.clearInterval;
+  global.clearTimeout = timers.clearTimeout;
+  global.setImmediate = timers.setImmediate;
+  global.setInterval = timers.setInterval;
+  global.setTimeout = timers.setTimeout;
+}
+
+function setupGlobalConsole() {
+  const consoleFromVM = global.console;
+  const consoleFromNode =
+    NativeModule.require('internal/console/global');
+  // Override global console from the one provided by the VM
+  // to the one implemented by Node.js
+  Object.defineProperty(global, 'console', {
+    configurable: true,
+    enumerable: false,
+    value: consoleFromNode,
+    writable: true
+  });
+  // TODO(joyeecheung): can we skip this if inspector is not active?
+  if (process.config.variables.v8_enable_inspector) {
+    const inspector =
+      NativeModule.require('internal/console/inspector');
+    inspector.addInspectorApis(consoleFromNode, consoleFromVM);
+    // This will be exposed by `require('inspector').console` later.
+    inspector.consoleFromVM = consoleFromVM;
   }
+}
+
+function setupGlobalURL() {
+  const { URL, URLSearchParams } = NativeModule.require('internal/url');
+  Object.defineProperties(global, {
+    URL: {
+      value: URL,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    },
+    URLSearchParams: {
+      value: URLSearchParams,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    }
+  });
+}
 
-  function setupGlobalEncoding() {
-    const { TextEncoder, TextDecoder } = NativeModule.require('util');
-    Object.defineProperties(global, {
-      TextEncoder: {
-        value: TextEncoder,
+function setupGlobalEncoding() {
+  const { TextEncoder, TextDecoder } = NativeModule.require('util');
+  Object.defineProperties(global, {
+    TextEncoder: {
+      value: TextEncoder,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    },
+    TextDecoder: {
+      value: TextDecoder,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    }
+  });
+}
+
+function setupQueueMicrotask() {
+  Object.defineProperty(global, 'queueMicrotask', {
+    get: () => {
+      process.emitWarning('queueMicrotask() is experimental.',
+                          'ExperimentalWarning');
+      const { setupQueueMicrotask } =
+        NativeModule.require('internal/queue_microtask');
+      const queueMicrotask = setupQueueMicrotask(triggerFatalException);
+      Object.defineProperty(global, 'queueMicrotask', {
+        value: queueMicrotask,
         writable: true,
+        enumerable: false,
         configurable: true,
-        enumerable: false
-      },
-      TextDecoder: {
-        value: TextDecoder,
+      });
+      return queueMicrotask;
+    },
+    set: (v) => {
+      Object.defineProperty(global, 'queueMicrotask', {
+        value: v,
         writable: true,
+        enumerable: false,
         configurable: true,
-        enumerable: false
-      }
-    });
-  }
-
-  function setupQueueMicrotask() {
-    Object.defineProperty(global, 'queueMicrotask', {
-      get: () => {
-        process.emitWarning('queueMicrotask() is experimental.',
-                            'ExperimentalWarning');
-        const { setupQueueMicrotask } =
-          NativeModule.require('internal/queue_microtask');
-        const queueMicrotask = setupQueueMicrotask(triggerFatalException);
-        Object.defineProperty(global, 'queueMicrotask', {
-          value: queueMicrotask,
-          writable: true,
-          enumerable: false,
-          configurable: true,
-        });
-        return queueMicrotask;
-      },
-      set: (v) => {
-        Object.defineProperty(global, 'queueMicrotask', {
-          value: v,
-          writable: true,
-          enumerable: false,
-          configurable: true,
-        });
-      },
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  function setupDOMException() {
-    // Registers the constructor with C++.
-    const DOMException = NativeModule.require('internal/domexception');
-    const { registerDOMException } = internalBinding('messaging');
-    registerDOMException(DOMException);
-  }
-
-  function setupInspector(originalConsole, wrappedConsole) {
-    if (!process.config.variables.v8_enable_inspector) {
-      return;
-    }
-    const CJSModule = NativeModule.require('internal/modules/cjs/loader');
-    const { addCommandLineAPI, consoleCall } = process.binding('inspector');
-    // Setup inspector command line API.
-    const { makeRequireFunction } =
-      NativeModule.require('internal/modules/cjs/helpers');
-    const path = NativeModule.require('path');
-    const cwd = tryGetCwd(path);
-
-    const consoleAPIModule = new CJSModule('<inspector console>');
-    consoleAPIModule.paths =
-        CJSModule._nodeModulePaths(cwd).concat(CJSModule.globalPaths);
-    addCommandLineAPI('require', makeRequireFunction(consoleAPIModule));
-    const config = {};
-    for (const key of Object.keys(wrappedConsole)) {
-      if (!originalConsole.hasOwnProperty(key))
-        continue;
-      // If global console has the same method as inspector console,
-      // then wrap these two methods into one. Native wrapper will preserve
-      // the original stack.
-      wrappedConsole[key] = consoleCall.bind(wrappedConsole,
-                                             originalConsole[key],
-                                             wrappedConsole[key],
-                                             config);
-    }
-    for (const key of Object.keys(originalConsole)) {
-      if (wrappedConsole.hasOwnProperty(key))
-        continue;
-      wrappedConsole[key] = originalConsole[key];
-    }
-  }
-
-  function noop() {}
-
-  function setupProcessFatal() {
-    const {
-      executionAsyncId,
-      clearDefaultTriggerAsyncId,
-      clearAsyncIdStack,
-      hasAsyncIdStack,
-      afterHooksExist,
-      emitAfter
-    } = NativeModule.require('internal/async_hooks');
-
-    process._fatalException = (er) => {
-      // It's possible that defaultTriggerAsyncId was set for a constructor
-      // call that threw and was never cleared. So clear it now.
-      clearDefaultTriggerAsyncId();
-
-      if (exceptionHandlerState.captureFn !== null) {
-        exceptionHandlerState.captureFn(er);
-      } else if (!process.emit('uncaughtException', er)) {
-        // If someone handled it, then great.  otherwise, die in C++ land
-        // since that means that we'll exit the process, emit the 'exit' event.
-        try {
-          if (!process._exiting) {
-            process._exiting = true;
-            process.exitCode = 1;
-            process.emit('exit', 1);
-          }
-        } catch {
-          // Nothing to be done about it at this point.
-        }
-        try {
-          const { kExpandStackSymbol } = NativeModule.require('internal/util');
-          if (typeof er[kExpandStackSymbol] === 'function')
-            er[kExpandStackSymbol]();
-        } catch {
-          // Nothing to be done about it at this point.
+      });
+    },
+    enumerable: false,
+    configurable: true,
+  });
+}
+
+function setupDOMException() {
+  // Registers the constructor with C++.
+  const DOMException = NativeModule.require('internal/domexception');
+  const { registerDOMException } = internalBinding('messaging');
+  registerDOMException(DOMException);
+}
+
+function noop() {}
+
+function setupProcessFatal() {
+  const {
+    executionAsyncId,
+    clearDefaultTriggerAsyncId,
+    clearAsyncIdStack,
+    hasAsyncIdStack,
+    afterHooksExist,
+    emitAfter
+  } = NativeModule.require('internal/async_hooks');
+
+  process._fatalException = (er) => {
+    // It's possible that defaultTriggerAsyncId was set for a constructor
+    // call that threw and was never cleared. So clear it now.
+    clearDefaultTriggerAsyncId();
+
+    if (exceptionHandlerState.captureFn !== null) {
+      exceptionHandlerState.captureFn(er);
+    } else if (!process.emit('uncaughtException', er)) {
+      // If someone handled it, then great.  otherwise, die in C++ land
+      // since that means that we'll exit the process, emit the 'exit' event.
+      try {
+        if (!process._exiting) {
+          process._exiting = true;
+          process.exitCode = 1;
+          process.emit('exit', 1);
         }
-        return false;
+      } catch {
+        // Nothing to be done about it at this point.
       }
-
-      // If we handled an error, then make sure any ticks get processed
-      // by ensuring that the next Immediate cycle isn't empty.
-      NativeModule.require('timers').setImmediate(noop);
-
-      // Emit the after() hooks now that the exception has been handled.
-      if (afterHooksExist()) {
-        do {
-          emitAfter(executionAsyncId());
-        } while (hasAsyncIdStack());
-      // Or completely empty the id stack.
-      } else {
-        clearAsyncIdStack();
+      try {
+        const { kExpandStackSymbol } = NativeModule.require('internal/util');
+        if (typeof er[kExpandStackSymbol] === 'function')
+          er[kExpandStackSymbol]();
+      } catch {
+        // Nothing to be done about it at this point.
       }
-
-      return true;
-    };
-  }
-
-  function setupProcessICUVersions() {
-    const icu = internalBinding('config').hasIntl ?
-      internalBinding('icu') : undefined;
-    if (!icu) return;  // no Intl/ICU: nothing to add here.
-    // With no argument, getVersion() returns a comma separated list
-    // of possible types.
-    const versionTypes = icu.getVersion().split(',');
-
-    for (var n = 0; n < versionTypes.length; n++) {
-      const name = versionTypes[n];
-      const version = icu.getVersion(name);
-      Object.defineProperty(process.versions, name, {
-        writable: false,
-        enumerable: true,
-        value: version
-      });
+      return false;
     }
-  }
 
-  function tryGetCwd(path) {
-    try {
-      return process.cwd();
-    } catch {
-      // getcwd(3) can fail if the current working directory has been deleted.
-      // Fall back to the directory name of the (absolute) executable path.
-      // It's not really correct but what are the alternatives?
-      return path.dirname(process.execPath);
+    // If we handled an error, then make sure any ticks get processed
+    // by ensuring that the next Immediate cycle isn't empty.
+    NativeModule.require('timers').setImmediate(noop);
+
+    // Emit the after() hooks now that the exception has been handled.
+    if (afterHooksExist()) {
+      do {
+        emitAfter(executionAsyncId());
+      } while (hasAsyncIdStack());
+    // Or completely empty the id stack.
+    } else {
+      clearAsyncIdStack();
     }
-  }
 
-  function wrapForBreakOnFirstLine(source) {
-    if (!process._breakFirstLine)
-      return source;
-    const fn = `function() {\n\n${source};\n\n}`;
-    return `process.binding('inspector').callAndPauseOnStart(${fn}, {})`;
-  }
+    return true;
+  };
+}
 
-  function evalScript(name, body) {
-    const CJSModule = NativeModule.require('internal/modules/cjs/loader');
-    const path = NativeModule.require('path');
-    const cwd = tryGetCwd(path);
-
-    const module = new CJSModule(name);
-    module.filename = path.join(cwd, name);
-    module.paths = CJSModule._nodeModulePaths(cwd);
-    const script = `global.__filename = ${JSON.stringify(name)};\n` +
-                   'global.exports = exports;\n' +
-                   'global.module = module;\n' +
-                   'global.__dirname = __dirname;\n' +
-                   'global.require = require;\n' +
-                   'return require("vm").runInThisContext(' +
-                   `${JSON.stringify(body)}, { filename: ` +
-                   `${JSON.stringify(name)}, displayErrors: true });\n`;
-    const result = module._compile(script, `${name}-wrapper`);
-    if (process._print_eval) console.log(result);
-    // Handle any nextTicks added in the first tick of the program.
-    process._tickCallback();
-  }
-
-  function checkScriptSyntax(source, filename) {
-    const CJSModule = NativeModule.require('internal/modules/cjs/loader');
-    const vm = NativeModule.require('vm');
-    const {
-      stripShebang, stripBOM
-    } = NativeModule.require('internal/modules/cjs/helpers');
+function setupProcessICUVersions() {
+  const icu = internalBinding('config').hasIntl ?
+    internalBinding('icu') : undefined;
+  if (!icu) return;  // no Intl/ICU: nothing to add here.
+  // With no argument, getVersion() returns a comma separated list
+  // of possible types.
+  const versionTypes = icu.getVersion().split(',');
 
-    // Remove Shebang.
-    source = stripShebang(source);
-    // Remove BOM.
-    source = stripBOM(source);
-    // Wrap it.
-    source = CJSModule.wrap(source);
-    // Compile the script, this will throw if it fails.
-    new vm.Script(source, { displayErrors: true, filename });
+  for (var n = 0; n < versionTypes.length; n++) {
+    const name = versionTypes[n];
+    const version = icu.getVersion(name);
+    Object.defineProperty(process.versions, name, {
+      writable: false,
+      enumerable: true,
+      value: version
+    });
   }
-
-  startup();
-});
+}
+
+function wrapForBreakOnFirstLine(source) {
+  if (!process._breakFirstLine)
+    return source;
+  const fn = `function() {\n\n${source};\n\n}`;
+  return `process.binding('inspector').callAndPauseOnStart(${fn}, {})`;
+}
+
+function evalScript(name, body) {
+  const CJSModule = NativeModule.require('internal/modules/cjs/loader');
+  const path = NativeModule.require('path');
+  const { tryGetCwd } = NativeModule.require('internal/util');
+  const cwd = tryGetCwd(path);
+
+  const module = new CJSModule(name);
+  module.filename = path.join(cwd, name);
+  module.paths = CJSModule._nodeModulePaths(cwd);
+  const script = `global.__filename = ${JSON.stringify(name)};\n` +
+                  'global.exports = exports;\n' +
+                  'global.module = module;\n' +
+                  'global.__dirname = __dirname;\n' +
+                  'global.require = require;\n' +
+                  'return require("vm").runInThisContext(' +
+                  `${JSON.stringify(body)}, { filename: ` +
+                  `${JSON.stringify(name)}, displayErrors: true });\n`;
+  const result = module._compile(script, `${name}-wrapper`);
+  if (process._print_eval) console.log(result);
+  // Handle any nextTicks added in the first tick of the program.
+  process._tickCallback();
+}
+
+function checkScriptSyntax(source, filename) {
+  const CJSModule = NativeModule.require('internal/modules/cjs/loader');
+  const vm = NativeModule.require('vm');
+  const {
+    stripShebang, stripBOM
+  } = NativeModule.require('internal/modules/cjs/helpers');
+
+  // Remove Shebang.
+  source = stripShebang(source);
+  // Remove BOM.
+  source = stripBOM(source);
+  // Wrap it.
+  source = CJSModule.wrap(source);
+  // Compile the script, this will throw if it fails.
+  new vm.Script(source, { displayErrors: true, filename });
+}
+
+startup();
diff --git a/lib/internal/cluster/child.js b/lib/internal/cluster/child.js
index 13a22b0186fc28..272b0d2bd95008 100644
--- a/lib/internal/cluster/child.js
+++ b/lib/internal/cluster/child.js
@@ -1,6 +1,5 @@
 'use strict';
 const assert = require('assert');
-const util = require('util');
 const path = require('path');
 const EventEmitter = require('events');
 const { owner_symbol } = require('internal/async_hooks').symbols;
@@ -71,11 +70,12 @@ cluster._getServer = function(obj, options, cb) {
 
   indexes.set(indexesKey, index);
 
-  const message = util._extend({
+  const message = {
     act: 'queryServer',
     index,
-    data: null
-  }, options);
+    data: null,
+    ...options
+  };
 
   message.address = address;
 
@@ -151,7 +151,7 @@ function rr(message, indexesKey, cb) {
 
   function getsockname(out) {
     if (key)
-      util._extend(out, message.sockname);
+      Object.assign(out, message.sockname);
 
     return 0;
   }
diff --git a/lib/internal/cluster/master.js b/lib/internal/cluster/master.js
index 60083c6393e781..c4f8e2b0efa299 100644
--- a/lib/internal/cluster/master.js
+++ b/lib/internal/cluster/master.js
@@ -1,7 +1,6 @@
 'use strict';
 const assert = require('assert');
 const { fork } = require('child_process');
-const util = require('util');
 const path = require('path');
 const EventEmitter = require('events');
 const RoundRobinHandle = require('internal/cluster/round_robin_handle');
@@ -47,14 +46,14 @@ if (schedulingPolicy === undefined) {
 cluster.schedulingPolicy = schedulingPolicy;
 
 cluster.setupMaster = function(options) {
-  var settings = {
+  const settings = {
     args: process.argv.slice(2),
     exec: process.argv[1],
     execArgv: process.execArgv,
-    silent: false
+    silent: false,
+    ...cluster.settings,
+    ...options
   };
-  util._extend(settings, cluster.settings);
-  util._extend(settings, options || {});
 
   // Tell V8 to write profile data for each process to a separate file.
   // Without --logfile=v8-%p.log, everything ends up in a single, unusable
@@ -101,15 +100,12 @@ function setupSettingsNT(settings) {
 }
 
 function createWorkerProcess(id, env) {
-  const workerEnv = util._extend({}, process.env);
+  const workerEnv = { ...process.env, ...env, NODE_UNIQUE_ID: `${id}` };
   const execArgv = cluster.settings.execArgv.slice();
   const debugArgRegex = /--inspect(?:-brk|-port)?|--debug-port/;
   const nodeOptions = process.env.NODE_OPTIONS ?
     process.env.NODE_OPTIONS : '';
 
-  util._extend(workerEnv, env);
-  workerEnv.NODE_UNIQUE_ID = '' + id;
-
   if (execArgv.some((arg) => arg.match(debugArgRegex)) ||
       nodeOptions.match(debugArgRegex)) {
     let inspectPort;
@@ -315,17 +311,18 @@ function queryServer(worker, message) {
 
   // Set custom server data
   handle.add(worker, (errno, reply, handle) => {
-    reply = util._extend({
-      errno: errno,
-      key: key,
-      ack: message.seq,
-      data: handles.get(key).data
-    }, reply);
+    const { data } = handles.get(key);
 
     if (errno)
       handles.delete(key);  // Gives other workers a chance to retry.
 
-    send(worker, reply, handle);
+    send(worker, {
+      errno,
+      key,
+      ack: message.seq,
+      data,
+      ...reply
+    }, handle);
   });
 }
 
diff --git a/lib/internal/cluster/utils.js b/lib/internal/cluster/utils.js
index 3fc5e408b76a5a..f20206c842be96 100644
--- a/lib/internal/cluster/utils.js
+++ b/lib/internal/cluster/utils.js
@@ -1,5 +1,4 @@
 'use strict';
-const util = require('util');
 
 module.exports = {
   sendHelper,
@@ -14,12 +13,11 @@ function sendHelper(proc, message, handle, cb) {
     return false;
 
   // Mark message as internal. See INTERNAL_PREFIX in lib/child_process.js
-  message = util._extend({ cmd: 'NODE_CLUSTER' }, message);
+  message = { cmd: 'NODE_CLUSTER', ...message, seq };
 
   if (typeof cb === 'function')
     callbacks.set(seq, cb);
 
-  message.seq = seq;
   seq += 1;
   return proc.send(message, handle);
 }
diff --git a/lib/internal/console/constructor.js b/lib/internal/console/constructor.js
index dcfb5f4a70a826..4d566394bfb23c 100644
--- a/lib/internal/console/constructor.js
+++ b/lib/internal/console/constructor.js
@@ -10,6 +10,7 @@ const {
     ERR_CONSOLE_WRITABLE_STREAM,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
+    ERR_INCOMPATIBLE_OPTION_PAIR,
   },
 } = require('internal/errors');
 const { previewEntries } = internalBinding('util');
@@ -54,6 +55,8 @@ const kBindStreamsLazy = Symbol('kBindStreamsLazy');
 const kUseStdout = Symbol('kUseStdout');
 const kUseStderr = Symbol('kUseStderr');
 
+const optionsMap = new WeakMap();
+
 function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
   // We have to test new.target here to see if this function is called
   // with new, because we need to define a custom instanceof to accommodate
@@ -74,7 +77,8 @@ function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
     stdout,
     stderr = stdout,
     ignoreErrors = true,
-    colorMode = 'auto'
+    colorMode = 'auto',
+    inspectOptions
   } = options;
 
   if (!stdout || typeof stdout.write !== 'function') {
@@ -87,6 +91,17 @@ function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
   if (typeof colorMode !== 'boolean' && colorMode !== 'auto')
     throw new ERR_INVALID_ARG_VALUE('colorMode', colorMode);
 
+  if (typeof inspectOptions === 'object' && inspectOptions !== null) {
+    if (inspectOptions.colors !== undefined &&
+        options.colorMode !== undefined) {
+      throw new ERR_INCOMPATIBLE_OPTION_PAIR(
+        'inspectOptions.color', 'colorMode');
+    }
+    optionsMap.set(this, inspectOptions);
+  } else if (inspectOptions !== undefined) {
+    throw new ERR_INVALID_ARG_TYPE('inspectOptions', 'object', inspectOptions);
+  }
+
   // Bind the prototype functions to this Console instance
   var keys = Object.keys(Console.prototype);
   for (var v = 0; v < keys.length; v++) {
@@ -243,6 +258,14 @@ Console.prototype[kGetInspectOptions] = function(stream) {
         stream.getColorDepth() > 2 : true);
   }
 
+  const options = optionsMap.get(this);
+  if (options) {
+    if (options.colors === undefined) {
+      options.colors = color;
+    }
+    return options;
+  }
+
   return color ? kColorInspectOptions : kNoColorInspectOptions;
 };
 
@@ -271,11 +294,12 @@ Console.prototype.warn = function warn(...args) {
 Console.prototype.error = Console.prototype.warn;
 
 Console.prototype.dir = function dir(object, options) {
-  this[kWriteToConsole](kUseStdout, util.inspect(object, {
+  options = {
     customInspect: false,
     ...this[kGetInspectOptions](this._stdout),
     ...options
-  }));
+  };
+  this[kWriteToConsole](kUseStdout, util.inspect(object, options));
 };
 
 Console.prototype.time = function time(label = 'default') {
@@ -411,15 +435,11 @@ Console.prototype.table = function(tabularData, properties) {
   const final = (k, v) => this.log(cliTable(k, v));
 
   const inspect = (v) => {
-    const depth = v !== null &&
-                  typeof v === 'object' &&
-                  !isArray(v) &&
-                  ObjectKeys(v).length > 2 ? -1 : 0;
-    const opt = {
-      depth,
-      maxArrayLength: 3,
-      ...this[kGetInspectOptions](this._stdout)
-    };
+    const opt = { depth: 0, maxArrayLength: 3 };
+    if (v !== null && typeof v === 'object' &&
+      !isArray(v) && ObjectKeys(v).length > 2)
+      opt.depth = -1;
+    Object.assign(opt, this[kGetInspectOptions](this._stdout));
     return util.inspect(v, opt);
   };
   const getIndexArray = (length) => ArrayFrom({ length }, (_, i) => inspect(i));
diff --git a/lib/internal/console/global.js b/lib/internal/console/global.js
new file mode 100644
index 00000000000000..0b480b165bd815
--- /dev/null
+++ b/lib/internal/console/global.js
@@ -0,0 +1,45 @@
+'use strict';
+
+// See https://console.spec.whatwg.org/#console-namespace
+// > For historical web-compatibility reasons, the namespace object
+// > for console must have as its [[Prototype]] an empty object,
+// > created as if by ObjectCreate(%ObjectPrototype%),
+// > instead of %ObjectPrototype%.
+
+// Since in Node.js, the Console constructor has been exposed through
+// require('console'), we need to keep the Console constructor but
+// we cannot actually use `new Console` to construct the global console.
+// Therefore, the console.Console.prototype is not
+// in the global console prototype chain anymore.
+
+const {
+  Console,
+  kBindStreamsLazy,
+  kBindProperties
+} = require('internal/console/constructor');
+
+// This is only here for v11.x conflict resolution.
+const globalConsole = Object.create(Console.prototype);
+
+// Since Console is not on the prototype chain of the global console,
+// the symbol properties on Console.prototype have to be looked up from
+// the global console itself. In addition, we need to make the global
+// console a namespace by binding the console methods directly onto
+// the global console with the receiver fixed.
+for (const prop of Reflect.ownKeys(Console.prototype)) {
+  if (prop === 'constructor') { continue; }
+  const desc = Reflect.getOwnPropertyDescriptor(Console.prototype, prop);
+  if (typeof desc.value === 'function') { // fix the receiver
+    desc.value = desc.value.bind(globalConsole);
+  }
+  Reflect.defineProperty(globalConsole, prop, desc);
+}
+
+globalConsole[kBindStreamsLazy](process);
+globalConsole[kBindProperties](true, 'auto');
+
+// This is a legacy feature - the Console constructor is exposed on
+// the global console instance.
+globalConsole.Console = Console;
+
+module.exports = globalConsole;
diff --git a/lib/internal/console/inspector.js b/lib/internal/console/inspector.js
new file mode 100644
index 00000000000000..d481896e8af4dc
--- /dev/null
+++ b/lib/internal/console/inspector.js
@@ -0,0 +1,53 @@
+'use strict';
+
+const path = require('path');
+const CJSModule = require('internal/modules/cjs/loader');
+const { makeRequireFunction } = require('internal/modules/cjs/helpers');
+const { tryGetCwd } = require('internal/util');
+const { addCommandLineAPI, consoleCall } = internalBinding('inspector');
+
+// Wrap a console implemented by Node.js with features from the VM inspector
+function addInspectorApis(consoleFromNode, consoleFromVM) {
+  // Setup inspector command line API.
+  const cwd = tryGetCwd(path);
+  const consoleAPIModule = new CJSModule('<inspector console>');
+  consoleAPIModule.paths =
+      CJSModule._nodeModulePaths(cwd).concat(CJSModule.globalPaths);
+  addCommandLineAPI('require', makeRequireFunction(consoleAPIModule));
+  const config = {};
+
+  // If global console has the same method as inspector console,
+  // then wrap these two methods into one. Native wrapper will preserve
+  // the original stack.
+  for (const key of Object.keys(consoleFromNode)) {
+    if (!consoleFromVM.hasOwnProperty(key))
+      continue;
+    consoleFromNode[key] = consoleCall.bind(consoleFromNode,
+                                            consoleFromVM[key],
+                                            consoleFromNode[key],
+                                            config);
+  }
+
+  // Add additional console APIs from the inspector
+  for (const key of Object.keys(consoleFromVM)) {
+    if (consoleFromNode.hasOwnProperty(key))
+      continue;
+    consoleFromNode[key] = consoleFromVM[key];
+  }
+}
+
+module.exports = {
+  addInspectorApis
+};
+
+// Stores the console from VM, should be set during bootstrap.
+let consoleFromVM;
+
+Object.defineProperty(module.exports, 'consoleFromVM', {
+  get() {
+    return consoleFromVM;
+  },
+  set(val) {
+    consoleFromVM = val;
+  }
+});
diff --git a/lib/internal/encoding.js b/lib/internal/encoding.js
index ad056fd0bd997f..0084c19b904a82 100644
--- a/lib/internal/encoding.js
+++ b/lib/internal/encoding.js
@@ -21,11 +21,10 @@ const {
   customInspectSymbol: inspect
 } = require('internal/util');
 
-const { isArrayBufferView } = require('internal/util/types');
-
 const {
-  isArrayBuffer
-} = internalBinding('types');
+  isArrayBuffer,
+  isArrayBufferView
+} = require('internal/util/types');
 
 const {
   encodeUtf8String
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index f78e776dfd20fd..700277630054a6 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -702,6 +702,8 @@ E('ERR_HTTP_INVALID_HEADER_VALUE',
 E('ERR_HTTP_INVALID_STATUS_CODE', 'Invalid status code: %s', RangeError);
 E('ERR_HTTP_TRAILER_INVALID',
   'Trailers are invalid with this transfer encoding', Error);
+E('ERR_INCOMPATIBLE_OPTION_PAIR',
+  'Option "%s" can not be used in combination with option "%s"', TypeError);
 E('ERR_INSPECTOR_ALREADY_CONNECTED', '%s is already connected', Error);
 E('ERR_INSPECTOR_CLOSED', 'Session was closed', Error);
 E('ERR_INSPECTOR_NOT_AVAILABLE', 'Inspector is not available', Error);
@@ -945,10 +947,7 @@ E('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s', TypeError);
 E('ERR_UNKNOWN_FILE_EXTENSION', 'Unknown file extension: %s', Error);
 E('ERR_UNKNOWN_MODULE_FORMAT', 'Unknown module format: %s', RangeError);
 E('ERR_UNKNOWN_SIGNAL', 'Unknown signal: %s', TypeError);
-E('ERR_UNKNOWN_STDIN_TYPE', 'Unknown stdin file type', Error);
 
-// This should probably be a `TypeError`.
-E('ERR_UNKNOWN_STREAM_TYPE', 'Unknown stream file type', Error);
 E('ERR_V8BREAKITERATOR',
   'Full ICU data not installed. See https://github.com/nodejs/node/wiki/Intl',
   Error);
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index b6b4d6605d3387..33c510ed5ca702 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -7,7 +7,7 @@ const {
   S_IFMT,
   S_IFREG
 } = internalBinding('constants').fs;
-const binding = process.binding('fs');
+const binding = internalBinding('fs');
 const { Buffer, kMaxLength } = require('buffer');
 const {
   ERR_FS_FILE_TOO_LARGE,
diff --git a/lib/internal/fs/read_file_context.js b/lib/internal/fs/read_file_context.js
index 62d2ed9e7d91ca..d7543ffa5aafed 100644
--- a/lib/internal/fs/read_file_context.js
+++ b/lib/internal/fs/read_file_context.js
@@ -1,7 +1,8 @@
 'use strict';
 
 const { Buffer } = require('buffer');
-const { FSReqCallback, close, read } = process.binding('fs');
+
+const { FSReqCallback, close, read } = internalBinding('fs');
 
 const kReadFileBufferLength = 8 * 1024;
 
diff --git a/lib/internal/fs/streams.js b/lib/internal/fs/streams.js
index 224752b1011c24..dc79a5b79abff1 100644
--- a/lib/internal/fs/streams.js
+++ b/lib/internal/fs/streams.js
@@ -3,7 +3,7 @@
 const {
   FSReqCallback,
   writeBuffers
-} = process.binding('fs');
+} = internalBinding('fs');
 const {
   ERR_INVALID_ARG_TYPE,
   ERR_OUT_OF_RANGE
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 4db4fb536c0b6a..0062bd435530d0 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -171,7 +171,7 @@ function getOptions(options, defaultOptions) {
   }
 
   if (typeof options === 'string') {
-    defaultOptions = util._extend({}, defaultOptions);
+    defaultOptions = { ...defaultOptions };
     defaultOptions.encoding = options;
     options = defaultOptions;
   } else if (typeof options !== 'object') {
diff --git a/lib/internal/fs/watchers.js b/lib/internal/fs/watchers.js
index f542a1eab1d177..e026aa8192c3cf 100644
--- a/lib/internal/fs/watchers.js
+++ b/lib/internal/fs/watchers.js
@@ -4,7 +4,7 @@ const errors = require('internal/errors');
 const {
   kFsStatsFieldsNumber,
   StatWatcher: _StatWatcher
-} = process.binding('fs');
+} = internalBinding('fs');
 const { FSEvent } = internalBinding('fs_event_wrap');
 const { UV_ENOSPC } = internalBinding('uv');
 const { EventEmitter } = require('events');
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index c0ad0ae3529a75..400db84b56f466 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -119,7 +119,7 @@ const {
 } = require('internal/timers');
 const { isArrayBufferView } = require('internal/util/types');
 
-const { FileHandle } = process.binding('fs');
+const { FileHandle } = internalBinding('fs');
 const binding = internalBinding('http2');
 const {
   ShutdownWrap,
diff --git a/lib/internal/inspector_async_hook.js b/lib/internal/inspector_async_hook.js
index 1ad0cbf3a533f2..4a3d31fc2ab7de 100644
--- a/lib/internal/inspector_async_hook.js
+++ b/lib/internal/inspector_async_hook.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const inspector = process.binding('inspector');
+const inspector = internalBinding('inspector');
 
 if (!inspector || !inspector.asyncTaskScheduled) {
   exports.setup = function() {};
diff --git a/lib/internal/modules/cjs/helpers.js b/lib/internal/modules/cjs/helpers.js
index 2c856a99c6b8fd..fcb536c3df3738 100644
--- a/lib/internal/modules/cjs/helpers.js
+++ b/lib/internal/modules/cjs/helpers.js
@@ -108,7 +108,7 @@ if (getOptionValue('--experimental-worker')) {
   builtinLibs.sort();
 }
 
-if (typeof process.binding('inspector').open === 'function') {
+if (typeof internalBinding('inspector').open === 'function') {
   builtinLibs.push('inspector');
   builtinLibs.sort();
 }
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 83ca0699773fa8..73f2aa729284df 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -33,7 +33,7 @@ const { URL } = require('url');
 const {
   internalModuleReadJSON,
   internalModuleStat
-} = process.binding('fs');
+} = internalBinding('fs');
 const { safeGetenv } = internalBinding('util');
 const {
   makeRequireFunction,
@@ -706,7 +706,7 @@ Module.prototype._compile = function(content, filename) {
     // Set breakpoint on module start
     if (filename === resolvedArgv) {
       delete process._breakFirstLine;
-      inspectorWrapper = process.binding('inspector').callAndPauseOnStart;
+      inspectorWrapper = internalBinding('inspector').callAndPauseOnStart;
     }
   }
   var dirname = path.dirname(filename);
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 50aa00a09a03ee..fbb29aef783006 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -73,7 +73,7 @@ class ModuleJob {
     try {
       if (this.isMain && process._breakFirstLine) {
         delete process._breakFirstLine;
-        const initWrapper = process.binding('inspector').callAndPauseOnStart;
+        const initWrapper = internalBinding('inspector').callAndPauseOnStart;
         initWrapper(this.module.instantiate, this.module);
       } else {
         this.module.instantiate();
diff --git a/lib/internal/net.js b/lib/internal/net.js
index d2b097573b918e..e8b67ed0fd397a 100644
--- a/lib/internal/net.js
+++ b/lib/internal/net.js
@@ -1,7 +1,7 @@
 'use strict';
 
 const Buffer = require('buffer').Buffer;
-const { writeBuffer } = process.binding('fs');
+const { writeBuffer } = internalBinding('fs');
 const errors = require('internal/errors');
 
 // IPv4 Segment
diff --git a/lib/internal/per_context.js b/lib/internal/per_context.js
index 87fc8d247eb933..725ba403df2348 100644
--- a/lib/internal/per_context.js
+++ b/lib/internal/per_context.js
@@ -1,9 +1,9 @@
-// arguments: global
+// This file is compiled as if it's wrapped in a function with arguments
+// passed by node::NewContext()
+/* global global */
 
 'use strict';
 
-// node::NewContext calls this script
-
 // https://github.com/nodejs/node/issues/14909
 if (global.Intl) delete global.Intl.v8BreakIterator;
 
diff --git a/lib/internal/process/coverage.js b/lib/internal/process/coverage.js
index 9c9b2b47119ea7..5c5d0c2b6171f3 100644
--- a/lib/internal/process/coverage.js
+++ b/lib/internal/process/coverage.js
@@ -51,7 +51,7 @@ function disableAllAsyncHooks() {
 exports.writeCoverage = writeCoverage;
 
 function setup() {
-  const { Connection } = process.binding('inspector');
+  const { Connection } = internalBinding('inspector');
   if (!Connection) {
     console.warn('inspector not enabled');
     return;
diff --git a/lib/internal/process/stdio.js b/lib/internal/process/stdio.js
index a52bbb7b1d204c..5e9ff6b26097a6 100644
--- a/lib/internal/process/stdio.js
+++ b/lib/internal/process/stdio.js
@@ -1,10 +1,5 @@
 'use strict';
 
-const {
-  ERR_UNKNOWN_STDIN_TYPE,
-  ERR_UNKNOWN_STREAM_TYPE
-} = require('internal/errors').codes;
-
 exports.setupProcessStdio = setupProcessStdio;
 exports.getMainThreadStdio = getMainThreadStdio;
 
@@ -87,8 +82,11 @@ function getMainThreadStdio() {
         break;
 
       default:
-        // Probably an error on in uv_guess_handle()
-        throw new ERR_UNKNOWN_STDIN_TYPE();
+        // Provide a dummy contentless input for e.g. non-console
+        // Windows applications.
+        const { Readable } = require('stream');
+        stdin = new Readable({ read() {} });
+        stdin.push(null);
     }
 
     // For supporting legacy API we put the FD here.
@@ -123,6 +121,12 @@ function getMainThreadStdio() {
     return stdin;
   }
 
+  exports.resetStdioForTesting = function() {
+    stdin = undefined;
+    stdout = undefined;
+    stderr = undefined;
+  };
+
   return {
     getStdout,
     getStderr,
@@ -199,8 +203,14 @@ function createWritableStdioStream(fd) {
       break;
 
     default:
-      // Probably an error on in uv_guess_handle()
-      throw new ERR_UNKNOWN_STREAM_TYPE();
+      // Provide a dummy black-hole output for e.g. non-console
+      // Windows applications.
+      const { Writable } = require('stream');
+      stream = new Writable({
+        write(buf, enc, cb) {
+          cb();
+        }
+      });
   }
 
   // For supporting legacy API we put the FD here.
diff --git a/lib/internal/repl.js b/lib/internal/repl.js
index 4c4e3c8cb4e275..e58752e76eb890 100644
--- a/lib/internal/repl.js
+++ b/lib/internal/repl.js
@@ -24,12 +24,13 @@ function createRepl(env, opts, cb) {
     cb = opts;
     opts = null;
   }
-  opts = util._extend({
+  opts = {
     ignoreUndefined: false,
     terminal: process.stdout.isTTY,
     useGlobal: true,
-    breakEvalOnSigint: true
-  }, opts);
+    breakEvalOnSigint: true,
+    ...opts
+  };
 
   if (parseInt(env.NODE_NO_READLINE)) {
     opts.terminal = false;
diff --git a/lib/internal/url.js b/lib/internal/url.js
index 13063cb8f2f5a6..45ed236511ac9a 100644
--- a/lib/internal/url.js
+++ b/lib/internal/url.js
@@ -193,7 +193,7 @@ class URLSearchParams {
       return ctx.stylize('[Object]', 'special');
 
     var separator = ', ';
-    var innerOpts = util._extend({}, ctx);
+    var innerOpts = { ...ctx };
     if (recurseTimes !== null) {
       innerOpts.depth = recurseTimes - 1;
     }
@@ -382,12 +382,13 @@ Object.defineProperties(URL.prototype, {
     value: function format(options) {
       if (options && typeof options !== 'object')
         throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
-      options = util._extend({
+      options = {
         fragment: true,
         unicode: false,
         search: true,
-        auth: true
-      }, options);
+        auth: true,
+        ...options
+      };
       const ctx = this[context];
       var ret = ctx.scheme;
       if (ctx.host !== null) {
@@ -1202,7 +1203,7 @@ defineIDLClass(URLSearchParamsIteratorPrototype, 'URLSearchParams Iterator', {
     if (typeof recurseTimes === 'number' && recurseTimes < 0)
       return ctx.stylize('[Object]', 'special');
 
-    const innerOpts = util._extend({}, ctx);
+    const innerOpts = { ...ctx };
     if (recurseTimes !== null) {
       innerOpts.depth = recurseTimes - 1;
     }
diff --git a/lib/internal/util.js b/lib/internal/util.js
index 6929085d469676..61b191c47c1d38 100644
--- a/lib/internal/util.js
+++ b/lib/internal/util.js
@@ -14,7 +14,7 @@ const {
 } = internalBinding('util');
 const {
   isNativeError
-} = internalBinding('types');
+} = require('internal/util/types');
 
 const noCrypto = !process.versions.openssl;
 
@@ -387,6 +387,17 @@ function once(callback) {
   };
 }
 
+function tryGetCwd(path) {
+  try {
+    return process.cwd();
+  } catch {
+    // getcwd(3) can fail if the current working directory has been deleted.
+    // Fall back to the directory name of the (absolute) executable path.
+    // It's not really correct but what are the alternatives?
+    return path.dirname(process.execPath);
+  }
+}
+
 module.exports = {
   assertCrypto,
   cachedResult,
@@ -406,6 +417,7 @@ module.exports = {
   once,
   promisify,
   spliceOne,
+  tryGetCwd,
   removeColors,
 
   // Symbol used to customize promisify conversion
diff --git a/lib/internal/util/comparisons.js b/lib/internal/util/comparisons.js
index 1d959f843bcbd3..d0726089063852 100644
--- a/lib/internal/util/comparisons.js
+++ b/lib/internal/util/comparisons.js
@@ -1,9 +1,9 @@
 'use strict';
 
 const { compare } = internalBinding('buffer');
-const { isArrayBufferView } = require('internal/util/types');
 const {
   isAnyArrayBuffer,
+  isArrayBufferView,
   isDate,
   isMap,
   isRegExp,
@@ -15,7 +15,7 @@ const {
   isBooleanObject,
   isBigIntObject,
   isSymbolObject
-} = internalBinding('types');
+} = require('internal/util/types');
 const {
   getOwnNonIndexProperties,
   propertyFilter: {
diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js
index 4697829fba2756..d78f67c502fda5 100644
--- a/lib/internal/util/inspect.js
+++ b/lib/internal/util/inspect.js
@@ -27,8 +27,6 @@ const {
   isStackOverflowError
 } = require('internal/errors');
 
-const types = internalBinding('types');
-Object.assign(types, require('internal/util/types'));
 const {
   isAnyArrayBuffer,
   isArrayBuffer,
@@ -38,6 +36,8 @@ const {
   isExternal,
   isMap,
   isMapIterator,
+  isModuleNamespaceObject,
+  isNativeError,
   isPromise,
   isSet,
   isSetIterator,
@@ -61,7 +61,7 @@ const {
   isFloat64Array,
   isBigInt64Array,
   isBigUint64Array
-} = types;
+} = require('internal/util/types');
 
 const ReflectApply = Reflect.apply;
 
@@ -89,6 +89,7 @@ const setValues = uncurryThis(Set.prototype.values);
 const mapEntries = uncurryThis(Map.prototype.entries);
 const dateGetTime = uncurryThis(Date.prototype.getTime);
 const hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+let hexSlice;
 
 const inspectDefaultOptions = Object.seal({
   showHidden: false,
@@ -385,9 +386,9 @@ function getKeys(value, showHidden) {
     try {
       keys = Object.keys(value);
     } catch (err) {
-      if (types.isNativeError(err) &&
+      if (isNativeError(err) &&
           err.name === 'ReferenceError' &&
-          types.isModuleNamespaceObject(value)) {
+          isModuleNamespaceObject(value)) {
         keys = Object.getOwnPropertyNames(value);
       } else {
         throw err;
@@ -494,7 +495,7 @@ function noPrototypeIterator(ctx, value, recurseTimes) {
 // Note: using `formatValue` directly requires the indentation level to be
 // corrected by setting `ctx.indentationLvL += diff` and then to decrease the
 // value afterwards again.
-function formatValue(ctx, value, recurseTimes) {
+function formatValue(ctx, value, recurseTimes, typedArray) {
   // Primitive types cannot have properties.
   if (typeof value !== 'object' && typeof value !== 'function') {
     return formatPrimitive(ctx.stylize, value, ctx);
@@ -542,10 +543,10 @@ function formatValue(ctx, value, recurseTimes) {
   if (ctx.seen.indexOf(value) !== -1)
     return ctx.stylize('[Circular]', 'special');
 
-  return formatRaw(ctx, value, recurseTimes);
+  return formatRaw(ctx, value, recurseTimes, typedArray);
 }
 
-function formatRaw(ctx, value, recurseTimes) {
+function formatRaw(ctx, value, recurseTimes, typedArray) {
   let keys;
 
   const constructor = getConstructorName(value, ctx);
@@ -678,9 +679,12 @@ function formatRaw(ctx, value, recurseTimes) {
       const arrayType = isArrayBuffer(value) ? 'ArrayBuffer' :
         'SharedArrayBuffer';
       const prefix = getPrefix(constructor, tag, arrayType);
-      if (keys.length === 0)
+      if (typedArray === undefined) {
+        formatter = formatArrayBuffer;
+      } else if (keys.length === 0) {
         return prefix +
               `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength)} }`;
+      }
       braces[0] = `${prefix}{`;
       keys.unshift('byteLength');
     } else if (isDataView(value)) {
@@ -696,7 +700,7 @@ function formatRaw(ctx, value, recurseTimes) {
     } else if (isWeakMap(value)) {
       braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`;
       formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection;
-    } else if (types.isModuleNamespaceObject(value)) {
+    } else if (isModuleNamespaceObject(value)) {
       braces[0] = `[${tag}] {`;
       formatter = formatNamespaceObject;
       skip = true;
@@ -883,7 +887,7 @@ function formatNamespaceObject(ctx, value, recurseTimes, keys) {
       output[i] = formatProperty(ctx, value, recurseTimes, keys[i],
                                  kObjectType);
     } catch (err) {
-      if (!(types.isNativeError(err) && err.name === 'ReferenceError')) {
+      if (!(isNativeError(err) && err.name === 'ReferenceError')) {
         throw err;
       }
       // Use the existing functionality. This makes sure the indentation and
@@ -941,6 +945,18 @@ function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) {
   return output;
 }
 
+function formatArrayBuffer(ctx, value) {
+  const buffer = new Uint8Array(value);
+  if (hexSlice === undefined)
+    hexSlice = uncurryThis(require('buffer').Buffer.prototype.hexSlice);
+  let str = hexSlice(buffer, 0, Math.min(ctx.maxArrayLength, buffer.length))
+    .replace(/(.{2})/g, '$1 ').trim();
+  const remaining = buffer.length - ctx.maxArrayLength;
+  if (remaining > 0)
+    str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+  return [`${ctx.stylize('[Uint8Contents]', 'special')}: <${str}>`];
+}
+
 function formatArray(ctx, value, recurseTimes) {
   const valLen = value.length;
   const len = Math.min(Math.max(0, ctx.maxArrayLength), valLen);
@@ -981,7 +997,7 @@ function formatTypedArray(ctx, value, recurseTimes) {
       'byteOffset',
       'buffer'
     ]) {
-      const str = formatValue(ctx, value[key], recurseTimes);
+      const str = formatValue(ctx, value[key], recurseTimes, true);
       output.push(`[${key}]: ${str}`);
     }
     ctx.indentationLvl -= 2;
@@ -1220,5 +1236,7 @@ function reduceToSingleString(ctx, output, base, braces) {
 }
 
 module.exports = {
-  inspect
+  inspect,
+  formatProperty,
+  kObjectType
 };
diff --git a/lib/internal/util/types.js b/lib/internal/util/types.js
index 182625a9716c72..865818c661b78d 100644
--- a/lib/internal/util/types.js
+++ b/lib/internal/util/types.js
@@ -70,6 +70,7 @@ function isBigUint64Array(value) {
 }
 
 module.exports = {
+  ...internalBinding('types'),
   isArrayBufferView,
   isTypedArray,
   isUint8Array,
diff --git a/lib/net.js b/lib/net.js
index eb5fae76fa17de..936dee088beb3f 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -245,7 +245,7 @@ function Socket(options) {
   if (typeof options === 'number')
     options = { fd: options }; // Legacy interface.
   else
-    options = util._extend({}, options);
+    options = { ...options };
 
   options.readable = options.readable || false;
   options.writable = options.writable || false;
diff --git a/lib/tty.js b/lib/tty.js
index 62945a78eb1f0f..6efaac6e43215f 100644
--- a/lib/tty.js
+++ b/lib/tty.js
@@ -21,7 +21,7 @@
 
 'use strict';
 
-const { inherits, _extend } = require('util');
+const { inherits } = require('util');
 const net = require('net');
 const { TTY, isTTY } = internalBinding('tty_wrap');
 const errors = require('internal/errors');
@@ -47,14 +47,13 @@ function ReadStream(fd, options) {
     throw new ERR_TTY_INIT_FAILED(ctx);
   }
 
-  options = _extend({
+  net.Socket.call(this, {
     highWaterMark: 0,
     readable: true,
     writable: false,
-    handle: tty
-  }, options);
-
-  net.Socket.call(this, options);
+    handle: tty,
+    ...options
+  });
 
   this.isRaw = false;
   this.isTTY = true;
diff --git a/lib/util.js b/lib/util.js
index 06ce842934505a..624f4dfb7d032b 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -31,13 +31,7 @@ const {
 const { validateNumber } = require('internal/validators');
 const { TextDecoder, TextEncoder } = require('internal/encoding');
 const { isBuffer } = require('buffer').Buffer;
-
-const types = internalBinding('types');
-Object.assign(types, require('internal/util/types'));
-const {
-  isRegExp,
-  isDate,
-} = types;
+const types = require('internal/util/types');
 
 const {
   deprecate,
@@ -433,9 +427,9 @@ module.exports = exports = {
   isString,
   isSymbol,
   isUndefined,
-  isRegExp,
+  isRegExp: types.isRegExp,
   isObject,
-  isDate,
+  isDate: types.isDate,
   isError(e) {
     return objectToString(e) === '[object Error]' || e instanceof Error;
   },
diff --git a/lib/zlib.js b/lib/zlib.js
index 49dcd4e92ecde4..2a840fe036abad 100644
--- a/lib/zlib.js
+++ b/lib/zlib.js
@@ -31,7 +31,6 @@ const {
 const Transform = require('_stream_transform');
 const {
   deprecate,
-  _extend,
   inherits,
   types: {
     isAnyArrayBuffer,
@@ -240,7 +239,7 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
       Z_NO_FLUSH, Z_BLOCK, finishFlush);
 
     if (opts.encoding || opts.objectMode || opts.writableObjectMode) {
-      opts = _extend({}, opts);
+      opts = { ...opts };
       opts.encoding = null;
       opts.objectMode = false;
       opts.writableObjectMode = false;
diff --git a/node.gyp b/node.gyp
index 450fad26c50e91..2caee4f85fac20 100644
--- a/node.gyp
+++ b/node.gyp
@@ -96,6 +96,9 @@
       'lib/internal/cluster/shared_handle.js',
       'lib/internal/cluster/utils.js',
       'lib/internal/cluster/worker.js',
+      'lib/internal/console/constructor.js',
+      'lib/internal/console/global.js',
+      'lib/internal/console/inspector.js',
       'lib/internal/crypto/certificate.js',
       'lib/internal/crypto/cipher.js',
       'lib/internal/crypto/diffiehellman.js',
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
index 8f0332cc616341..3f05f02bb50ddb 100644
--- a/src/inspector_js_api.cc
+++ b/src/inspector_js_api.cc
@@ -315,5 +315,5 @@ void Initialize(Local<Object> target, Local<Value> unused,
 }  // namespace inspector
 }  // namespace node
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(inspector,
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(inspector,
                                   node::inspector::Initialize);
diff --git a/src/node.cc b/src/node.cc
index e8710bef22d3d7..583099b31f970a 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -110,7 +110,6 @@ typedef int mode_t;
 
 namespace node {
 
-using errors::TryCatchScope;
 using native_module::NativeModuleLoader;
 using options_parser::kAllowedInEnvironment;
 using options_parser::kDisallowedInEnvironment;
@@ -136,7 +135,6 @@ using v8::MicrotasksPolicy;
 using v8::NewStringType;
 using v8::None;
 using v8::Nothing;
-using v8::Null;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Script;
@@ -704,41 +702,6 @@ Local<Value> MakeCallback(Isolate* isolate,
           .FromMaybe(Local<Value>()));
 }
 
-// Executes a str within the current v8 context.
-static MaybeLocal<Value> ExecuteString(Environment* env,
-                                       Local<String> source,
-                                       Local<String> filename) {
-  EscapableHandleScope scope(env->isolate());
-  TryCatchScope try_catch(env);
-
-  // try_catch must be nonverbose to disable FatalException() handler,
-  // we will handle exceptions ourself.
-  try_catch.SetVerbose(false);
-
-  ScriptOrigin origin(filename);
-
-  MaybeLocal<Script> script =
-      Script::Compile(env->context(), source, &origin);
-  if (script.IsEmpty()) {
-    ReportException(env, try_catch);
-    env->Exit(3);
-    return MaybeLocal<Value>();
-  }
-
-  MaybeLocal<Value> result = script.ToLocalChecked()->Run(env->context());
-  if (result.IsEmpty()) {
-    if (try_catch.HasTerminated()) {
-      env->isolate()->CancelTerminateExecution();
-      return MaybeLocal<Value>();
-    }
-    ReportException(env, try_catch);
-    env->Exit(4);
-    return MaybeLocal<Value>();
-  }
-
-  return scope.Escape(result.ToLocalChecked());
-}
-
 static void WaitForInspectorDisconnect(Environment* env) {
 #if HAVE_INSPECTOR
   if (env->inspector_agent()->IsActive()) {
@@ -1223,39 +1186,13 @@ void SignalExit(int signo) {
   raise(signo);
 }
 
-
-static MaybeLocal<Function> GetBootstrapper(
+static MaybeLocal<Value> ExecuteBootstrapper(
     Environment* env,
-    Local<String> source,
-    Local<String> script_name) {
-  EscapableHandleScope scope(env->isolate());
-
-  TryCatchScope try_catch(env);
-
-  // Disable verbose mode to stop FatalException() handler from trying
-  // to handle the exception. Errors this early in the start-up phase
-  // are not safe to ignore.
-  try_catch.SetVerbose(false);
-
-  // Execute the bootstrapper javascript file
-  MaybeLocal<Value> bootstrapper_v = ExecuteString(env, source, script_name);
-  if (bootstrapper_v.IsEmpty())  // This happens when execution was interrupted.
-    return MaybeLocal<Function>();
-
-  if (try_catch.HasCaught())  {
-    ReportException(env, try_catch);
-    exit(10);
-  }
-
-  CHECK(bootstrapper_v.ToLocalChecked()->IsFunction());
-  return scope.Escape(bootstrapper_v.ToLocalChecked().As<Function>());
-}
-
-static bool ExecuteBootstrapper(Environment* env, Local<Function> bootstrapper,
-                                int argc, Local<Value> argv[],
-                                Local<Value>* out) {
-  bool ret = bootstrapper->Call(
-      env->context(), Null(env->isolate()), argc, argv).ToLocal(out);
+    const char* id,
+    std::vector<Local<String>>* parameters,
+    std::vector<Local<Value>>* arguments) {
+  MaybeLocal<Value> ret = per_process_loader.CompileAndCall(
+      env->context(), id, parameters, arguments, env);
 
   // If there was an error during bootstrap then it was either handled by the
   // FatalException handler or it's unrecoverable (e.g. max call stack
@@ -1264,123 +1201,86 @@ static bool ExecuteBootstrapper(Environment* env, Local<Function> bootstrapper,
   // There are only two ways to have a stack size > 1: 1) the user manually
   // called MakeCallback or 2) user awaited during bootstrap, which triggered
   // _tickCallback().
-  if (!ret) {
+  if (ret.IsEmpty()) {
     env->async_hooks()->clear_async_id_stack();
   }
 
   return ret;
 }
 
-
 void LoadEnvironment(Environment* env) {
   HandleScope handle_scope(env->isolate());
-
-  TryCatchScope try_catch(env);
-  // Disable verbose mode to stop FatalException() handler from trying
-  // to handle the exception. Errors this early in the start-up phase
-  // are not safe to ignore.
-  try_catch.SetVerbose(false);
-
-  // The bootstrapper scripts are lib/internal/bootstrap/loaders.js and
-  // lib/internal/bootstrap/node.js, each included as a static C string
-  // generated in node_javascript.cc by node_js2c.
-
-  // TODO(joyeecheung): use NativeModuleLoader::Compile
-  // We duplicate the string literals here since once we refactor the bootstrap
-  // compilation out to NativeModuleLoader none of this is going to matter
   Isolate* isolate = env->isolate();
-  Local<String> loaders_name =
-      FIXED_ONE_BYTE_STRING(isolate, "internal/bootstrap/loaders.js");
-  Local<String> loaders_source =
-      per_process_loader.GetSource(isolate, "internal/bootstrap/loaders");
-  MaybeLocal<Function> loaders_bootstrapper =
-      GetBootstrapper(env, loaders_source, loaders_name);
-  Local<String> node_name =
-      FIXED_ONE_BYTE_STRING(isolate, "internal/bootstrap/node.js");
-  Local<String> node_source =
-      per_process_loader.GetSource(isolate, "internal/bootstrap/node");
-  MaybeLocal<Function> node_bootstrapper =
-      GetBootstrapper(env, node_source, node_name);
-
-  if (loaders_bootstrapper.IsEmpty() || node_bootstrapper.IsEmpty()) {
-    // Execution was interrupted.
-    return;
-  }
+  Local<Context> context = env->context();
 
   // Add a reference to the global object
-  Local<Object> global = env->context()->Global();
+  Local<Object> global = context->Global();
 
 #if defined HAVE_DTRACE || defined HAVE_ETW
   InitDTrace(env, global);
 #endif
 
-  // Enable handling of uncaught exceptions
-  // (FatalException(), break on uncaught exception in debugger)
-  //
-  // This is not strictly necessary since it's almost impossible
-  // to attach the debugger fast enough to break on exception
-  // thrown during process startup.
-  try_catch.SetVerbose(true);
-
-  env->SetMethod(env->process_object(), "_rawDebug", RawDebug);
+  Local<Object> process = env->process_object();
 
+  // Setting global properties for the bootstrappers to use:
+  // - global
+  // - process._rawDebug
   // Expose the global object as a property on itself
   // (Allows you to set stuff on `global` from anywhere in JavaScript.)
-  global->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(env->isolate(), "global"),
-              global).FromJust();
+  global->Set(context, FIXED_ONE_BYTE_STRING(env->isolate(), "global"), global)
+      .FromJust();
+  env->SetMethod(process, "_rawDebug", RawDebug);
 
   // Create binding loaders
-  Local<Function> get_binding_fn = env->NewFunctionTemplate(binding::GetBinding)
-                                       ->GetFunction(env->context())
-                                       .ToLocalChecked();
-
-  Local<Function> get_linked_binding_fn =
+  std::vector<Local<String>> loaders_params = {
+      env->process_string(),
+      FIXED_ONE_BYTE_STRING(isolate, "getBinding"),
+      FIXED_ONE_BYTE_STRING(isolate, "getLinkedBinding"),
+      FIXED_ONE_BYTE_STRING(isolate, "getInternalBinding"),
+      FIXED_ONE_BYTE_STRING(isolate, "debugBreak")};
+  std::vector<Local<Value>> loaders_args = {
+      process,
+      env->NewFunctionTemplate(binding::GetBinding)
+          ->GetFunction(context)
+          .ToLocalChecked(),
       env->NewFunctionTemplate(binding::GetLinkedBinding)
-          ->GetFunction(env->context())
-          .ToLocalChecked();
-
-  Local<Function> get_internal_binding_fn =
+          ->GetFunction(context)
+          .ToLocalChecked(),
       env->NewFunctionTemplate(binding::GetInternalBinding)
-          ->GetFunction(env->context())
-          .ToLocalChecked();
-
-  Local<Value> loaders_bootstrapper_args[] = {
-    env->process_object(),
-    get_binding_fn,
-    get_linked_binding_fn,
-    get_internal_binding_fn,
-    Boolean::New(env->isolate(),
-                 env->options()->debug_options().break_node_first_line)
-  };
+          ->GetFunction(context)
+          .ToLocalChecked(),
+      Boolean::New(isolate,
+                   env->options()->debug_options().break_node_first_line)};
 
+  MaybeLocal<Value> loader_exports;
   // Bootstrap internal loaders
-  Local<Value> bootstrapped_loaders;
-  if (!ExecuteBootstrapper(env, loaders_bootstrapper.ToLocalChecked(),
-                           arraysize(loaders_bootstrapper_args),
-                           loaders_bootstrapper_args,
-                           &bootstrapped_loaders)) {
+  loader_exports = ExecuteBootstrapper(
+      env, "internal/bootstrap/loaders", &loaders_params, &loaders_args);
+  if (loader_exports.IsEmpty()) {
     return;
   }
 
-  Local<Function> trigger_fatal_exception =
-      env->NewFunctionTemplate(FatalException)->GetFunction(env->context())
-          .ToLocalChecked();
-
   // Bootstrap Node.js
   Local<Object> bootstrapper = Object::New(env->isolate());
   SetupBootstrapObject(env, bootstrapper);
-  Local<Value> bootstrapped_node;
-  Local<Value> node_bootstrapper_args[] = {
-    env->process_object(),
-    bootstrapper,
-    bootstrapped_loaders,
-    trigger_fatal_exception,
-  };
-  if (!ExecuteBootstrapper(env, node_bootstrapper.ToLocalChecked(),
-                           arraysize(node_bootstrapper_args),
-                           node_bootstrapper_args,
-                           &bootstrapped_node)) {
+
+  // process, bootstrappers, loaderExports, triggerFatalException
+  std::vector<Local<String>> node_params = {
+      env->process_string(),
+      FIXED_ONE_BYTE_STRING(isolate, "bootstrappers"),
+      FIXED_ONE_BYTE_STRING(isolate, "loaderExports"),
+      FIXED_ONE_BYTE_STRING(isolate, "triggerFatalException")};
+  std::vector<Local<Value>> node_args = {
+      process,
+      bootstrapper,
+      loader_exports.ToLocalChecked(),
+      env->NewFunctionTemplate(FatalException)
+          ->GetFunction(context)
+          .ToLocalChecked()};
+
+  if (ExecuteBootstrapper(
+          env, "internal/bootstrap/node", &node_params, &node_args)
+          .IsEmpty()) {
     return;
   }
 }
@@ -2238,5 +2138,5 @@ int Start(int argc, char** argv) {
 #if !HAVE_INSPECTOR
 void Initialize() {}
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(inspector, Initialize)
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(inspector, Initialize)
 #endif  // !HAVE_INSPECTOR
diff --git a/src/node_config.cc b/src/node_config.cc
index a8ffac2cc158a4..1ba1fe9d277af5 100644
--- a/src/node_config.cc
+++ b/src/node_config.cc
@@ -77,9 +77,6 @@ static void Initialize(Local<Object> target,
   if (env->options()->experimental_repl_await)
     READONLY_TRUE_PROPERTY(target, "experimentalREPLAwait");
 
-  if (env->options()->pending_deprecation)
-    READONLY_TRUE_PROPERTY(target, "pendingDeprecation");
-
   if (env->options()->expose_internals)
     READONLY_TRUE_PROPERTY(target, "exposeInternals");
 
diff --git a/src/node_file.cc b/src/node_file.cc
index ae34d90a2d026a..b66c0fe6d20915 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -2236,4 +2236,4 @@ void Initialize(Local<Object> target,
 
 }  // end namespace node
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(fs, node::fs::Initialize)
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(fs, node::fs::Initialize)
diff --git a/test/message/eval_messages.out b/test/message/eval_messages.out
index c26c63d2b0d016..dfa8ec0f7d400b 100644
--- a/test/message/eval_messages.out
+++ b/test/message/eval_messages.out
@@ -12,7 +12,7 @@ SyntaxError: Strict mode code may not include a with statement
     at executeUserCode (internal/bootstrap/node.js:*:*)
     at startExecution (internal/bootstrap/node.js:*:*)
     at startup (internal/bootstrap/node.js:*:*)
-    at bootstrapNodeJSCore (internal/bootstrap/node.js:*:*)
+    at internal/bootstrap/node.js:*:*
 42
 42
 [eval]:1
@@ -29,7 +29,7 @@ Error: hello
     at executeUserCode (internal/bootstrap/node.js:*:*)
     at startExecution (internal/bootstrap/node.js:*:*)
     at startup (internal/bootstrap/node.js:*:*)
-    at bootstrapNodeJSCore (internal/bootstrap/node.js:*:*)
+    at internal/bootstrap/node.js:*:*
 
 [eval]:1
 throw new Error("hello")
@@ -45,7 +45,7 @@ Error: hello
     at executeUserCode (internal/bootstrap/node.js:*:*)
     at startExecution (internal/bootstrap/node.js:*:*)
     at startup (internal/bootstrap/node.js:*:*)
-    at bootstrapNodeJSCore (internal/bootstrap/node.js:*:*)
+    at internal/bootstrap/node.js:*:*
 100
 [eval]:1
 var x = 100; y = x;
@@ -61,7 +61,7 @@ ReferenceError: y is not defined
     at executeUserCode (internal/bootstrap/node.js:*:*)
     at startExecution (internal/bootstrap/node.js:*:*)
     at startup (internal/bootstrap/node.js:*:*)
-    at bootstrapNodeJSCore (internal/bootstrap/node.js:*:*)
+    at internal/bootstrap/node.js:*:*
 
 [eval]:1
 var ______________________________________________; throw 10
diff --git a/test/message/events_unhandled_error_nexttick.out b/test/message/events_unhandled_error_nexttick.out
index d043839fe2c40c..1c0ed6df9341fe 100644
--- a/test/message/events_unhandled_error_nexttick.out
+++ b/test/message/events_unhandled_error_nexttick.out
@@ -21,4 +21,4 @@ Emitted 'error' event at:
     at executeUserCode (internal/bootstrap/node.js:*:*)
     at startExecution (internal/bootstrap/node.js:*:*)
     at startup (internal/bootstrap/node.js:*:*)
-    at bootstrapNodeJSCore (internal/bootstrap/node.js:*:*)
+    at internal/bootstrap/node.js:*:*
diff --git a/test/message/nexttick_throw.out b/test/message/nexttick_throw.out
index 5f3c85f874c599..2bf69e8146130a 100644
--- a/test/message/nexttick_throw.out
+++ b/test/message/nexttick_throw.out
@@ -10,4 +10,4 @@ ReferenceError: undefined_reference_error_maker is not defined
     at executeUserCode (internal/bootstrap/node.js:*:*)
     at startExecution (internal/bootstrap/node.js:*:*)
     at startup (internal/bootstrap/node.js:*:*)
-    at bootstrapNodeJSCore (internal/bootstrap/node.js:*:*)
+    at internal/bootstrap/node.js:*:*
diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js
index 172a55959ec97b..db00ed2836327f 100644
--- a/test/parallel/test-assert.js
+++ b/test/parallel/test-assert.js
@@ -1,3 +1,4 @@
+// Flags: --expose-internals
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
@@ -24,6 +25,7 @@
 const common = require('../common');
 const assert = require('assert');
 const { inspect } = require('util');
+const { internalBinding } = require('internal/test/binding');
 const a = assert;
 
 // Disable colored output to prevent color codes from breaking assertion
@@ -656,7 +658,7 @@ common.expectsError(
 
 {
   // Test caching.
-  const fs = process.binding('fs');
+  const fs = internalBinding('fs');
   const tmp = fs.close;
   fs.close = common.mustCall(tmp, 1);
   function throwErr() {
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index ebc31ba9c2848e..eb5afea961ba5d 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -9,7 +9,7 @@ const common = require('../common');
 const assert = require('assert');
 
 const isMainThread = common.isMainThread;
-const kMaxModuleCount = isMainThread ? 57 : 78;
+const kMaxModuleCount = isMainThread ? 59 : 80;
 
 assert(list.length <= kMaxModuleCount,
        `Total length: ${list.length}\n` + list.join('\n')
diff --git a/test/parallel/test-buffer-inspect.js b/test/parallel/test-buffer-inspect.js
index 9f91de700c7878..9230d7b089dd16 100644
--- a/test/parallel/test-buffer-inspect.js
+++ b/test/parallel/test-buffer-inspect.js
@@ -55,4 +55,4 @@ assert.strictEqual(util.inspect(b), expected);
 assert.strictEqual(util.inspect(s), expected);
 
 b.inspect = undefined;
-assert.strictEqual(util.inspect(b), expected);
+assert.strictEqual(util.inspect(b), '<Buffer 31 32, inspect: undefined>');
diff --git a/test/parallel/test-console-instance.js b/test/parallel/test-console-instance.js
index 127e59e6e5b981..1c8b54ef4ca725 100644
--- a/test/parallel/test-console-instance.js
+++ b/test/parallel/test-console-instance.js
@@ -128,3 +128,21 @@ out.write = err.write = (d) => {};
   assert.throws(() => c2.warn('foo'), /^Error: err$/);
   assert.throws(() => c2.dir('foo'), /^Error: out$/);
 }
+
+// Console constructor throws if inspectOptions is not an object.
+[null, true, false, 'foo', 5, Symbol()].forEach((inspectOptions) => {
+  assert.throws(
+    () => {
+      new Console({
+        stdout: out,
+        stderr: err,
+        inspectOptions
+      });
+    },
+    {
+      message: 'The "inspectOptions" argument must be of type object.' +
+               ` Received type ${typeof inspectOptions}`,
+      code: 'ERR_INVALID_ARG_TYPE'
+    }
+  );
+});
diff --git a/test/parallel/test-console-tty-colors.js b/test/parallel/test-console-tty-colors.js
index 4f4064970ad6b7..85a0e61e381170 100644
--- a/test/parallel/test-console-tty-colors.js
+++ b/test/parallel/test-console-tty-colors.js
@@ -5,7 +5,7 @@ const util = require('util');
 const { Writable } = require('stream');
 const { Console } = require('console');
 
-function check(isTTY, colorMode, expectedColorMode) {
+function check(isTTY, colorMode, expectedColorMode, inspectOptions) {
   const items = [
     1,
     { a: 2 },
@@ -18,7 +18,8 @@ function check(isTTY, colorMode, expectedColorMode) {
     write: common.mustCall((chunk, enc, cb) => {
       assert.strictEqual(chunk.trim(),
                          util.inspect(items[i++], {
-                           colors: expectedColorMode
+                           colors: expectedColorMode,
+                           ...inspectOptions
                          }));
       cb();
     }, items.length),
@@ -31,7 +32,8 @@ function check(isTTY, colorMode, expectedColorMode) {
   const testConsole = new Console({
     stdout: stream,
     ignoreErrors: false,
-    colorMode
+    colorMode,
+    inspectOptions
   });
   for (const item of items) {
     testConsole.log(item);
@@ -40,12 +42,15 @@ function check(isTTY, colorMode, expectedColorMode) {
 
 check(true, 'auto', true);
 check(false, 'auto', false);
+check(false, undefined, true, { colors: true, compact: false });
+check(true, 'auto', true, { compact: false });
+check(true, undefined, false, { colors: false });
 check(true, true, true);
 check(false, true, true);
 check(true, false, false);
 check(false, false, false);
 
-// check invalid colorMode type
+// Check invalid options.
 {
   const stream = new Writable({
     write: common.mustNotCall()
@@ -67,4 +72,24 @@ check(false, false, false);
       }
     );
   });
+
+  [true, false, 'auto'].forEach((colorMode) => {
+    assert.throws(
+      () => {
+        new Console({
+          stdout: stream,
+          ignoreErrors: false,
+          colorMode: colorMode,
+          inspectOptions: {
+            colors: false
+          }
+        });
+      },
+      {
+        message: 'Option "inspectOptions.color" can not be used in ' +
+                 'combination with option "colorMode"',
+        code: 'ERR_INCOMPATIBLE_OPTION_PAIR'
+      }
+    );
+  });
 }
diff --git a/test/parallel/test-dummy-stdio.js b/test/parallel/test-dummy-stdio.js
new file mode 100644
index 00000000000000..165c2c2c575ff5
--- /dev/null
+++ b/test/parallel/test-dummy-stdio.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const child_process = require('child_process');
+
+if (common.isWindows)
+  common.skip('fs.closeSync(n) does not close stdio on Windows');
+
+function runTest(fd, streamName, testOutputStream, expectedName) {
+  const result = child_process.spawnSync(process.execPath, [
+    '--expose-internals',
+    '-e', `
+    require('internal/process/stdio').resetStdioForTesting();
+    fs.closeSync(${fd});
+    const ctorName = process.${streamName}.constructor.name;
+    process.${testOutputStream}.write(ctorName);
+    `]);
+  assert.strictEqual(result[testOutputStream].toString(), expectedName,
+                     `stdout:\n${result.stdout}\nstderr:\n${result.stderr}\n` +
+                     `while running test with fd = ${fd}`);
+  if (testOutputStream !== 'stderr')
+    assert.strictEqual(result.stderr.toString(), '');
+}
+
+runTest(0, 'stdin', 'stdout', 'Readable');
+runTest(1, 'stdout', 'stderr', 'Writable');
+runTest(2, 'stderr', 'stdout', 'Writable');
diff --git a/test/parallel/test-fs-filehandle.js b/test/parallel/test-fs-filehandle.js
index 0d1dffa2b5ff78..a56b39f7c92526 100644
--- a/test/parallel/test-fs-filehandle.js
+++ b/test/parallel/test-fs-filehandle.js
@@ -4,7 +4,8 @@
 const common = require('../common');
 const assert = require('assert');
 const path = require('path');
-const fs = process.binding('fs');
+const { internalBinding } = require('internal/test/binding');
+const fs = internalBinding('fs');
 const { stringToFlags } = require('internal/fs/utils');
 
 // Verifies that the FileHandle object is garbage collected and that a
@@ -18,11 +19,16 @@ let fdnum;
   assert.strictEqual(ctx.errno, undefined);
 }
 
-common.expectWarning(
-  'Warning',
-  `Closing file descriptor ${fdnum} on garbage collection`,
-  common.noWarnCode
-);
+common.expectWarning({
+  'internal/test/binding': [
+    'These APIs are for internal testing only. Do not use them.',
+    common.noWarnCode
+  ],
+  'Warning': [
+    `Closing file descriptor ${fdnum} on garbage collection`,
+    common.noWarnCode
+  ]
+});
 
 global.gc();
 
diff --git a/test/parallel/test-fs-sync-fd-leak.js b/test/parallel/test-fs-sync-fd-leak.js
index 30016e02845298..52f6f38f9c0ea0 100644
--- a/test/parallel/test-fs-sync-fd-leak.js
+++ b/test/parallel/test-fs-sync-fd-leak.js
@@ -42,7 +42,7 @@ fs.writeSync = function() {
   throw new Error('BAM');
 };
 
-process.binding('fs').fstat = function(fd, bigint, _, ctx) {
+internalBinding('fs').fstat = function(fd, bigint, _, ctx) {
   ctx.errno = UV_EBADF;
   ctx.syscall = 'fstat';
 };
diff --git a/test/parallel/test-module-binding.js b/test/parallel/test-module-binding.js
index a3ebaf9e7266d2..07c4965f2204f3 100644
--- a/test/parallel/test-module-binding.js
+++ b/test/parallel/test-module-binding.js
@@ -1,7 +1,9 @@
+// Flags: --expose-internals
 'use strict';
 require('../common');
 const fixtures = require('../common/fixtures');
-const { internalModuleReadJSON } = process.binding('fs');
+const { internalBinding } = require('internal/test/binding');
+const { internalModuleReadJSON } = internalBinding('fs');
 const { readFileSync } = require('fs');
 const { strictEqual } = require('assert');
 
diff --git a/test/parallel/test-pending-deprecation.js b/test/parallel/test-pending-deprecation.js
index bb11d84bcc0aec..6cabf9ddc693f7 100644
--- a/test/parallel/test-pending-deprecation.js
+++ b/test/parallel/test-pending-deprecation.js
@@ -1,36 +1,45 @@
 'use strict';
 
-// Tests that --pending-deprecation and NODE_PENDING_DEPRECATION both
-// set the process.binding('config').pendingDeprecation flag that is
-// used to determine if pending deprecation messages should be shown.
-// The test is performed by launching two child processes that run
+// Flags: --expose-internals
+// Tests that --pending-deprecation and NODE_PENDING_DEPRECATION both set the
+// `require('internal/options').getOptionValue('--pending-deprecation')`
+// flag that is used to determine if pending deprecation messages should be
+// shown. The test is performed by launching two child processes that run
 // this same test script with different arguments. If those exit with
 // code 0, then the test passes. If they don't, it fails.
 
+// TODO(joyeecheung): instead of testing internals, test the actual features
+// pending deprecations.
+
 const common = require('../common');
 
 const assert = require('assert');
-const config = process.binding('config');
 const fork = require('child_process').fork;
+const { getOptionValue } = require('internal/options');
 
 function message(name) {
-  return `${name} did not set the process.binding('config').` +
-         'pendingDeprecation flag.';
+  return `${name} did not affect getOptionValue('--pending-deprecation')`;
 }
 
 switch (process.argv[2]) {
   case 'env':
   case 'switch':
-    assert.strictEqual(config.pendingDeprecation, true);
+    assert.strictEqual(
+      getOptionValue('--pending-deprecation'),
+      true
+    );
     break;
   default:
     // Verify that the flag is off by default.
     const envvar = process.env.NODE_PENDING_DEPRECATION;
-    assert.strictEqual(config.pendingDeprecation, envvar && envvar[0] === '1');
+    assert.strictEqual(
+      getOptionValue('--pending-deprecation'),
+      !!(envvar && envvar[0] === '1')
+    );
 
     // Test the --pending-deprecation command line switch.
     fork(__filename, ['switch'], {
-      execArgv: ['--pending-deprecation'],
+      execArgv: ['--pending-deprecation', '--expose-internals'],
       silent: true
     }).on('exit', common.mustCall((code) => {
       assert.strictEqual(code, 0, message('--pending-deprecation'));
@@ -38,7 +47,7 @@ switch (process.argv[2]) {
 
     // Test the --pending_deprecation command line switch.
     fork(__filename, ['switch'], {
-      execArgv: ['--pending_deprecation'],
+      execArgv: ['--pending_deprecation', '--expose-internals'],
       silent: true
     }).on('exit', common.mustCall((code) => {
       assert.strictEqual(code, 0, message('--pending_deprecation'));
@@ -47,6 +56,7 @@ switch (process.argv[2]) {
     // Test the NODE_PENDING_DEPRECATION environment var.
     fork(__filename, ['env'], {
       env: Object.assign({}, process.env, { NODE_PENDING_DEPRECATION: 1 }),
+      execArgv: ['--expose-internals'],
       silent: true
     }).on('exit', common.mustCall((code) => {
       assert.strictEqual(code, 0, message('NODE_PENDING_DEPRECATION'));
diff --git a/test/parallel/test-process-binding-internalbinding-whitelist.js b/test/parallel/test-process-binding-internalbinding-whitelist.js
index c7b683a88a1376..044757e98dc402 100644
--- a/test/parallel/test-process-binding-internalbinding-whitelist.js
+++ b/test/parallel/test-process-binding-internalbinding-whitelist.js
@@ -16,4 +16,6 @@ assert(process.binding('url'));
 assert(process.binding('spawn_sync'));
 assert(process.binding('js_stream'));
 assert(process.binding('buffer'));
+assert(process.binding('fs'));
+assert(process.binding('inspector'));
 assert(process.binding('os'));
diff --git a/test/parallel/test-util-format-shared-arraybuffer.js b/test/parallel/test-util-format-shared-arraybuffer.js
deleted file mode 100644
index 27dfad3c91fd16..00000000000000
--- a/test/parallel/test-util-format-shared-arraybuffer.js
+++ /dev/null
@@ -1,6 +0,0 @@
-'use strict';
-require('../common');
-const assert = require('assert');
-const util = require('util');
-const sab = new SharedArrayBuffer(4);
-assert.strictEqual(util.format(sab), 'SharedArrayBuffer { byteLength: 4 }');
diff --git a/test/parallel/test-util-format.js b/test/parallel/test-util-format.js
index fa4140ed8c5757..df48838767639a 100644
--- a/test/parallel/test-util-format.js
+++ b/test/parallel/test-util-format.js
@@ -308,3 +308,8 @@ Object.setPrototypeOf(BadCustomError.prototype, Error.prototype);
 Object.setPrototypeOf(BadCustomError, Error);
 assert.strictEqual(util.format(new BadCustomError('foo')),
                    '[BadCustomError: foo]');
+
+assert.strictEqual(
+  util.format(new SharedArrayBuffer(4)),
+  'SharedArrayBuffer { [Uint8Contents]: <00 00 00 00>, byteLength: 4 }'
+);
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index cf7f9742687133..e001273409014a 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -115,70 +115,86 @@ assert(!/Object/.test(
   util.inspect({ a: { a: { a: { a: {} } } } }, undefined, null, true)
 ));
 
-for (const showHidden of [true, false]) {
-  const ab = new ArrayBuffer(4);
+{
+  const showHidden = true;
+  const ab = new Uint8Array([1, 2, 3, 4]).buffer;
   const dv = new DataView(ab, 1, 2);
   assert.strictEqual(
     util.inspect(ab, showHidden),
-    'ArrayBuffer { byteLength: 4 }'
+    'ArrayBuffer { [Uint8Contents]: <01 02 03 04>, byteLength: 4 }'
   );
   assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
                      'DataView {\n' +
                      '  byteLength: 2,\n' +
                      '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+                     '  buffer:\n' +
+                     '   ArrayBuffer { [Uint8Contents]: ' +
+                       '<01 02 03 04>, byteLength: 4 } }');
   assert.strictEqual(
     util.inspect(ab, showHidden),
-    'ArrayBuffer { byteLength: 4 }'
+    'ArrayBuffer { [Uint8Contents]: <01 02 03 04>, byteLength: 4 }'
   );
   assert.strictEqual(util.inspect(dv, showHidden),
                      'DataView {\n' +
                      '  byteLength: 2,\n' +
                      '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+                     '  buffer:\n' +
+                     '   ArrayBuffer { [Uint8Contents]: ' +
+                       '<01 02 03 04>, byteLength: 4 } }');
   ab.x = 42;
   dv.y = 1337;
   assert.strictEqual(util.inspect(ab, showHidden),
-                     'ArrayBuffer { byteLength: 4, x: 42 }');
+                     'ArrayBuffer { [Uint8Contents]: <01 02 03 04>, ' +
+                       'byteLength: 4, x: 42 }');
   assert.strictEqual(util.inspect(dv, showHidden),
                      'DataView {\n' +
                      '  byteLength: 2,\n' +
                      '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
+                     '  buffer:\n' +
+                     '   ArrayBuffer { [Uint8Contents]: <01 02 03 04>, ' +
+                       'byteLength: 4, x: 42 },\n' +
                      '  y: 1337 }');
 }
 
 // Now do the same checks but from a different context.
-for (const showHidden of [true, false]) {
+{
+  const showHidden = false;
   const ab = vm.runInNewContext('new ArrayBuffer(4)');
   const dv = vm.runInNewContext('new DataView(ab, 1, 2)', { ab });
   assert.strictEqual(
     util.inspect(ab, showHidden),
-    'ArrayBuffer { byteLength: 4 }'
+    'ArrayBuffer { [Uint8Contents]: <00 00 00 00>, byteLength: 4 }'
   );
   assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
                      'DataView {\n' +
                      '  byteLength: 2,\n' +
                      '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+                     '  buffer:\n' +
+                     '   ArrayBuffer { [Uint8Contents]: <00 00 00 00>, ' +
+                       'byteLength: 4 } }');
   assert.strictEqual(
     util.inspect(ab, showHidden),
-    'ArrayBuffer { byteLength: 4 }'
+    'ArrayBuffer { [Uint8Contents]: <00 00 00 00>, byteLength: 4 }'
   );
   assert.strictEqual(util.inspect(dv, showHidden),
                      'DataView {\n' +
                      '  byteLength: 2,\n' +
                      '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+                     '  buffer:\n' +
+                     '   ArrayBuffer { [Uint8Contents]: <00 00 00 00>, ' +
+                       'byteLength: 4 } }');
   ab.x = 42;
   dv.y = 1337;
   assert.strictEqual(util.inspect(ab, showHidden),
-                     'ArrayBuffer { byteLength: 4, x: 42 }');
+                     'ArrayBuffer { [Uint8Contents]: <00 00 00 00>, ' +
+                       'byteLength: 4, x: 42 }');
   assert.strictEqual(util.inspect(dv, showHidden),
                      'DataView {\n' +
                      '  byteLength: 2,\n' +
                      '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
+                     '  buffer:\n' +
+                     '   ArrayBuffer { [Uint8Contents]: <00 00 00 00>,' +
+                       ' byteLength: 4, x: 42 },\n' +
                      '  y: 1337 }');
 }
 
@@ -1639,13 +1655,14 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   [new Float64Array(2), '[Float64Array: null prototype] [ 0, 0 ]'],
   [new BigInt64Array(2), '[BigInt64Array: null prototype] [ 0n, 0n ]'],
   [new BigUint64Array(2), '[BigUint64Array: null prototype] [ 0n, 0n ]'],
-  [new ArrayBuffer(16), '[ArrayBuffer: null prototype] ' +
-   '{ byteLength: undefined }'],
+  [new ArrayBuffer(16), '[ArrayBuffer: null prototype] {\n' +
+     '  [Uint8Contents]: <00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00>,\n' +
+     '  byteLength: undefined }'],
   [new DataView(new ArrayBuffer(16)),
    '[DataView: null prototype] {\n  byteLength: undefined,\n  ' +
-    'byteOffset: undefined,\n  buffer: undefined }'],
+     'byteOffset: undefined,\n  buffer: undefined }'],
   [new SharedArrayBuffer(2), '[SharedArrayBuffer: null prototype] ' +
-  '{ byteLength: undefined }'],
+     '{ [Uint8Contents]: <00 00>, byteLength: undefined }'],
   [/foobar/, '[RegExp: null prototype] /foobar/']
 ].forEach(([value, expected]) => {
   assert.strictEqual(
diff --git a/test/sequential/test-async-wrap-getasyncid.js b/test/sequential/test-async-wrap-getasyncid.js
index 3a59ade9a950a4..6a6bf1b407e50f 100644
--- a/test/sequential/test-async-wrap-getasyncid.js
+++ b/test/sequential/test-async-wrap-getasyncid.js
@@ -132,7 +132,7 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
 
 
 {
-  const binding = process.binding('fs');
+  const binding = internalBinding('fs');
   const path = require('path');
 
   const FSReqCallback = binding.FSReqCallback;
@@ -291,7 +291,7 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
 
 if (process.config.variables.v8_enable_inspector !== 0 &&
     common.isMainThread) {
-  const binding = process.binding('inspector');
+  const binding = internalBinding('inspector');
   const handle = new binding.Connection(() => {});
   testInitialized(handle, 'Connection');
   handle.disconnect();