diff --git a/.gitignore b/.gitignore
index 86664b41461a8e..7e263948622716 100644
--- a/.gitignore
+++ b/.gitignore
@@ -41,23 +41,19 @@ coverage/
 
 /out
 
-# various stuff that VC++ produces/uses
-Debug/
-!**/node_modules/debug/
-Release/
-!**/node_modules/**/release
+# various stuff that VC++ produces/uses and is not in /out
+/Debug/
+/Release/
 !doc/blog/**
 *.sln
 !nodemsi.sln
 *.suo
-*.vcproj
 *.vcxproj
 !custom_actions.vcxproj
 *.vcxproj.user
 *.vcxproj.filters
 UpgradeLog*.XML
 _UpgradeReport_Files/
-ipch/
 *.sdf
 *.opensdf
 *.VC.db
diff --git a/.travis.yml b/.travis.yml
index 576de336e2df11..98bfbe432ab3a3 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,12 @@
+x-ccache-setup-steps: &ccache-setup-steps
+  - export CCACHE_NOSTATS=1
+  - export CCACHE_SLOPPINESS="file_macro,include_file_mtime,include_file_ctime,time_macros,file_stat_matches"
+  - export CC='ccache gcc-6'
+  - export CXX='ccache g++-6'
+
 os: linux
 dist: xenial
+language: cpp
 jobs:
   include:
     - stage: "Lint and Compile"
@@ -21,7 +28,6 @@ jobs:
         - NODE=$(which node) make lint lint-py
 
     - name: "Compile V8"
-      language: cpp
       cache: ccache
       addons:
         apt:
@@ -29,13 +35,12 @@ jobs:
             - ubuntu-toolchain-r-test
           packages:
             - g++-6
-      install:
-        - CC='ccache gcc-6' CXX='ccache g++-6' ./configure
+      install: *ccache-setup-steps
       script:
-        - CC='ccache gcc-6' CXX='ccache g++-6' make -j2 -C out V=1 v8
+        - ./configure
+        - make -j2 -C out V=1 v8
 
     - name: "Compile Node.js"
-      language: cpp
       cache: ccache
       addons:
         apt:
@@ -43,26 +48,35 @@ jobs:
             - ubuntu-toolchain-r-test
           packages:
             - g++-6
-      install:
-        - CC='ccache gcc-6' CXX='ccache g++-6' ./configure
+      install: *ccache-setup-steps
       script:
-        - CC='ccache gcc-6' CXX='ccache g++-6' make -j2 V=1
+        - ./configure
+        - make -j2 V=1
+        - cp out/Release/node /home/travis/.ccache
+        - cp out/Release/cctest /home/travis/.ccache
 
     - stage: "Tests"
-      name: "Test Suite"
-      language: cpp
+      name: "Test JS Suites"
       cache: ccache
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
       install:
-        - export CC='ccache gcc-6' CXX='ccache g++-6' JOBS=2
-        - ./configure
-        # We already have a compile log in the above job
-        - make -j2 > /dev/null
-        - make -j1 build-addons build-js-native-api-tests build-node-api-tests > /dev/null
+        - mkdir -p out/Release
+        - cp /home/travis/.ccache/node out/Release/node
+      script:
+        - python tools/test.py -j 2 -p dots --report --mode=release --flaky-tests=dontcare default
+
+    - name: "Test C++ Suites"
+      cache: ccache
+      install:
+        - export CCACHE_NOSTATS=1
+        - export CCACHE_SLOPPINESS="file_macro,include_file_mtime,include_file_ctime,time_macros,file_stat_matches"
+        - export CC='ccache gcc'
+        - export CXX='ccache g++'
+        - mkdir -p out/Release
+        - cp /home/travis/.ccache/node out/Release/node
+        - ln -fs out/Release/node node
+        - cp /home/travis/.ccache/cctest out/Release/cctest
+        - touch config.gypi
       script:
-        - JOBS=2 FLAKY_TESTS=dontcare make -s -j1 V= test-ci | grep -F -e "---" -e "..." -v
+        - out/Release/cctest
+        - make -j1 V=1 test/addons/.buildstamp test/js-native-api/.buildstamp test/node-api/.buildstamp
+        - python tools/test.py -j 2 -p dots --report --mode=release --flaky-tests=dontcare addons js-native-api node-api
diff --git a/GOVERNANCE.md b/GOVERNANCE.md
index 7e563417e1b569..3e58601579dc4e 100644
--- a/GOVERNANCE.md
+++ b/GOVERNANCE.md
@@ -65,13 +65,13 @@ The TSC has final authority over this project, including:
 * Contribution policy
 * GitHub repository hosting
 * Conduct guidelines
-* Maintaining the list of additional Collaborators
+* Maintaining the list of Collaborators
 
-The current list of TSC members can be found in
+The current list of TSC members is in
 [the project README](./README.md#current-project-team-members).
 
-The operations of the TSC are governed by the [TSC Charter][] as approved by
-the Node.js Foundation Board of Directors.
+The [TSC Charter][] governs the operations of the TSC. All changes to the
+Charter need approval by the Node.js Board of Directors.
 
 ### TSC Meetings
 
diff --git a/common.gypi b/common.gypi
index 11b5d3b7aeb11d..8676d28ca53303 100644
--- a/common.gypi
+++ b/common.gypi
@@ -1,5 +1,6 @@
 {
   'variables': {
+    'configuring_node%': 0,
     'asan%': 0,
     'werror': '',                     # Turn off -Werror in V8 build.
     'visibility%': 'hidden',          # V8's visibility setting
@@ -280,6 +281,12 @@
     'msvs_cygwin_shell': 0, # prevent actions from trying to use cygwin
 
     'conditions': [
+      [ 'configuring_node', {
+        'msvs_configuration_attributes': {
+          'OutputDirectory': '<(DEPTH)/out/$(Configuration)/',
+          'IntermediateDirectory': '$(OutDir)obj/$(ProjectName)/'
+        },
+      }],
       [ 'target_arch=="x64"', {
         'msvs_configuration_platform': 'x64',
       }],
diff --git a/configure.py b/configure.py
index c23af2487314b0..d78a1caf64a1d2 100755
--- a/configure.py
+++ b/configure.py
@@ -1625,7 +1625,7 @@ def make_bin_override():
 
 write('config.mk', do_not_edit + config)
 
-gyp_args = ['--no-parallel']
+gyp_args = ['--no-parallel', '-Dconfiguring_node=1']
 
 if options.use_ninja:
   gyp_args += ['-f', 'ninja']
diff --git a/doc/api/cli.md b/doc/api/cli.md
index ced8cece1d57f0..60d75a6c04baef 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -230,6 +230,14 @@ https://github.com/tc39/ecma262/pull/1320.
 
 Both of the above may change in future updates, which will be breaking changes.
 
+### `--heapsnapshot-signal=signal`
+<!-- YAML
+added: REPLACEME
+-->
+
+Generates a heap snapshot each time the process receives the specified signal.
+`signal` must be a valid signal name. Disabled by default.
+
 ### `--http-parser=library`
 <!-- YAML
 added: v11.4.0
@@ -765,6 +773,7 @@ Node.js options that are allowed are:
 - `--experimental-vm-modules`
 - `--force-fips`
 - `--frozen-intrinsics`
+- `--heapsnapshot-signal`
 - `--icu-data-dir`
 - `--inspect`
 - `--inspect-brk`
diff --git a/doc/node.1 b/doc/node.1
index e2ac998cab2973..0fccabc4bceecd 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -156,6 +156,9 @@ Same requirements as
 .It Fl -frozen-intrinsics
 Enable experimental frozen intrinsics support.
 .
+.It Fl -heapsnapshot-signal Ns = Ns Ar signal
+Generate heap snapshot on specified signal.
+.
 .It Fl -http-parser Ns = Ns Ar library
 Chooses an HTTP parser library. Available values are
 .Sy llhttp
diff --git a/lib/internal/bootstrap/pre_execution.js b/lib/internal/bootstrap/pre_execution.js
index e2b1103f8cfbd8..6b1e3fb2132ed7 100644
--- a/lib/internal/bootstrap/pre_execution.js
+++ b/lib/internal/bootstrap/pre_execution.js
@@ -29,6 +29,8 @@ function prepareMainThreadExecution(expandArgv1 = false) {
   initializeReport();
   initializeReportSignalHandlers();  // Main-thread-only.
 
+  initializeHeapSnapshotSignalHandlers();
+
   // If the process is spawned with env NODE_CHANNEL_FD, it's probably
   // spawned by our child_process module, then initialize IPC.
   // This attaches some internal event listeners and creates:
@@ -166,6 +168,20 @@ function initializeReportSignalHandlers() {
   addSignalHandler();
 }
 
+function initializeHeapSnapshotSignalHandlers() {
+  const signal = getOptionValue('--heapsnapshot-signal');
+
+  if (!signal)
+    return;
+
+  require('internal/validators').validateSignalName(signal);
+  const { writeHeapSnapshot } = require('v8');
+
+  process.on(signal, () => {
+    writeHeapSnapshot();
+  });
+}
+
 function setupTraceCategoryState() {
   const { isTraceCategoryEnabled } = internalBinding('trace_events');
   const { toggleTraceCategoryState } = require('internal/process/per_thread');
diff --git a/node.gyp b/node.gyp
index 2ad76020f5784c..9088c4ce9612f7 100644
--- a/node.gyp
+++ b/node.gyp
@@ -251,6 +251,31 @@
     ],
   },
 
+  'target_defaults': {
+    # Putting these explicitly here so not to depend on `common.gypi`.
+    # `common.gypi` need to be more general because it is used to build userland native addons.
+    # Refs: https://github.com/nodejs/node-gyp/issues/1118
+    'cflags': [ '-Wall', '-Wextra', '-Wno-unused-parameter', ],
+    'xcode_settings': {
+      'WARNING_CFLAGS': [
+        '-Wall',
+        '-Wendif-labels',
+        '-W',
+        '-Wno-unused-parameter',
+        '-Werror=undefined-inline',
+      ],
+    },
+
+    # Relevant only for x86.
+    # Refs: https://github.com/nodejs/node/pull/25852
+    # Refs: https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers
+    'msvs_settings': {
+      'VCLinkerTool': {
+        'ImageHasSafeExceptionHandlers': 'false',
+      },
+    },
+  },
+
   'targets': [
     {
       'target_name': '<(node_core_target_name)',
@@ -438,6 +463,7 @@
         'src/node_messaging.cc',
         'src/node_metadata.cc',
         'src/node_native_module.cc',
+        'src/node_native_module_env.cc',
         'src/node_options.cc',
         'src/node_os.cc',
         'src/node_perf.cc',
@@ -518,6 +544,7 @@
         'src/node_metadata.h',
         'src/node_mutex.h',
         'src/node_native_module.h',
+        'src/node_native_module_env.h',
         'src/node_object_wrap.h',
         'src/node_options.h',
         'src/node_options-inl.h',
diff --git a/node.gypi b/node.gypi
index b53ccfd6bebbd8..d6c4c2669834bf 100644
--- a/node.gypi
+++ b/node.gypi
@@ -24,36 +24,20 @@
     },
     'force_load%': '<(force_load)',
   },
-  # Putting these explicitly here so not to be dependant on common.gypi.
-  'cflags': [ '-Wall', '-Wextra', '-Wno-unused-parameter', ],
-  'xcode_settings': {
-    'WARNING_CFLAGS': [
-      '-Wall',
-      '-Wendif-labels',
-      '-W',
-      '-Wno-unused-parameter',
-      '-Werror=undefined-inline',
-    ],
-  },
-  # Relevant only for x86.
-  # Refs: https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers
-  'msvs_settings': {
-    'VCLinkerTool': {
-      'ImageHasSafeExceptionHandlers': 'false',
-    },
-  },
+
   'conditions': [
     [ 'clang==1', {
       'cflags': [ '-Werror=undefined-inline', ]
     }],
-    [ 'node_shared=="false"', {
+    [ 'node_shared=="false" and "<(_type)"=="executable"', {
       'msvs_settings': {
         'VCManifestTool': {
           'EmbedManifest': 'true',
           'AdditionalManifestFiles': 'src/res/node.exe.extra.manifest'
         }
       },
-    }, {
+    }],
+    [ 'node_shared=="true"', {
       'defines': [
         'NODE_SHARED_MODE',
       ],
diff --git a/src/api/environment.cc b/src/api/environment.cc
index 62eca337e15627..fb7d7003bba0b3 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -3,7 +3,7 @@
 #include "node_context_data.h"
 #include "node_errors.h"
 #include "node_internals.h"
-#include "node_native_module.h"
+#include "node_native_module_env.h"
 #include "node_platform.h"
 #include "node_process.h"
 #include "node_v8_platform-inl.h"
@@ -351,7 +351,7 @@ Local<Context> NewContext(Isolate* isolate,
       };
       Local<Value> arguments[] = {context->Global(), exports};
       MaybeLocal<Function> maybe_fn =
-          per_process::native_module_loader.LookupAndCompile(
+          native_module::NativeModuleEnv::LookupAndCompile(
               context, *module, &parameters, nullptr);
       if (maybe_fn.IsEmpty()) {
         return Local<Context>();
diff --git a/src/api/exceptions.cc b/src/api/exceptions.cc
index 1025991063e710..ee5ea984eb23c5 100644
--- a/src/api/exceptions.cc
+++ b/src/api/exceptions.cc
@@ -58,17 +58,17 @@ Local<Value> ErrnoException(Isolate* isolate,
   Local<Object> obj = e.As<Object>();
   obj->Set(env->context(),
            env->errno_string(),
-           Integer::New(isolate, errorno)).FromJust();
-  obj->Set(env->context(), env->code_string(), estring).FromJust();
+           Integer::New(isolate, errorno)).Check();
+  obj->Set(env->context(), env->code_string(), estring).Check();
 
   if (path_string.IsEmpty() == false) {
-    obj->Set(env->context(), env->path_string(), path_string).FromJust();
+    obj->Set(env->context(), env->path_string(), path_string).Check();
   }
 
   if (syscall != nullptr) {
     obj->Set(env->context(),
              env->syscall_string(),
-             OneByteString(isolate, syscall)).FromJust();
+             OneByteString(isolate, syscall)).Check();
   }
 
   return e;
@@ -144,13 +144,13 @@ Local<Value> UVException(Isolate* isolate,
 
   e->Set(env->context(),
          env->errno_string(),
-         Integer::New(isolate, errorno)).FromJust();
-  e->Set(env->context(), env->code_string(), js_code).FromJust();
-  e->Set(env->context(), env->syscall_string(), js_syscall).FromJust();
+         Integer::New(isolate, errorno)).Check();
+  e->Set(env->context(), env->code_string(), js_code).Check();
+  e->Set(env->context(), env->syscall_string(), js_syscall).Check();
   if (!js_path.IsEmpty())
-    e->Set(env->context(), env->path_string(), js_path).FromJust();
+    e->Set(env->context(), env->path_string(), js_path).Check();
   if (!js_dest.IsEmpty())
-    e->Set(env->context(), env->dest_string(), js_dest).FromJust();
+    e->Set(env->context(), env->dest_string(), js_dest).Check();
 
   return e;
 }
@@ -219,21 +219,21 @@ Local<Value> WinapiErrnoException(Isolate* isolate,
 
   Local<Object> obj = e.As<Object>();
   obj->Set(env->context(), env->errno_string(), Integer::New(isolate, errorno))
-      .FromJust();
+      .Check();
 
   if (path != nullptr) {
     obj->Set(env->context(),
              env->path_string(),
              String::NewFromUtf8(isolate, path, NewStringType::kNormal)
                  .ToLocalChecked())
-        .FromJust();
+        .Check();
   }
 
   if (syscall != nullptr) {
     obj->Set(env->context(),
              env->syscall_string(),
              OneByteString(isolate, syscall))
-        .FromJust();
+        .Check();
   }
 
   if (must_free) {
diff --git a/src/api/hooks.cc b/src/api/hooks.cc
index 6a0319c61cc767..3b1ee90a99ae1d 100644
--- a/src/api/hooks.cc
+++ b/src/api/hooks.cc
@@ -49,7 +49,7 @@ int EmitExit(Environment* env) {
       ->Set(env->context(),
             FIXED_ONE_BYTE_STRING(env->isolate(), "_exiting"),
             True(env->isolate()))
-      .FromJust();
+      .Check();
 
   Local<String> exit_code = env->exit_code_string();
   int code = process_object->Get(env->context(), exit_code)
diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index 0cee1b2db1e860..dd84f992273a27 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -487,11 +487,11 @@ void AsyncWrap::Initialize(Local<Object> target,
 
   target->Set(context,
               env->async_ids_stack_string(),
-              env->async_hooks()->async_ids_stack().GetJSArray()).FromJust();
+              env->async_hooks()->async_ids_stack().GetJSArray()).Check();
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(env->isolate(), "owner_symbol"),
-              env->owner_symbol()).FromJust();
+              env->owner_symbol()).Check();
 
   Local<Object> constants = Object::New(isolate);
 #define SET_HOOKS_CONSTANT(name)                                              \
@@ -542,7 +542,7 @@ void AsyncWrap::Initialize(Local<Object> target,
     instance_template->SetInternalFieldCount(1);
     auto function =
         function_template->GetFunction(env->context()).ToLocalChecked();
-    target->Set(env->context(), class_name, function).FromJust();
+    target->Set(env->context(), class_name, function).Check();
     env->set_async_wrap_object_ctor_template(function_template);
   }
 }
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index 6c6fca53312158..07882a4212c6b2 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -374,7 +374,7 @@ Local<Array> HostentToNames(Environment* env,
 
   for (uint32_t i = 0; host->h_aliases[i] != nullptr; ++i) {
     Local<String> address = OneByteString(env->isolate(), host->h_aliases[i]);
-    names->Set(context, i + offset, address).FromJust();
+    names->Set(context, i + offset, address).Check();
   }
 
   return append ? names : scope.Escape(names);
@@ -577,7 +577,7 @@ class QueryWrap : public AsyncWrap {
     // Make sure the channel object stays alive during the query lifetime.
     req_wrap_obj->Set(env()->context(),
                       env()->channel_string(),
-                      channel->object()).FromJust();
+                      channel->object()).Check();
   }
 
   ~QueryWrap() override {
@@ -756,7 +756,7 @@ Local<Array> AddrTTLToArray(Environment* env,
   Local<Array> ttls = Array::New(isolate, naddrttls);
   for (size_t i = 0; i < naddrttls; i++) {
     auto value = Integer::New(isolate, addrttls[i].ttl);
-    ttls->Set(context, i, value).FromJust();
+    ttls->Set(context, i, value).Check();
   }
 
   return escapable_handle_scope.Escape(ttls);
@@ -816,7 +816,7 @@ int ParseGeneralReply(Environment* env,
     *type = ns_t_cname;
     ret->Set(context,
              ret->Length(),
-             OneByteString(env->isolate(), host->h_name)).FromJust();
+             OneByteString(env->isolate(), host->h_name)).Check();
     ares_free_hostent(host);
     return ARES_SUCCESS;
   }
@@ -830,7 +830,7 @@ int ParseGeneralReply(Environment* env,
     uint32_t offset = ret->Length();
     for (uint32_t i = 0; host->h_aliases[i] != nullptr; i++) {
       auto alias = OneByteString(env->isolate(), host->h_aliases[i]);
-      ret->Set(context, i + offset, alias).FromJust();
+      ret->Set(context, i + offset, alias).Check();
     }
   } else {
     uint32_t offset = ret->Length();
@@ -838,7 +838,7 @@ int ParseGeneralReply(Environment* env,
     for (uint32_t i = 0; host->h_addr_list[i] != nullptr; ++i) {
       uv_inet_ntop(host->h_addrtype, host->h_addr_list[i], ip, sizeof(ip));
       auto address = OneByteString(env->isolate(), ip);
-      ret->Set(context, i + offset, address).FromJust();
+      ret->Set(context, i + offset, address).Check();
     }
   }
 
@@ -868,16 +868,16 @@ int ParseMxReply(Environment* env,
     Local<Object> mx_record = Object::New(env->isolate());
     mx_record->Set(context,
                    env->exchange_string(),
-                   OneByteString(env->isolate(), current->host)).FromJust();
+                   OneByteString(env->isolate(), current->host)).Check();
     mx_record->Set(context,
                    env->priority_string(),
-                   Integer::New(env->isolate(), current->priority)).FromJust();
+                   Integer::New(env->isolate(), current->priority)).Check();
     if (need_type)
       mx_record->Set(context,
                      env->type_string(),
-                     env->dns_mx_string()).FromJust();
+                     env->dns_mx_string()).Check();
 
-    ret->Set(context, i + offset, mx_record).FromJust();
+    ret->Set(context, i + offset, mx_record).Check();
   }
 
   ares_free_data(mx_start);
@@ -912,13 +912,13 @@ int ParseTxtReply(Environment* env,
       if (!txt_chunk.IsEmpty()) {
         if (need_type) {
           Local<Object> elem = Object::New(env->isolate());
-          elem->Set(context, env->entries_string(), txt_chunk).FromJust();
+          elem->Set(context, env->entries_string(), txt_chunk).Check();
           elem->Set(context,
                     env->type_string(),
-                    env->dns_txt_string()).FromJust();
-          ret->Set(context, offset + i++, elem).FromJust();
+                    env->dns_txt_string()).Check();
+          ret->Set(context, offset + i++, elem).Check();
         } else {
-          ret->Set(context, offset + i++, txt_chunk).FromJust();
+          ret->Set(context, offset + i++, txt_chunk).Check();
         }
       }
 
@@ -926,20 +926,20 @@ int ParseTxtReply(Environment* env,
       j = 0;
     }
 
-    txt_chunk->Set(context, j++, txt).FromJust();
+    txt_chunk->Set(context, j++, txt).Check();
   }
 
   // Push last chunk if it isn't empty
   if (!txt_chunk.IsEmpty()) {
     if (need_type) {
       Local<Object> elem = Object::New(env->isolate());
-      elem->Set(context, env->entries_string(), txt_chunk).FromJust();
+      elem->Set(context, env->entries_string(), txt_chunk).Check();
       elem->Set(context,
                 env->type_string(),
-                env->dns_txt_string()).FromJust();
-      ret->Set(context, offset + i, elem).FromJust();
+                env->dns_txt_string()).Check();
+      ret->Set(context, offset + i, elem).Check();
     } else {
-      ret->Set(context, offset + i, txt_chunk).FromJust();
+      ret->Set(context, offset + i, txt_chunk).Check();
     }
   }
 
@@ -968,22 +968,22 @@ int ParseSrvReply(Environment* env,
     Local<Object> srv_record = Object::New(env->isolate());
     srv_record->Set(context,
                     env->name_string(),
-                    OneByteString(env->isolate(), current->host)).FromJust();
+                    OneByteString(env->isolate(), current->host)).Check();
     srv_record->Set(context,
                     env->port_string(),
-                    Integer::New(env->isolate(), current->port)).FromJust();
+                    Integer::New(env->isolate(), current->port)).Check();
     srv_record->Set(context,
                     env->priority_string(),
-                    Integer::New(env->isolate(), current->priority)).FromJust();
+                    Integer::New(env->isolate(), current->priority)).Check();
     srv_record->Set(context,
                     env->weight_string(),
-                    Integer::New(env->isolate(), current->weight)).FromJust();
+                    Integer::New(env->isolate(), current->weight)).Check();
     if (need_type)
       srv_record->Set(context,
                       env->type_string(),
-                      env->dns_srv_string()).FromJust();
+                      env->dns_srv_string()).Check();
 
-    ret->Set(context, i + offset, srv_record).FromJust();
+    ret->Set(context, i + offset, srv_record).Check();
   }
 
   ares_free_data(srv_start);
@@ -1012,32 +1012,32 @@ int ParseNaptrReply(Environment* env,
     Local<Object> naptr_record = Object::New(env->isolate());
     naptr_record->Set(context,
                       env->flags_string(),
-                      OneByteString(env->isolate(), current->flags)).FromJust();
+                      OneByteString(env->isolate(), current->flags)).Check();
     naptr_record->Set(context,
                       env->service_string(),
                       OneByteString(env->isolate(),
-                                    current->service)).FromJust();
+                                    current->service)).Check();
     naptr_record->Set(context,
                       env->regexp_string(),
                       OneByteString(env->isolate(),
-                                    current->regexp)).FromJust();
+                                    current->regexp)).Check();
     naptr_record->Set(context,
                       env->replacement_string(),
                       OneByteString(env->isolate(),
-                                    current->replacement)).FromJust();
+                                    current->replacement)).Check();
     naptr_record->Set(context,
                       env->order_string(),
-                      Integer::New(env->isolate(), current->order)).FromJust();
+                      Integer::New(env->isolate(), current->order)).Check();
     naptr_record->Set(context,
                       env->preference_string(),
                       Integer::New(env->isolate(),
-                                   current->preference)).FromJust();
+                                   current->preference)).Check();
     if (need_type)
       naptr_record->Set(context,
                         env->type_string(),
-                        env->dns_naptr_string()).FromJust();
+                        env->dns_naptr_string()).Check();
 
-    ret->Set(context, i + offset, naptr_record).FromJust();
+    ret->Set(context, i + offset, naptr_record).Check();
   }
 
   ares_free_data(naptr_start);
@@ -1131,29 +1131,29 @@ int ParseSoaReply(Environment* env,
       Local<Object> soa_record = Object::New(env->isolate());
       soa_record->Set(context,
                       env->nsname_string(),
-                      OneByteString(env->isolate(), nsname.get())).FromJust();
+                      OneByteString(env->isolate(), nsname.get())).Check();
       soa_record->Set(context,
                       env->hostmaster_string(),
                       OneByteString(env->isolate(),
-                                    hostmaster.get())).FromJust();
+                                    hostmaster.get())).Check();
       soa_record->Set(context,
                       env->serial_string(),
-                      Integer::New(env->isolate(), serial)).FromJust();
+                      Integer::New(env->isolate(), serial)).Check();
       soa_record->Set(context,
                       env->refresh_string(),
-                      Integer::New(env->isolate(), refresh)).FromJust();
+                      Integer::New(env->isolate(), refresh)).Check();
       soa_record->Set(context,
                       env->retry_string(),
-                      Integer::New(env->isolate(), retry)).FromJust();
+                      Integer::New(env->isolate(), retry)).Check();
       soa_record->Set(context,
                       env->expire_string(),
-                      Integer::New(env->isolate(), expire)).FromJust();
+                      Integer::New(env->isolate(), expire)).Check();
       soa_record->Set(context,
                       env->minttl_string(),
-                      Integer::New(env->isolate(), minttl)).FromJust();
+                      Integer::New(env->isolate(), minttl)).Check();
       soa_record->Set(context,
                       env->type_string(),
-                      env->dns_soa_string()).FromJust();
+                      env->dns_soa_string()).Check();
 
 
       *ret = handle_scope.Escape(soa_record);
@@ -1215,25 +1215,25 @@ class QueryAnyWrap: public QueryWrap {
         Local<Object> obj = Object::New(env()->isolate());
         obj->Set(context,
                  env()->address_string(),
-                 ret->Get(context, i).ToLocalChecked()).FromJust();
+                 ret->Get(context, i).ToLocalChecked()).Check();
         obj->Set(context,
                  env()->ttl_string(),
-                 Integer::New(env()->isolate(), addrttls[i].ttl)).FromJust();
+                 Integer::New(env()->isolate(), addrttls[i].ttl)).Check();
         obj->Set(context,
                  env()->type_string(),
-                 env()->dns_a_string()).FromJust();
-        ret->Set(context, i, obj).FromJust();
+                 env()->dns_a_string()).Check();
+        ret->Set(context, i, obj).Check();
       }
     } else {
       for (uint32_t i = 0; i < a_count; i++) {
         Local<Object> obj = Object::New(env()->isolate());
         obj->Set(context,
                  env()->value_string(),
-                 ret->Get(context, i).ToLocalChecked()).FromJust();
+                 ret->Get(context, i).ToLocalChecked()).Check();
         obj->Set(context,
                  env()->type_string(),
-                 env()->dns_cname_string()).FromJust();
-        ret->Set(context, i, obj).FromJust();
+                 env()->dns_cname_string()).Check();
+        ret->Set(context, i, obj).Check();
       }
     }
 
@@ -1261,15 +1261,15 @@ class QueryAnyWrap: public QueryWrap {
       Local<Object> obj = Object::New(env()->isolate());
       obj->Set(context,
                env()->address_string(),
-               ret->Get(context, i).ToLocalChecked()).FromJust();
+               ret->Get(context, i).ToLocalChecked()).Check();
       obj->Set(context,
                env()->ttl_string(),
                Integer::New(env()->isolate(), addr6ttls[i - a_count].ttl))
-          .FromJust();
+          .Check();
       obj->Set(context,
                env()->type_string(),
-               env()->dns_aaaa_string()).FromJust();
-      ret->Set(context, i, obj).FromJust();
+               env()->dns_aaaa_string()).Check();
+      ret->Set(context, i, obj).Check();
     }
 
     /* Parse MX records */
@@ -1291,11 +1291,11 @@ class QueryAnyWrap: public QueryWrap {
       Local<Object> obj = Object::New(env()->isolate());
       obj->Set(context,
                env()->value_string(),
-               ret->Get(context, i).ToLocalChecked()).FromJust();
+               ret->Get(context, i).ToLocalChecked()).Check();
       obj->Set(context,
                env()->type_string(),
-               env()->dns_ns_string()).FromJust();
-      ret->Set(context, i, obj).FromJust();
+               env()->dns_ns_string()).Check();
+      ret->Set(context, i, obj).Check();
     }
 
     /* Parse TXT records */
@@ -1319,11 +1319,11 @@ class QueryAnyWrap: public QueryWrap {
       Local<Object> obj = Object::New(env()->isolate());
       obj->Set(context,
                env()->value_string(),
-               ret->Get(context, i).ToLocalChecked()).FromJust();
+               ret->Get(context, i).ToLocalChecked()).Check();
       obj->Set(context,
                env()->type_string(),
-               env()->dns_ptr_string()).FromJust();
-      ret->Set(context, i, obj).FromJust();
+               env()->dns_ptr_string()).Check();
+      ret->Set(context, i, obj).Check();
     }
 
     /* Parse NAPTR records */
@@ -1341,7 +1341,7 @@ class QueryAnyWrap: public QueryWrap {
       return;
     }
     if (!soa_record.IsEmpty())
-      ret->Set(context, ret->Length(), soa_record).FromJust();
+      ret->Set(context, ret->Length(), soa_record).Check();
 
     CallOnComplete(ret);
   }
@@ -1701,27 +1701,27 @@ class QuerySoaWrap: public QueryWrap {
     soa_record->Set(context,
                     env()->nsname_string(),
                     OneByteString(env()->isolate(),
-                                  soa_out->nsname)).FromJust();
+                                  soa_out->nsname)).Check();
     soa_record->Set(context,
                     env()->hostmaster_string(),
                     OneByteString(env()->isolate(),
-                                  soa_out->hostmaster)).FromJust();
+                                  soa_out->hostmaster)).Check();
     soa_record->Set(context,
                     env()->serial_string(),
-                    Integer::New(env()->isolate(), soa_out->serial)).FromJust();
+                    Integer::New(env()->isolate(), soa_out->serial)).Check();
     soa_record->Set(context,
                     env()->refresh_string(),
                     Integer::New(env()->isolate(),
-                                 soa_out->refresh)).FromJust();
+                                 soa_out->refresh)).Check();
     soa_record->Set(context,
                     env()->retry_string(),
-                    Integer::New(env()->isolate(), soa_out->retry)).FromJust();
+                    Integer::New(env()->isolate(), soa_out->retry)).Check();
     soa_record->Set(context,
                     env()->expire_string(),
-                    Integer::New(env()->isolate(), soa_out->expire)).FromJust();
+                    Integer::New(env()->isolate(), soa_out->expire)).Check();
     soa_record->Set(context,
                     env()->minttl_string(),
-                    Integer::New(env()->isolate(), soa_out->minttl)).FromJust();
+                    Integer::New(env()->isolate(), soa_out->minttl)).Check();
 
     ares_free_data(soa_out);
 
@@ -1844,7 +1844,7 @@ void AfterGetAddrInfo(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
           continue;
 
         Local<String> s = OneByteString(env->isolate(), ip);
-        results->Set(env->context(), n, s).FromJust();
+        results->Set(env->context(), n, s).Check();
         n++;
       }
     };
@@ -2047,12 +2047,12 @@ void GetServers(const FunctionCallbackInfo<Value>& args) {
     CHECK_EQ(err, 0);
 
     Local<Array> ret = Array::New(env->isolate(), 2);
-    ret->Set(env->context(), 0, OneByteString(env->isolate(), ip)).FromJust();
+    ret->Set(env->context(), 0, OneByteString(env->isolate(), ip)).Check();
     ret->Set(env->context(),
              1,
-             Integer::New(env->isolate(), cur->udp_port)).FromJust();
+             Integer::New(env->isolate(), cur->udp_port)).Check();
 
-    server_array->Set(env->context(), i, ret).FromJust();
+    server_array->Set(env->context(), i, ret).Check();
   }
 
   ares_free_data(servers);
@@ -2177,18 +2177,18 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "strerror", StrError);
 
   target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(), "AF_INET"),
-              Integer::New(env->isolate(), AF_INET)).FromJust();
+              Integer::New(env->isolate(), AF_INET)).Check();
   target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(), "AF_INET6"),
-              Integer::New(env->isolate(), AF_INET6)).FromJust();
+              Integer::New(env->isolate(), AF_INET6)).Check();
   target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(),
                                                     "AF_UNSPEC"),
-              Integer::New(env->isolate(), AF_UNSPEC)).FromJust();
+              Integer::New(env->isolate(), AF_UNSPEC)).Check();
   target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(),
                                                     "AI_ADDRCONFIG"),
-              Integer::New(env->isolate(), AI_ADDRCONFIG)).FromJust();
+              Integer::New(env->isolate(), AI_ADDRCONFIG)).Check();
   target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(),
                                                     "AI_V4MAPPED"),
-              Integer::New(env->isolate(), AI_V4MAPPED)).FromJust();
+              Integer::New(env->isolate(), AI_V4MAPPED)).Check();
 
   Local<FunctionTemplate> aiw =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
@@ -2198,7 +2198,7 @@ void Initialize(Local<Object> target,
   aiw->SetClassName(addrInfoWrapString);
   target->Set(env->context(),
               addrInfoWrapString,
-              aiw->GetFunction(context).ToLocalChecked()).FromJust();
+              aiw->GetFunction(context).ToLocalChecked()).Check();
 
   Local<FunctionTemplate> niw =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
@@ -2208,7 +2208,7 @@ void Initialize(Local<Object> target,
   niw->SetClassName(nameInfoWrapString);
   target->Set(env->context(),
               nameInfoWrapString,
-              niw->GetFunction(context).ToLocalChecked()).FromJust();
+              niw->GetFunction(context).ToLocalChecked()).Check();
 
   Local<FunctionTemplate> qrw =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
@@ -2218,7 +2218,7 @@ void Initialize(Local<Object> target,
   qrw->SetClassName(queryWrapString);
   target->Set(env->context(),
               queryWrapString,
-              qrw->GetFunction(context).ToLocalChecked()).FromJust();
+              qrw->GetFunction(context).ToLocalChecked()).Check();
 
   Local<FunctionTemplate> channel_wrap =
       env->NewFunctionTemplate(ChannelWrap::New);
@@ -2246,7 +2246,7 @@ void Initialize(Local<Object> target,
       FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap");
   channel_wrap->SetClassName(channelWrapString);
   target->Set(env->context(), channelWrapString,
-              channel_wrap->GetFunction(context).ToLocalChecked()).FromJust();
+              channel_wrap->GetFunction(context).ToLocalChecked()).Check();
 }
 
 }  // anonymous namespace
diff --git a/src/env-inl.h b/src/env-inl.h
index a489a4001a2557..a78ed024d2bbf9 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -934,7 +934,7 @@ inline void Environment::SetMethod(v8::Local<v8::Object> that,
   const v8::NewStringType type = v8::NewStringType::kInternalized;
   v8::Local<v8::String> name_string =
       v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
-  that->Set(context, name_string, function).FromJust();
+  that->Set(context, name_string, function).Check();
   function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
 }
 
@@ -952,7 +952,7 @@ inline void Environment::SetMethodNoSideEffect(v8::Local<v8::Object> that,
   const v8::NewStringType type = v8::NewStringType::kInternalized;
   v8::Local<v8::String> name_string =
       v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
-  that->Set(context, name_string, function).FromJust();
+  that->Set(context, name_string, function).Check();
   function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
 }
 
diff --git a/src/env.cc b/src/env.cc
index 3d85bcfcf703dc..88017ab54524e7 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -748,33 +748,33 @@ void CollectExceptionInfo(Environment* env,
                           const char* dest) {
   obj->Set(env->context(),
            env->errno_string(),
-           Integer::New(env->isolate(), errorno)).FromJust();
+           Integer::New(env->isolate(), errorno)).Check();
 
   obj->Set(env->context(), env->code_string(),
-           OneByteString(env->isolate(), err_string)).FromJust();
+           OneByteString(env->isolate(), err_string)).Check();
 
   if (message != nullptr) {
     obj->Set(env->context(), env->message_string(),
-             OneByteString(env->isolate(), message)).FromJust();
+             OneByteString(env->isolate(), message)).Check();
   }
 
   Local<Value> path_buffer;
   if (path != nullptr) {
     path_buffer =
       Buffer::Copy(env->isolate(), path, strlen(path)).ToLocalChecked();
-    obj->Set(env->context(), env->path_string(), path_buffer).FromJust();
+    obj->Set(env->context(), env->path_string(), path_buffer).Check();
   }
 
   Local<Value> dest_buffer;
   if (dest != nullptr) {
     dest_buffer =
       Buffer::Copy(env->isolate(), dest, strlen(dest)).ToLocalChecked();
-    obj->Set(env->context(), env->dest_string(), dest_buffer).FromJust();
+    obj->Set(env->context(), env->dest_string(), dest_buffer).Check();
   }
 
   if (syscall != nullptr) {
     obj->Set(env->context(), env->syscall_string(),
-             OneByteString(env->isolate(), syscall)).FromJust();
+             OneByteString(env->isolate(), syscall)).Check();
   }
 }
 
@@ -819,7 +819,7 @@ void AsyncHooks::grow_async_ids_stack() {
   env()->async_hooks_binding()->Set(
       env()->context(),
       env()->async_ids_stack_string(),
-      async_ids_stack_.GetJSArray()).FromJust();
+      async_ids_stack_.GetJSArray()).Check();
 }
 
 uv_key_t Environment::thread_local_env = {};
diff --git a/src/fs_event_wrap.cc b/src/fs_event_wrap.cc
index acdaff586cec50..b5807dd3ffc9ab 100644
--- a/src/fs_event_wrap.cc
+++ b/src/fs_event_wrap.cc
@@ -122,7 +122,7 @@ void FSEventWrap::Initialize(Local<Object> target,
 
   target->Set(env->context(),
               fsevent_string,
-              t->GetFunction(context).ToLocalChecked()).FromJust();
+              t->GetFunction(context).ToLocalChecked()).Check();
 }
 
 
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index 57228ed953302f..cda5cdbbd8dc46 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -403,7 +403,7 @@ void NotifyClusterWorkersDebugEnabled(Environment* env) {
   // Send message to enable debug in cluster workers
   Local<Object> message = Object::New(isolate);
   message->Set(context, FIXED_ONE_BYTE_STRING(isolate, "cmd"),
-               FIXED_ONE_BYTE_STRING(isolate, "NODE_DEBUG_ENABLED")).FromJust();
+               FIXED_ONE_BYTE_STRING(isolate, "NODE_DEBUG_ENABLED")).Check();
   ProcessEmit(env, "internalMessage", message);
 }
 
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
index 8b55146dbe555f..51ec14a63a1ad1 100644
--- a/src/inspector_js_api.cc
+++ b/src/inspector_js_api.cc
@@ -280,7 +280,7 @@ void Initialize(Local<Object> target, Local<Value> unused,
           ->GetFunction(context)
           .ToLocalChecked();
   auto name_string = FIXED_ONE_BYTE_STRING(env->isolate(), "consoleCall");
-  target->Set(context, name_string, consoleCallFunc).FromJust();
+  target->Set(context, name_string, consoleCallFunc).Check();
   consoleCallFunc->SetName(name_string);
 
   env->SetMethod(
diff --git a/src/js_stream.cc b/src/js_stream.cc
index ddde2a5948f355..d29e748da8dae2 100644
--- a/src/js_stream.cc
+++ b/src/js_stream.cc
@@ -120,7 +120,7 @@ int JSStream::DoWrite(WriteWrap* w,
   Local<Object> buf;
   for (size_t i = 0; i < count; i++) {
     buf = Buffer::Copy(env(), bufs[i].base, bufs[i].len).ToLocalChecked();
-    bufs_arr->Set(env()->context(), i, buf).FromJust();
+    bufs_arr->Set(env()->context(), i, buf).Check();
   }
 
   Local<Value> argv[] = {
@@ -216,7 +216,7 @@ void JSStream::Initialize(Local<Object> target,
   StreamBase::AddMethods(env, t);
   target->Set(env->context(),
               jsStreamString,
-              t->GetFunction(context).ToLocalChecked()).FromJust();
+              t->GetFunction(context).ToLocalChecked()).Check();
 }
 
 }  // namespace node
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index b11a4fe898ab81..d6ad0da622476f 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -239,7 +239,7 @@ void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
     Local<Promise> resolve_promise = resolve_return_value.As<Promise>();
     obj->resolve_cache_[specifier_std].Reset(env->isolate(), resolve_promise);
 
-    promises->Set(mod_context, i, resolve_promise).FromJust();
+    promises->Set(mod_context, i, resolve_promise).Check();
   }
 
   args.GetReturnValue().Set(promises);
@@ -374,7 +374,7 @@ void ModuleWrap::GetStaticDependencySpecifiers(
   Local<Array> specifiers = Array::New(env->isolate(), count);
 
   for (int i = 0; i < count; i++)
-    specifiers->Set(env->context(), i, module->GetModuleRequest(i)).FromJust();
+    specifiers->Set(env->context(), i, module->GetModuleRequest(i)).Check();
 
   args.GetReturnValue().Set(specifiers);
 }
@@ -1064,7 +1064,7 @@ void ModuleWrap::Initialize(Local<Object> target,
                                   GetStaticDependencySpecifiers);
 
   target->Set(env->context(), FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"),
-              tpl->GetFunction(context).ToLocalChecked()).FromJust();
+              tpl->GetFunction(context).ToLocalChecked()).Check();
   env->SetMethod(target, "resolve", Resolve);
   env->SetMethod(target, "getPackageType", GetPackageType);
   env->SetMethod(target,
diff --git a/src/node.cc b/src/node.cc
index adf4a832094be5..09817b8a4c1d0d 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -31,7 +31,7 @@
 #include "node_errors.h"
 #include "node_internals.h"
 #include "node_metadata.h"
-#include "node_native_module.h"
+#include "node_native_module_env.h"
 #include "node_options-inl.h"
 #include "node_perf.h"
 #include "node_platform.h"
@@ -118,8 +118,10 @@
 
 namespace node {
 
+using native_module::NativeModuleEnv;
 using options_parser::kAllowedInEnvironment;
 using options_parser::kDisallowedInEnvironment;
+
 using v8::Array;
 using v8::Boolean;
 using v8::Context;
@@ -130,7 +132,6 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
 using v8::Isolate;
-using v8::Just;
 using v8::Local;
 using v8::Locker;
 using v8::Maybe;
@@ -208,8 +209,7 @@ MaybeLocal<Value> ExecuteBootstrapper(Environment* env,
                                       std::vector<Local<Value>>* arguments) {
   EscapableHandleScope scope(env->isolate());
   MaybeLocal<Function> maybe_fn =
-      per_process::native_module_loader.LookupAndCompile(
-          env->context(), id, parameters, env);
+      NativeModuleEnv::LookupAndCompile(env->context(), id, parameters, env);
 
   if (maybe_fn.IsEmpty()) {
     return MaybeLocal<Value>();
@@ -266,7 +266,7 @@ MaybeLocal<Value> RunBootstrapping(Environment* env) {
   // Expose the global object as a property on itself
   // (Allows you to set stuff on `global` from anywhere in JavaScript.)
   global->Set(context, FIXED_ONE_BYTE_STRING(env->isolate(), "global"), global)
-      .FromJust();
+      .Check();
 
   // Store primordials
   env->set_primordials(Object::New(isolate));
@@ -402,7 +402,7 @@ MaybeLocal<Value> StartMainThreadExecution(Environment* env) {
   // 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 (per_process::native_module_loader.Exists("_third_party_main")) {
+  if (NativeModuleEnv::Exists("_third_party_main")) {
     return StartExecution(env, "internal/main/run_third_party_main");
   }
 
@@ -725,6 +725,8 @@ int InitializeNodeWithArgs(std::vector<std::string>* argv,
   per_process::metadata.versions.InitializeIntlVersions();
 #endif
 
+  NativeModuleEnv::InitializeCodeCache();
+
   // We should set node_is_initialized here instead of in node::Start,
   // otherwise embedders using node::Init to initialize everything will not be
   // able to set it and native modules will not load for them.
diff --git a/src/node.h b/src/node.h
index 2923c60cf61008..e638ff24182201 100644
--- a/src/node.h
+++ b/src/node.h
@@ -374,7 +374,7 @@ NODE_DEPRECATED("Use v8::Date::ValueOf() directly",
     (target)->DefineOwnProperty(context,                                      \
                                 constant_name,                                \
                                 constant_value,                               \
-                                constant_attributes).FromJust();              \
+                                constant_attributes).Check();                 \
   }                                                                           \
   while (0)
 
@@ -395,7 +395,7 @@ NODE_DEPRECATED("Use v8::Date::ValueOf() directly",
     (target)->DefineOwnProperty(context,                                      \
                                 constant_name,                                \
                                 constant_value,                               \
-                                constant_attributes).FromJust();              \
+                                constant_attributes).Check();                 \
   }                                                                           \
   while (0)
 
@@ -426,7 +426,7 @@ inline void NODE_SET_METHOD(v8::Local<v8::Object> recv,
   v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name,
       v8::NewStringType::kInternalized).ToLocalChecked();
   fn->SetName(fn_name);
-  recv->Set(context, fn_name, fn).FromJust();
+  recv->Set(context, fn_name, fn).Check();
 }
 #define NODE_SET_METHOD node::NODE_SET_METHOD
 
diff --git a/src/node_binding.cc b/src/node_binding.cc
index 123bdad418e446..9a9bfa70a8a378 100644
--- a/src/node_binding.cc
+++ b/src/node_binding.cc
@@ -1,8 +1,8 @@
 #include "node_binding.h"
+#include <atomic>
 #include "env-inl.h"
-#include "node_native_module.h"
+#include "node_native_module_env.h"
 #include "util.h"
-#include <atomic>
 
 #if HAVE_OPENSSL
 #define NODE_BUILTIN_OPENSSL_MODULES(V) V(crypto) V(tls_wrap)
@@ -593,13 +593,13 @@ void GetInternalBinding(const FunctionCallbackInfo<Value>& args) {
         exports->SetPrototype(env->context(), Null(env->isolate())).FromJust());
     DefineConstants(env->isolate(), exports);
   } else if (!strcmp(*module_v, "natives")) {
-    exports = per_process::native_module_loader.GetSourceObject(env->context());
+    exports = native_module::NativeModuleEnv::GetSourceObject(env->context());
     // Legacy feature: process.binding('natives').config contains stringified
     // config.gypi
     CHECK(exports
               ->Set(env->context(),
                     env->config_string(),
-                    per_process::native_module_loader.GetConfigString(
+                    native_module::NativeModuleEnv::GetConfigString(
                         env->isolate()))
               .FromJust());
   } else {
@@ -633,7 +633,7 @@ void GetLinkedBinding(const FunctionCallbackInfo<Value>& args) {
   Local<String> exports_prop =
       String::NewFromUtf8(env->isolate(), "exports", NewStringType::kNormal)
           .ToLocalChecked();
-  module->Set(env->context(), exports_prop, exports).FromJust();
+  module->Set(env->context(), exports_prop, exports).Check();
 
   if (mod->nm_context_register_func != nullptr) {
     mod->nm_context_register_func(
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 6bc9cfeed3188f..19d2de96b1c057 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -1085,11 +1085,11 @@ void Initialize(Local<Object> target,
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"),
-              Integer::NewFromUnsigned(env->isolate(), kMaxLength)).FromJust();
+              Integer::NewFromUnsigned(env->isolate(), kMaxLength)).Check();
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "kStringMaxLength"),
-              Integer::New(env->isolate(), String::kMaxLength)).FromJust();
+              Integer::New(env->isolate(), String::kMaxLength)).Check();
 
   env->SetMethodNoSideEffect(target, "asciiSlice", StringSlice<ASCII>);
   env->SetMethodNoSideEffect(target, "base64Slice", StringSlice<BASE64>);
diff --git a/src/node_code_cache_stub.cc b/src/node_code_cache_stub.cc
index 4fffa8e0c29557..021910e8298b63 100644
--- a/src/node_code_cache_stub.cc
+++ b/src/node_code_cache_stub.cc
@@ -1,5 +1,5 @@
 
-#include "node_native_module.h"
+#include "node_native_module_env.h"
 
 // This is supposed to be generated by tools/generate_code_cache.js
 // The stub here is used when configure is run without `--code-cache-path`
@@ -8,8 +8,8 @@ namespace node {
 namespace native_module {
 
 // The generated source code would insert <std::string, UnionString> pairs
-// into native_module_loader.code_cache_.
-void NativeModuleLoader::LoadCodeCache() {}
+// into NativeModuleLoader::instance.code_cache_.
+void NativeModuleEnv::InitializeCodeCache() {}
 
 }  // namespace native_module
 }  // namespace node
diff --git a/src/node_constants.cc b/src/node_constants.cc
index 17236fd31db044..bdbef2bfbc54d4 100644
--- a/src/node_constants.cc
+++ b/src/node_constants.cc
@@ -1367,31 +1367,31 @@ void DefineConstants(v8::Isolate* isolate, Local<Object> target) {
 
   os_constants->Set(env->context(),
                     OneByteString(isolate, "dlopen"),
-                    dlopen_constants).FromJust();
+                    dlopen_constants).Check();
   os_constants->Set(env->context(),
                     OneByteString(isolate, "errno"),
-                    err_constants).FromJust();
+                    err_constants).Check();
   os_constants->Set(env->context(),
                     OneByteString(isolate, "signals"),
-                    sig_constants).FromJust();
+                    sig_constants).Check();
   os_constants->Set(env->context(),
                     OneByteString(isolate, "priority"),
-                    priority_constants).FromJust();
+                    priority_constants).Check();
   target->Set(env->context(),
               OneByteString(isolate, "os"),
-              os_constants).FromJust();
+              os_constants).Check();
   target->Set(env->context(),
               OneByteString(isolate, "fs"),
-              fs_constants).FromJust();
+              fs_constants).Check();
   target->Set(env->context(),
               OneByteString(isolate, "crypto"),
-              crypto_constants).FromJust();
+              crypto_constants).Check();
   target->Set(env->context(),
               OneByteString(isolate, "zlib"),
-              zlib_constants).FromJust();
+              zlib_constants).Check();
   target->Set(env->context(),
               OneByteString(isolate, "trace"),
-              trace_constants).FromJust();
+              trace_constants).Check();
 }
 
 }  // namespace node
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index 087727d93a9837..25b8b28ecd54b6 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -405,7 +405,7 @@ void ContextifyContext::PropertySetterCallback(
     args.GetReturnValue().Set(false);
   }
 
-  ctx->sandbox()->Set(ctx->context(), property, value).FromJust();
+  ctx->sandbox()->Set(ctx->context(), property, value).Check();
 }
 
 // static
@@ -469,7 +469,7 @@ void ContextifyContext::PropertyDefinerCallback(
         }
         // Set the property on the sandbox.
         sandbox->DefineProperty(context, property, *desc_for_sandbox)
-            .FromJust();
+            .Check();
       };
 
   if (desc.has_get() || desc.has_set()) {
@@ -620,7 +620,7 @@ void ContextifyScript::Init(Environment* env, Local<Object> target) {
   env->SetProtoMethod(script_tmpl, "runInThisContext", RunInThisContext);
 
   target->Set(env->context(), class_name,
-      script_tmpl->GetFunction(env->context()).ToLocalChecked()).FromJust();
+      script_tmpl->GetFunction(env->context()).ToLocalChecked()).Check();
   env->set_script_context_constructor_template(script_tmpl);
 }
 
@@ -744,7 +744,7 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
     args.This()->Set(
         env->context(),
         env->cached_data_rejected_string(),
-        Boolean::New(isolate, source.GetCachedData()->rejected)).FromJust();
+        Boolean::New(isolate, source.GetCachedData()->rejected)).Check();
   } else if (produce_cached_data) {
     const ScriptCompiler::CachedData* cached_data =
       ScriptCompiler::CreateCodeCache(v8_script.ToLocalChecked());
@@ -756,12 +756,12 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
           cached_data->length);
       args.This()->Set(env->context(),
                        env->cached_data_string(),
-                       buf.ToLocalChecked()).FromJust();
+                       buf.ToLocalChecked()).Check();
     }
     args.This()->Set(
         env->context(),
         env->cached_data_produced_string(),
-        Boolean::New(isolate, cached_data_produced)).FromJust();
+        Boolean::New(isolate, cached_data_produced)).Check();
   }
   TRACE_EVENT_NESTABLE_ASYNC_END0(
       TRACING_CATEGORY_NODE2(vm, script),
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index c62106381023f6..815968cbd2c14a 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -367,7 +367,7 @@ struct CryptoErrorVector : public std::vector<std::string> {
       exception->Set(env->context(),
                      env->openssl_error_stack(),
                      ToV8Value(env->context(), *this).ToLocalChecked())
-          .FromJust();
+          .Check();
     }
 
     return exception_v;
@@ -513,7 +513,7 @@ void SecureContext::Initialize(Environment* env, Local<Object> target) {
       static_cast<PropertyAttribute>(ReadOnly | DontDelete));
 
   target->Set(env->context(), secureContextString,
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
   env->set_secure_context_constructor_template(t);
 }
 
@@ -1756,20 +1756,20 @@ void SSLWrap<Base>::OnClientHello(void* arg,
       env,
       reinterpret_cast<const char*>(hello.session_id()),
       hello.session_size()).ToLocalChecked();
-  hello_obj->Set(context, env->session_id_string(), buff).FromJust();
+  hello_obj->Set(context, env->session_id_string(), buff).Check();
   if (hello.servername() == nullptr) {
     hello_obj->Set(context,
                    env->servername_string(),
-                   String::Empty(env->isolate())).FromJust();
+                   String::Empty(env->isolate())).Check();
   } else {
     Local<String> servername = OneByteString(env->isolate(),
                                              hello.servername(),
                                              hello.servername_size());
-    hello_obj->Set(context, env->servername_string(), servername).FromJust();
+    hello_obj->Set(context, env->servername_string(), servername).Check();
   }
   hello_obj->Set(context,
                  env->tls_ticket_string(),
-                 Boolean::New(env->isolate(), hello.has_ticket())).FromJust();
+                 Boolean::New(env->isolate(), hello.has_ticket())).Check();
 
   Local<Value> argv[] = { hello_obj };
   w->MakeCallback(env->onclienthello_string(), arraysize(argv), argv);
@@ -1872,7 +1872,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
     info->Set(context, env->subject_string(),
               String::NewFromUtf8(env->isolate(), mem->data,
                                   NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).FromJust();
+                                  mem->length).ToLocalChecked()).Check();
   }
   USE(BIO_reset(bio.get()));
 
@@ -1882,7 +1882,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
     info->Set(context, env->issuer_string(),
               String::NewFromUtf8(env->isolate(), mem->data,
                                   NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).FromJust();
+                                  mem->length).ToLocalChecked()).Check();
   }
   USE(BIO_reset(bio.get()));
 
@@ -1906,7 +1906,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
     info->Set(context, keys[i],
               String::NewFromUtf8(env->isolate(), mem->data,
                                   NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).FromJust();
+                                  mem->length).ToLocalChecked()).Check();
 
     USE(BIO_reset(bio.get()));
   }
@@ -1934,12 +1934,12 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
     info->Set(context, env->modulus_string(),
               String::NewFromUtf8(env->isolate(), mem->data,
                                   NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).FromJust();
+                                  mem->length).ToLocalChecked()).Check();
     USE(BIO_reset(bio.get()));
 
     int bits = BN_num_bits(n);
     info->Set(context, env->bits_string(),
-              Integer::New(env->isolate(), bits)).FromJust();
+              Integer::New(env->isolate(), bits)).Check();
 
     uint64_t exponent_word = static_cast<uint64_t>(BN_get_word(e));
     uint32_t lo = static_cast<uint32_t>(exponent_word);
@@ -1953,7 +1953,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
     info->Set(context, env->exponent_string(),
               String::NewFromUtf8(env->isolate(), mem->data,
                                   NewStringType::kNormal,
-                                  mem->length).ToLocalChecked()).FromJust();
+                                  mem->length).ToLocalChecked()).Check();
     USE(BIO_reset(bio.get()));
 
     int size = i2d_RSA_PUBKEY(rsa.get(), nullptr);
@@ -1962,14 +1962,14 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
     unsigned char* pubserialized =
         reinterpret_cast<unsigned char*>(Buffer::Data(pubbuff));
     i2d_RSA_PUBKEY(rsa.get(), &pubserialized);
-    info->Set(env->context(), env->pubkey_string(), pubbuff).FromJust();
+    info->Set(env->context(), env->pubkey_string(), pubbuff).Check();
   } else if (ec) {
     const EC_GROUP* group = EC_KEY_get0_group(ec.get());
     if (group != nullptr) {
       int bits = EC_GROUP_order_bits(group);
       if (bits > 0) {
         info->Set(context, env->bits_string(),
-                  Integer::New(env->isolate(), bits)).FromJust();
+                  Integer::New(env->isolate(), bits)).Check();
       }
     }
 
@@ -1979,7 +1979,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
         ECPointToBuffer(
             env, group, pubkey, EC_KEY_get_conv_form(ec.get()), nullptr)
             .ToLocal(&buf)) {
-      info->Set(context, env->pubkey_string(), buf).FromJust();
+      info->Set(context, env->pubkey_string(), buf).Check();
     }
 
     const int nid = EC_GROUP_get_curve_name(group);
@@ -1988,12 +1988,12 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
 
       if (const char* sn = OBJ_nid2sn(nid)) {
         info->Set(context, env->asn1curve_string(),
-                  OneByteString(env->isolate(), sn)).FromJust();
+                  OneByteString(env->isolate(), sn)).Check();
       }
 
       if (const char* nist = EC_curve_nid2nist(nid)) {
         info->Set(context, env->nistcurve_string(),
-                  OneByteString(env->isolate(), nist)).FromJust();
+                  OneByteString(env->isolate(), nist)).Check();
       }
     } else {
       // Unnamed curves can be described by their mathematical properties,
@@ -2010,7 +2010,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
   info->Set(context, env->valid_from_string(),
             String::NewFromUtf8(env->isolate(), mem->data,
                                 NewStringType::kNormal,
-                                mem->length).ToLocalChecked()).FromJust();
+                                mem->length).ToLocalChecked()).Check();
   USE(BIO_reset(bio.get()));
 
   ASN1_TIME_print(bio.get(), X509_get_notAfter(cert));
@@ -2018,7 +2018,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
   info->Set(context, env->valid_to_string(),
             String::NewFromUtf8(env->isolate(), mem->data,
                                 NewStringType::kNormal,
-                                mem->length).ToLocalChecked()).FromJust();
+                                mem->length).ToLocalChecked()).Check();
   bio.reset();
 
   unsigned char md[EVP_MAX_MD_SIZE];
@@ -2027,12 +2027,12 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
   if (X509_digest(cert, EVP_sha1(), md, &md_size)) {
       AddFingerprintDigest(md, md_size, &fingerprint);
       info->Set(context, env->fingerprint_string(),
-                OneByteString(env->isolate(), fingerprint)).FromJust();
+                OneByteString(env->isolate(), fingerprint)).Check();
   }
   if (X509_digest(cert, EVP_sha256(), md, &md_size)) {
       AddFingerprintDigest(md, md_size, &fingerprint);
       info->Set(context, env->fingerprint256_string(),
-                OneByteString(env->isolate(), fingerprint)).FromJust();
+                OneByteString(env->isolate(), fingerprint)).Check();
   }
 
   StackOfASN1 eku(static_cast<STACK_OF(ASN1_OBJECT)*>(
@@ -2048,12 +2048,12 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
                       sk_ASN1_OBJECT_value(eku.get(), i), 1) >= 0) {
         ext_key_usage->Set(context,
                            j++,
-                           OneByteString(env->isolate(), buf)).FromJust();
+                           OneByteString(env->isolate(), buf)).Check();
       }
     }
 
     eku.reset();
-    info->Set(context, env->ext_key_usage_string(), ext_key_usage).FromJust();
+    info->Set(context, env->ext_key_usage_string(), ext_key_usage).Check();
   }
 
   if (ASN1_INTEGER* serial_number = X509_get_serialNumber(cert)) {
@@ -2062,7 +2062,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
       OpenSSLBuffer buf(BN_bn2hex(bn.get()));
       if (buf) {
         info->Set(context, env->serial_number_string(),
-                  OneByteString(env->isolate(), buf.get())).FromJust();
+                  OneByteString(env->isolate(), buf.get())).Check();
       }
     }
   }
@@ -2073,7 +2073,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
   unsigned char* serialized = reinterpret_cast<unsigned char*>(
       Buffer::Data(buff));
   i2d_X509(cert, &serialized);
-  info->Set(context, env->raw_string(), buff).FromJust();
+  info->Set(context, env->raw_string(), buff).Check();
 
   return scope.Escape(info);
 }
@@ -2093,7 +2093,7 @@ static Local<Object> AddIssuerChainToObject(X509Pointer* cert,
         continue;
 
       Local<Object> ca_info = X509ToObject(env, ca);
-      object->Set(context, env->issuercert_string(), ca_info).FromJust();
+      object->Set(context, env->issuercert_string(), ca_info).Check();
       object = ca_info;
 
       // NOTE: Intentionally freeing cert that is not used anymore.
@@ -2137,7 +2137,7 @@ static Local<Object> GetLastIssuedCert(X509Pointer* cert,
       break;
 
     Local<Object> ca_info = X509ToObject(env, ca);
-    issuer_chain->Set(context, env->issuercert_string(), ca_info).FromJust();
+    issuer_chain->Set(context, env->issuercert_string(), ca_info).Check();
     issuer_chain = ca_info;
 
     // Delete previous cert and continue aggregating issuers.
@@ -2187,7 +2187,7 @@ void SSLWrap<Base>::GetPeerCertificate(
     if (X509_check_issued(cert.get(), cert.get()) == X509_V_OK)
       issuer_chain->Set(env->context(),
                         env->issuercert_string(),
-                        issuer_chain).FromJust();
+                        issuer_chain).Check();
   }
 
  done:
@@ -2437,10 +2437,10 @@ void SSLWrap<Base>::GetEphemeralKeyInfo(
     switch (kid) {
       case EVP_PKEY_DH:
         info->Set(context, env->type_string(),
-                  FIXED_ONE_BYTE_STRING(env->isolate(), "DH")).FromJust();
+                  FIXED_ONE_BYTE_STRING(env->isolate(), "DH")).Check();
         info->Set(context, env->size_string(),
                   Integer::New(env->isolate(), EVP_PKEY_bits(key.get())))
-            .FromJust();
+            .Check();
         break;
       case EVP_PKEY_EC:
       case EVP_PKEY_X25519:
@@ -2456,13 +2456,13 @@ void SSLWrap<Base>::GetEphemeralKeyInfo(
             curve_name = OBJ_nid2sn(kid);
           }
           info->Set(context, env->type_string(),
-                    FIXED_ONE_BYTE_STRING(env->isolate(), "ECDH")).FromJust();
+                    FIXED_ONE_BYTE_STRING(env->isolate(), "ECDH")).Check();
           info->Set(context, env->name_string(),
                     OneByteString(args.GetIsolate(),
-                                  curve_name)).FromJust();
+                                  curve_name)).Check();
           info->Set(context, env->size_string(),
                     Integer::New(env->isolate(),
-                                 EVP_PKEY_bits(key.get()))).FromJust();
+                                 EVP_PKEY_bits(key.get()))).Check();
         }
         break;
       default:
@@ -2551,7 +2551,7 @@ void SSLWrap<Base>::VerifyError(const FunctionCallbackInfo<Value>& args) {
   Local<Object> exception_object =
     exception_value->ToObject(isolate->GetCurrentContext()).ToLocalChecked();
   exception_object->Set(w->env()->context(), w->env()->code_string(),
-                        OneByteString(isolate, code)).FromJust();
+                        OneByteString(isolate, code)).Check();
   args.GetReturnValue().Set(exception_object);
 }
 
@@ -2570,10 +2570,10 @@ void SSLWrap<Base>::GetCipher(const FunctionCallbackInfo<Value>& args) {
   Local<Object> info = Object::New(env->isolate());
   const char* cipher_name = SSL_CIPHER_get_name(c);
   info->Set(context, env->name_string(),
-            OneByteString(args.GetIsolate(), cipher_name)).FromJust();
+            OneByteString(args.GetIsolate(), cipher_name)).Check();
   const char* cipher_version = SSL_CIPHER_get_version(c);
   info->Set(context, env->version_string(),
-            OneByteString(args.GetIsolate(), cipher_version)).FromJust();
+            OneByteString(args.GetIsolate(), cipher_version)).Check();
   args.GetReturnValue().Set(info);
 }
 
@@ -2754,16 +2754,16 @@ int SSLWrap<Base>::SSLCertCallback(SSL* s, void* arg) {
   if (servername == nullptr) {
     info->Set(context,
               env->servername_string(),
-              String::Empty(env->isolate())).FromJust();
+              String::Empty(env->isolate())).Check();
   } else {
     Local<String> str = OneByteString(env->isolate(), servername,
                                       strlen(servername));
-    info->Set(context, env->servername_string(), str).FromJust();
+    info->Set(context, env->servername_string(), str).Check();
   }
 
   const bool ocsp = (SSL_get_tlsext_status_type(s) == TLSEXT_STATUSTYPE_ocsp);
   info->Set(context, env->ocsp_request_string(),
-            Boolean::New(env->isolate(), ocsp)).FromJust();
+            Boolean::New(env->isolate(), ocsp)).Check();
 
   Local<Value> argv[] = { info };
   w->MakeCallback(env->oncertcb_string(), arraysize(argv), argv);
@@ -3570,7 +3570,7 @@ Local<Function> KeyObject::Initialize(Environment* env, Local<Object> target) {
   auto function = t->GetFunction(env->context()).ToLocalChecked();
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "KeyObject"),
-              function).FromJust();
+              function).Check();
 
   return function;
 }
@@ -3782,7 +3782,7 @@ void CipherBase::Initialize(Environment* env, Local<Object> target) {
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "CipherBase"),
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 
@@ -4398,7 +4398,7 @@ void Hmac::Initialize(Environment* env, Local<Object> target) {
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "Hmac"),
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 
@@ -4516,7 +4516,7 @@ void Hash::Initialize(Environment* env, Local<Object> target) {
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "Hash"),
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 
@@ -4714,7 +4714,7 @@ void Sign::Initialize(Environment* env, Local<Object> target) {
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "Sign"),
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 
@@ -4961,7 +4961,7 @@ void Verify::Initialize(Environment* env, Local<Object> target) {
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "Verify"),
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 
@@ -5233,7 +5233,7 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
 
     target->Set(env->context(),
                 name,
-                t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+                t->GetFunction(env->context()).ToLocalChecked()).Check();
   };
 
   make(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellman"), New);
@@ -5567,7 +5567,7 @@ void ECDH::Initialize(Environment* env, Local<Object> target) {
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "ECDH"),
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 
@@ -6464,7 +6464,7 @@ void GetSSLCiphers(const FunctionCallbackInfo<Value>& args) {
     arr->Set(env->context(),
              i,
              OneByteString(args.GetIsolate(),
-                           SSL_CIPHER_get_name(cipher))).FromJust();
+                           SSL_CIPHER_get_name(cipher))).Check();
   }
 
   // TLSv1.3 ciphers aren't listed by EVP. There are only 5, we could just
@@ -6482,7 +6482,7 @@ void GetSSLCiphers(const FunctionCallbackInfo<Value>& args) {
   for (unsigned i = 0; i < arraysize(TLS13_CIPHERS); ++i) {
     const char* name = TLS13_CIPHERS[i];
     arr->Set(env->context(),
-             arr->Length(), OneByteString(args.GetIsolate(), name)).FromJust();
+             arr->Length(), OneByteString(args.GetIsolate(), name)).Check();
   }
 
   args.GetReturnValue().Set(arr);
@@ -6513,7 +6513,7 @@ static void array_push_back(const TypeName* md,
   CipherPushContext* ctx = static_cast<CipherPushContext*>(arg);
   ctx->arr->Set(ctx->env()->context(),
                 ctx->arr->Length(),
-                OneByteString(ctx->env()->isolate(), from)).FromJust();
+                OneByteString(ctx->env()->isolate(), from)).Check();
 }
 
 
@@ -6546,7 +6546,7 @@ void GetCurves(const FunctionCallbackInfo<Value>& args) {
         arr->Set(env->context(),
                  i,
                  OneByteString(env->isolate(),
-                               OBJ_nid2sn(curves[i].nid))).FromJust();
+                               OBJ_nid2sn(curves[i].nid))).Check();
       }
     }
   }
diff --git a/src/node_errors.h b/src/node_errors.h
index 61d9b882212275..4d6e1ab42d4d5d 100644
--- a/src/node_errors.h
+++ b/src/node_errors.h
@@ -70,7 +70,7 @@ void FatalException(v8::Isolate* isolate,
         v8::Exception::type(js_msg)->ToObject(                                \
             isolate->GetCurrentContext()).ToLocalChecked();                   \
     e->Set(isolate->GetCurrentContext(), OneByteString(isolate, "code"),      \
-           js_code).FromJust();                                               \
+           js_code).Check();                                                  \
     return e;                                                                 \
   }                                                                           \
   inline void THROW_ ## code(v8::Isolate* isolate, const char* message) {     \
diff --git a/src/node_file.cc b/src/node_file.cc
index 6cb3c9499f2795..e1acf82408fcf0 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -206,7 +206,7 @@ void FileHandle::CloseReq::Resolve() {
   InternalCallbackScope callback_scope(this);
   Local<Promise> promise = promise_.Get(isolate);
   Local<Promise::Resolver> resolver = promise.As<Promise::Resolver>();
-  resolver->Resolve(env()->context(), Undefined(isolate)).FromJust();
+  resolver->Resolve(env()->context(), Undefined(isolate)).Check();
 }
 
 void FileHandle::CloseReq::Reject(Local<Value> reason) {
@@ -215,7 +215,7 @@ void FileHandle::CloseReq::Reject(Local<Value> reason) {
   InternalCallbackScope callback_scope(this);
   Local<Promise> promise = promise_.Get(isolate);
   Local<Promise::Resolver> resolver = promise.As<Promise::Resolver>();
-  resolver->Reject(env()->context(), reason).FromJust();
+  resolver->Reject(env()->context(), reason).Check();
 }
 
 FileHandle* FileHandle::CloseReq::file_handle() {
@@ -269,7 +269,7 @@ inline MaybeLocal<Promise> FileHandle::ClosePromise() {
   } else {
     // Already closed. Just reject the promise immediately
     resolver->Reject(context, UVException(isolate, UV_EBADF, "close"))
-        .FromJust();
+        .Check();
   }
   return scope.Escape(promise);
 }
@@ -668,11 +668,11 @@ void AfterScanDirWithTypes(uv_fs_t* req) {
   result->Set(env->context(),
               0,
               Array::New(isolate, name_v.data(),
-              name_v.size())).FromJust();
+              name_v.size())).Check();
   result->Set(env->context(),
               1,
               Array::New(isolate, type_v.data(),
-              type_v.size())).FromJust();
+              type_v.size())).Check();
   req_wrap->Resolve(result);
 }
 
@@ -739,10 +739,10 @@ inline int SyncCall(Environment* env, Local<Value> ctx, FSReqWrapSync* req_wrap,
     Isolate* isolate = env->isolate();
     ctx_obj->Set(context,
              env->errno_string(),
-             Integer::New(isolate, err)).FromJust();
+             Integer::New(isolate, err)).Check();
     ctx_obj->Set(context,
              env->syscall_string(),
-             OneByteString(isolate, syscall)).FromJust();
+             OneByteString(isolate, syscall)).Check();
   }
   return err;
 }
@@ -1085,7 +1085,7 @@ static void ReadLink(const FunctionCallbackInfo<Value>& args) {
                                                &error);
     if (rc.IsEmpty()) {
       Local<Object> ctx = args[3].As<Object>();
-      ctx->Set(env->context(), env->error_string(), error).FromJust();
+      ctx->Set(env->context(), env->error_string(), error).Check();
       return;
     }
 
@@ -1434,7 +1434,7 @@ static void RealPath(const FunctionCallbackInfo<Value>& args) {
                                                &error);
     if (rc.IsEmpty()) {
       Local<Object> ctx = args[3].As<Object>();
-      ctx->Set(env->context(), env->error_string(), error).FromJust();
+      ctx->Set(env->context(), env->error_string(), error).Check();
       return;
     }
 
@@ -1490,9 +1490,9 @@ static void ReadDir(const FunctionCallbackInfo<Value>& args) {
       if (r != 0) {
         Local<Object> ctx = args[4].As<Object>();
         ctx->Set(env->context(), env->errno_string(),
-                 Integer::New(isolate, r)).FromJust();
+                 Integer::New(isolate, r)).Check();
         ctx->Set(env->context(), env->syscall_string(),
-                 OneByteString(isolate, "readdir")).FromJust();
+                 OneByteString(isolate, "readdir")).Check();
         return;
       }
 
@@ -1504,7 +1504,7 @@ static void ReadDir(const FunctionCallbackInfo<Value>& args) {
 
       if (filename.IsEmpty()) {
         Local<Object> ctx = args[4].As<Object>();
-        ctx->Set(env->context(), env->error_string(), error).FromJust();
+        ctx->Set(env->context(), env->error_string(), error).Check();
         return;
       }
 
@@ -1519,11 +1519,11 @@ static void ReadDir(const FunctionCallbackInfo<Value>& args) {
     Local<Array> names = Array::New(isolate, name_v.data(), name_v.size());
     if (with_types) {
       Local<Array> result = Array::New(isolate, 2);
-      result->Set(env->context(), 0, names).FromJust();
+      result->Set(env->context(), 0, names).Check();
       result->Set(env->context(),
                   1,
                   Array::New(isolate, type_v.data(),
-                             type_v.size())).FromJust();
+                             type_v.size())).Check();
       args.GetReturnValue().Set(result);
     } else {
       args.GetReturnValue().Set(names);
@@ -2126,7 +2126,7 @@ static void Mkdtemp(const FunctionCallbackInfo<Value>& args) {
         StringBytes::Encode(isolate, path, encoding, &error);
     if (rc.IsEmpty()) {
       Local<Object> ctx = args[3].As<Object>();
-      ctx->Set(env->context(), env->error_string(), error).FromJust();
+      ctx->Set(env->context(), env->error_string(), error).Check();
       return;
     }
     args.GetReturnValue().Set(rc.ToLocalChecked());
@@ -2183,15 +2183,15 @@ void Initialize(Local<Object> target,
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "kFsStatsFieldsNumber"),
               Integer::New(isolate, kFsStatsFieldsNumber))
-        .FromJust();
+        .Check();
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "statValues"),
-              env->fs_stats_field_array()->GetJSArray()).FromJust();
+              env->fs_stats_field_array()->GetJSArray()).Check();
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "bigintStatValues"),
-              env->fs_stats_field_bigint_array()->GetJSArray()).FromJust();
+              env->fs_stats_field_bigint_array()->GetJSArray()).Check();
 
   StatWatcher::Initialize(env, target);
 
@@ -2205,7 +2205,7 @@ void Initialize(Local<Object> target,
   target
       ->Set(context, wrapString,
             fst->GetFunction(env->context()).ToLocalChecked())
-      .FromJust();
+      .Check();
 
   // Create FunctionTemplate for FileHandleReadWrap. There’s no need
   // to do anything in the constructor, so we only store the instance template.
@@ -2242,7 +2242,7 @@ void Initialize(Local<Object> target,
   target
       ->Set(context, handleString,
             fd->GetFunction(env->context()).ToLocalChecked())
-      .FromJust();
+      .Check();
   env->set_fd_constructor_template(fdt);
 
   // Create FunctionTemplate for FileHandle::CloseReq
@@ -2260,7 +2260,7 @@ void Initialize(Local<Object> target,
   env->set_fs_use_promises_symbol(use_promises_symbol);
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "kUsePromises"),
-              use_promises_symbol).FromJust();
+              use_promises_symbol).Check();
 }
 
 }  // namespace fs
diff --git a/src/node_http2.cc b/src/node_http2.cc
index b2666f1c8b6a4e..17c87cd7273f48 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -2530,7 +2530,7 @@ void Http2Session::UpdateChunksSent(const FunctionCallbackInfo<Value>& args) {
 
   session->object()->Set(env->context(),
                          env->chunks_sent_since_last_write_string(),
-                         Integer::NewFromUnsigned(isolate, length)).FromJust();
+                         Integer::NewFromUnsigned(isolate, length)).Check();
 
   args.GetReturnValue().Set(length);
 }
@@ -3015,7 +3015,7 @@ void Initialize(Local<Object> target,
   env->set_http2stream_constructor_template(streamt);
   target->Set(context,
               FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Stream"),
-              stream->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              stream->GetFunction(env->context()).ToLocalChecked()).Check();
 
   Local<FunctionTemplate> session =
       env->NewFunctionTemplate(Http2Session::New);
@@ -3043,7 +3043,7 @@ void Initialize(Local<Object> target,
       Http2Session::RefreshSettings<nghttp2_session_get_remote_settings>);
   target->Set(context,
               http2SessionClassName,
-              session->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              session->GetFunction(env->context()).ToLocalChecked()).Check();
 
   Local<Object> constants = Object::New(isolate);
   Local<Array> name_for_error_code = Array::New(isolate);
@@ -3078,7 +3078,7 @@ void Initialize(Local<Object> target,
   name_for_error_code->Set(env->context(),                              \
                            static_cast<int>(name),                      \
                            FIXED_ONE_BYTE_STRING(isolate,               \
-                                                 #name)).FromJust();
+                                                 #name)).Check();
   NODE_NGHTTP2_ERROR_CODES(V)
 #undef V
 
@@ -3146,10 +3146,10 @@ HTTP_STATUS_CODES(V)
 
   target->Set(context,
               env->constants_string(),
-              constants).FromJust();
+              constants).Check();
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "nameForErrorCode"),
-              name_for_error_code).FromJust();
+              name_for_error_code).Check();
 }
 }  // namespace http2
 }  // namespace node
diff --git a/src/node_http_parser_impl.h b/src/node_http_parser_impl.h
index a2eea3bb3d7ce7..75ea992dda9748 100644
--- a/src/node_http_parser_impl.h
+++ b/src/node_http_parser_impl.h
@@ -733,7 +733,7 @@ class Parser : public AsyncWrap, public StreamListener {
         .ToLocalChecked();
       obj->Set(env()->context(),
                env()->bytes_parsed_string(),
-               nread_obj).FromJust();
+               nread_obj).Check();
 #ifdef NODE_EXPERIMENTAL_HTTP
       const char* errno_reason = llhttp_get_error_reason(&parser_);
 
@@ -750,13 +750,13 @@ class Parser : public AsyncWrap, public StreamListener {
         reason = OneByteString(env()->isolate(), errno_reason);
       }
 
-      obj->Set(env()->context(), env()->code_string(), code).FromJust();
-      obj->Set(env()->context(), env()->reason_string(), reason).FromJust();
+      obj->Set(env()->context(), env()->code_string(), code).Check();
+      obj->Set(env()->context(), env()->reason_string(), reason).Check();
 #else  /* !NODE_EXPERIMENTAL_HTTP */
       obj->Set(env()->context(),
                env()->code_string(),
                OneByteString(env()->isolate(),
-                             http_errno_name(err))).FromJust();
+                             http_errno_name(err))).Check();
 #endif  /* NODE_EXPERIMENTAL_HTTP */
       return scope.Escape(e);
     }
@@ -946,12 +946,12 @@ void InitializeHttpParser(Local<Object> target,
   Local<Array> methods = Array::New(env->isolate());
 #define V(num, name, string)                                                  \
     methods->Set(env->context(),                                              \
-        num, FIXED_ONE_BYTE_STRING(env->isolate(), #string)).FromJust();
+        num, FIXED_ONE_BYTE_STRING(env->isolate(), #string)).Check();
   HTTP_METHOD_MAP(V)
 #undef V
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "methods"),
-              methods).FromJust();
+              methods).Check();
 
   t->Inherit(AsyncWrap::GetConstructorTemplate(env));
   env->SetProtoMethod(t, "close", Parser::Close);
@@ -967,7 +967,7 @@ void InitializeHttpParser(Local<Object> target,
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "HTTPParser"),
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 
 #ifndef NODE_EXPERIMENTAL_HTTP
   static uv_once_t init_once = UV_ONCE_INIT;
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 7fcbde67e0d5eb..77ed959477f289 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -847,9 +847,9 @@ static void MessageChannel(const FunctionCallbackInfo<Value>& args) {
   MessagePort::Entangle(port1, port2);
 
   args.This()->Set(context, env->port1_string(), port1->object())
-      .FromJust();
+      .Check();
   args.This()->Set(context, env->port2_string(), port2->object())
-      .FromJust();
+      .Check();
 }
 
 static void InitMessaging(Local<Object> target,
@@ -865,13 +865,13 @@ static void InitMessaging(Local<Object> target,
     templ->SetClassName(message_channel_string);
     target->Set(context,
                 message_channel_string,
-                templ->GetFunction(context).ToLocalChecked()).FromJust();
+                templ->GetFunction(context).ToLocalChecked()).Check();
   }
 
   target->Set(context,
               env->message_port_constructor_string(),
               GetMessagePortConstructor(env, context).ToLocalChecked())
-                  .FromJust();
+                  .Check();
 
   // These are not methods on the MessagePort prototype, because
   // the browser equivalents do not provide them.
diff --git a/src/node_native_module.cc b/src/node_native_module.cc
index 08c0ab16e3d8fa..814adb620dcf8a 100644
--- a/src/node_native_module.cc
+++ b/src/node_native_module.cc
@@ -1,40 +1,60 @@
 #include "node_native_module.h"
-#include "node_errors.h"
+#include "util-inl.h"
 
 namespace node {
-
-namespace per_process {
-native_module::NativeModuleLoader native_module_loader;
-}  // namespace per_process
-
 namespace native_module {
 
-using v8::Array;
-using v8::ArrayBuffer;
 using v8::Context;
-using v8::DEFAULT;
 using v8::EscapableHandleScope;
 using v8::Function;
-using v8::FunctionCallbackInfo;
 using v8::HandleScope;
 using v8::Integer;
-using v8::IntegrityLevel;
 using v8::Isolate;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
-using v8::Name;
-using v8::None;
 using v8::Object;
-using v8::PropertyCallbackInfo;
 using v8::Script;
 using v8::ScriptCompiler;
 using v8::ScriptOrigin;
-using v8::Set;
-using v8::SideEffectType;
 using v8::String;
-using v8::Uint8Array;
-using v8::Value;
+
+NativeModuleLoader NativeModuleLoader::instance_;
+
+NativeModuleLoader::NativeModuleLoader() : config_(GetConfig()) {
+  LoadJavaScriptSource();
+}
+
+NativeModuleLoader* NativeModuleLoader::GetInstance() {
+  return &instance_;
+}
+
+bool NativeModuleLoader::Exists(const char* id) {
+  return source_.find(id) != source_.end();
+}
+
+Local<Object> NativeModuleLoader::GetSourceObject(Local<Context> context) {
+  Isolate* isolate = context->GetIsolate();
+  Local<Object> out = Object::New(isolate);
+  for (auto const& x : source_) {
+    Local<String> key = OneByteString(isolate, x.first.c_str(), x.first.size());
+    out->Set(context, key, x.second.ToStringChecked(isolate)).FromJust();
+  }
+  return out;
+}
+
+Local<String> NativeModuleLoader::GetConfigString(Isolate* isolate) {
+  return config_.ToStringChecked(isolate);
+}
+
+std::vector<std::string> NativeModuleLoader::GetModuleIds() {
+  std::vector<std::string> ids;
+  ids.reserve(source_.size());
+  for (auto const& x : source_) {
+    ids.emplace_back(x.first);
+  }
+  return ids;
+}
 
 void NativeModuleLoader::InitializeModuleCategories() {
   if (module_categories_.is_initialized) {
@@ -105,182 +125,52 @@ void NativeModuleLoader::InitializeModuleCategories() {
   module_categories_.is_initialized = true;
 }
 
-// TODO(joyeecheung): make these more general and put them into util.h
-Local<Object> MapToObject(Local<Context> context,
-                          const NativeModuleRecordMap& in) {
-  Isolate* isolate = context->GetIsolate();
-  Local<Object> out = Object::New(isolate);
-  for (auto const& x : in) {
-    Local<String> key = OneByteString(isolate, x.first.c_str(), x.first.size());
-    out->Set(context, key, x.second.ToStringChecked(isolate)).FromJust();
-  }
-  return out;
+const std::set<std::string>& NativeModuleLoader::GetCannotBeRequired() {
+  InitializeModuleCategories();
+  return module_categories_.cannot_be_required;
 }
 
-Local<Set> ToJsSet(Local<Context> context,
-                   const std::set<std::string>& in) {
-  Isolate* isolate = context->GetIsolate();
-  Local<Set> out = Set::New(isolate);
-  for (auto const& x : in) {
-    out->Add(context, OneByteString(isolate, x.c_str(), x.size()))
-        .ToLocalChecked();
-  }
-  return out;
+const std::set<std::string>& NativeModuleLoader::GetCanBeRequired() {
+  InitializeModuleCategories();
+  return module_categories_.can_be_required;
 }
 
-bool NativeModuleLoader::Exists(const char* id) {
-  return source_.find(id) != source_.end();
+bool NativeModuleLoader::CanBeRequired(const char* id) {
+  return GetCanBeRequired().count(id) == 1;
 }
 
-void NativeModuleLoader::GetModuleCategories(
-    Local<Name> property, const PropertyCallbackInfo<Value>& info) {
-  per_process::native_module_loader.InitializeModuleCategories();
-
-  Environment* env = Environment::GetCurrent(info);
-  Isolate* isolate = env->isolate();
-  Local<Context> context = env->context();
-  Local<Object> result = Object::New(isolate);
-
-  // Copy from the per-process categories
-  std::set<std::string> cannot_be_required =
-      per_process::native_module_loader.module_categories_.cannot_be_required;
-  std::set<std::string> can_be_required =
-      per_process::native_module_loader.module_categories_.can_be_required;
-
-  if (!env->owns_process_state()) {
-    can_be_required.erase("trace_events");
-    cannot_be_required.insert("trace_events");
-  }
-
-  result
-      ->Set(context,
-            OneByteString(isolate, "cannotBeRequired"),
-            ToJsSet(context, cannot_be_required))
-      .FromJust();
-  result
-      ->Set(context,
-            OneByteString(isolate, "canBeRequired"),
-            ToJsSet(context, can_be_required))
-      .FromJust();
-  info.GetReturnValue().Set(result);
-}
-
-void NativeModuleLoader::GetCacheUsage(
-    const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  Isolate* isolate = env->isolate();
-  Local<Context> context = env->context();
-  Local<Object> result = Object::New(isolate);
-  result
-      ->Set(env->context(),
-            OneByteString(isolate, "compiledWithCache"),
-            ToJsSet(context, env->native_modules_with_cache))
-      .FromJust();
-  result
-      ->Set(env->context(),
-            OneByteString(isolate, "compiledWithoutCache"),
-            ToJsSet(context, env->native_modules_without_cache))
-      .FromJust();
-  args.GetReturnValue().Set(result);
-}
-
-void NativeModuleLoader::ModuleIdsGetter(
-    Local<Name> property, const PropertyCallbackInfo<Value>& info) {
-  Isolate* isolate = info.GetIsolate();
-
-  const NativeModuleRecordMap& source_ =
-      per_process::native_module_loader.source_;
-  std::vector<Local<Value>> ids;
-  ids.reserve(source_.size());
-
-  for (auto const& x : source_) {
-    ids.emplace_back(OneByteString(isolate, x.first.c_str(), x.first.size()));
-  }
-
-  info.GetReturnValue().Set(Array::New(isolate, ids.data(), ids.size()));
-}
-
-void NativeModuleLoader::ConfigStringGetter(
-    Local<Name> property, const PropertyCallbackInfo<Value>& info) {
-  info.GetReturnValue().Set(
-      per_process::native_module_loader.GetConfigString(info.GetIsolate()));
+bool NativeModuleLoader::CannotBeRequired(const char* id) {
+  return GetCannotBeRequired().count(id) == 1;
 }
 
-Local<Object> NativeModuleLoader::GetSourceObject(
-    Local<Context> context) const {
-  return MapToObject(context, source_);
-}
-
-Local<String> NativeModuleLoader::GetConfigString(Isolate* isolate) const {
-  return config_.ToStringChecked(isolate);
+NativeModuleCacheMap* NativeModuleLoader::code_cache() {
+  return &code_cache_;
 }
 
-NativeModuleLoader::NativeModuleLoader() : config_(GetConfig()) {
-  LoadJavaScriptSource();
-  LoadCodeCache();
-}
-
-// This is supposed to be run only by the main thread in
-// tools/generate_code_cache.js
-void NativeModuleLoader::GetCodeCache(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  Isolate* isolate = env->isolate();
-  CHECK(env->is_main_thread());
-
-  CHECK(args[0]->IsString());
-  node::Utf8Value id_v(isolate, args[0].As<String>());
-  const char* id = *id_v;
-
-  const NativeModuleLoader& loader = per_process::native_module_loader;
-  MaybeLocal<Uint8Array> ret = loader.GetCodeCache(isolate, id);
-  if (!ret.IsEmpty()) {
-    args.GetReturnValue().Set(ret.ToLocalChecked());
-  }
-}
-
-// This is supposed to be run only by the main thread in
-// tools/generate_code_cache.js
-MaybeLocal<Uint8Array> NativeModuleLoader::GetCodeCache(Isolate* isolate,
-                                                        const char* id) const {
-  EscapableHandleScope scope(isolate);
+ScriptCompiler::CachedData* NativeModuleLoader::GetCodeCache(
+    const char* id) const {
   Mutex::ScopedLock lock(code_cache_mutex_);
-
-  ScriptCompiler::CachedData* cached_data = nullptr;
   const auto it = code_cache_.find(id);
   if (it == code_cache_.end()) {
     // The module has not been compiled before.
-    return MaybeLocal<Uint8Array>();
-  }
-
-  cached_data = it->second.get();
-
-  Local<ArrayBuffer> buf = ArrayBuffer::New(isolate, cached_data->length);
-  memcpy(buf->GetContents().Data(), cached_data->data, cached_data->length);
-  return scope.Escape(Uint8Array::New(buf, 0, cached_data->length));
-}
-
-void NativeModuleLoader::CompileFunction(
-    const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK(args[0]->IsString());
-  node::Utf8Value id(env->isolate(), args[0].As<String>());
-
-  MaybeLocal<Function> result = CompileAsModule(env, *id);
-  if (!result.IsEmpty()) {
-    args.GetReturnValue().Set(result.ToLocalChecked());
+    return nullptr;
   }
+  return it->second.get();
 }
 
-MaybeLocal<Function> NativeModuleLoader::CompileAsModule(Environment* env,
-                                                         const char* id) {
-  std::vector<Local<String>> parameters = {env->exports_string(),
-                                           env->require_string(),
-                                           env->module_string(),
-                                           env->process_string(),
-                                           env->internal_binding_string(),
-                                           env->primordials_string()};
-  return per_process::native_module_loader.LookupAndCompile(
-      env->context(), id, &parameters, env);
+MaybeLocal<Function> NativeModuleLoader::CompileAsModule(
+    Local<Context> context,
+    const char* id,
+    NativeModuleLoader::Result* result) {
+  Isolate* isolate = context->GetIsolate();
+  std::vector<Local<String>> parameters = {
+      FIXED_ONE_BYTE_STRING(isolate, "exports"),
+      FIXED_ONE_BYTE_STRING(isolate, "require"),
+      FIXED_ONE_BYTE_STRING(isolate, "module"),
+      FIXED_ONE_BYTE_STRING(isolate, "process"),
+      FIXED_ONE_BYTE_STRING(isolate, "internalBinding"),
+      FIXED_ONE_BYTE_STRING(isolate, "primordials")};
+  return LookupAndCompile(context, id, &parameters, result);
 }
 
 // Returns Local<Function> of the compiled module if return_code_cache
@@ -290,7 +180,7 @@ MaybeLocal<Function> NativeModuleLoader::LookupAndCompile(
     Local<Context> context,
     const char* id,
     std::vector<Local<String>>* parameters,
-    Environment* optional_env) {
+    NativeModuleLoader::Result* result) {
   Isolate* isolate = context->GetIsolate();
   EscapableHandleScope scope(isolate);
 
@@ -317,9 +207,9 @@ MaybeLocal<Function> NativeModuleLoader::LookupAndCompile(
     }
   }
 
-  const bool use_cache = cached_data != nullptr;
+  const bool has_cache = cached_data != nullptr;
   ScriptCompiler::CompileOptions options =
-      use_cache ? ScriptCompiler::kConsumeCodeCache
+      has_cache ? ScriptCompiler::kConsumeCodeCache
                 : ScriptCompiler::kEagerCompile;
   ScriptCompiler::Source script_source(source, origin, cached_data);
 
@@ -346,22 +236,10 @@ MaybeLocal<Function> NativeModuleLoader::LookupAndCompile(
   // it only starts after the Environment is created, so the per_context.js
   // will never be in any of these two sets, but the two sets are only for
   // testing anyway.
-  if (use_cache) {
-    if (optional_env != nullptr) {
-      // This could happen when Node is run with any v8 flag, but
-      // the cache is not generated with one
-      if (script_source.GetCachedData()->rejected) {
-        optional_env->native_modules_without_cache.insert(id);
-      } else {
-        optional_env->native_modules_with_cache.insert(id);
-      }
-    }
-  } else {
-    if (optional_env != nullptr) {
-      optional_env->native_modules_without_cache.insert(id);
-    }
-  }
 
+  *result = (has_cache && !script_source.GetCachedData()->rejected)
+                ? Result::kWithCache
+                : Result::kWithoutCache;
   // Generate new cache for next compilation
   std::unique_ptr<ScriptCompiler::CachedData> new_cached_data(
       ScriptCompiler::CreateCodeCacheForFunction(fun));
@@ -373,56 +251,5 @@ MaybeLocal<Function> NativeModuleLoader::LookupAndCompile(
   return scope.Escape(fun);
 }
 
-void NativeModuleLoader::Initialize(Local<Object> target,
-                                    Local<Value> unused,
-                                    Local<Context> context,
-                                    void* priv) {
-  Environment* env = Environment::GetCurrent(context);
-
-  CHECK(target
-            ->SetAccessor(env->context(),
-                          env->config_string(),
-                          ConfigStringGetter,
-                          nullptr,
-                          MaybeLocal<Value>(),
-                          DEFAULT,
-                          None,
-                          SideEffectType::kHasNoSideEffect)
-            .FromJust());
-  CHECK(target
-            ->SetAccessor(env->context(),
-                          FIXED_ONE_BYTE_STRING(env->isolate(), "moduleIds"),
-                          ModuleIdsGetter,
-                          nullptr,
-                          MaybeLocal<Value>(),
-                          DEFAULT,
-                          None,
-                          SideEffectType::kHasNoSideEffect)
-            .FromJust());
-
-  CHECK(target
-            ->SetAccessor(
-                env->context(),
-                FIXED_ONE_BYTE_STRING(env->isolate(), "moduleCategories"),
-                GetModuleCategories,
-                nullptr,
-                env->as_callback_data(),
-                DEFAULT,
-                None,
-                SideEffectType::kHasNoSideEffect)
-            .FromJust());
-
-  env->SetMethod(
-      target, "getCacheUsage", NativeModuleLoader::GetCacheUsage);
-  env->SetMethod(
-      target, "compileFunction", NativeModuleLoader::CompileFunction);
-  env->SetMethod(target, "getCodeCache", NativeModuleLoader::GetCodeCache);
-  // internalBinding('native_module') should be frozen
-  target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
-}
-
 }  // namespace native_module
 }  // namespace node
-
-NODE_MODULE_CONTEXT_AWARE_INTERNAL(
-    native_module, node::native_module::NativeModuleLoader::Initialize)
diff --git a/src/node_native_module.h b/src/node_native_module.h
index 587c59022afc56..bbd4d89c4001cd 100644
--- a/src/node_native_module.h
+++ b/src/node_native_module.h
@@ -4,9 +4,9 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
-#include "env.h"
 #include "node_mutex.h"
 #include "node_union_bytes.h"
 #include "v8.h"
@@ -23,79 +23,57 @@ using NativeModuleCacheMap =
 // handles compilation and caching of builtin modules (NativeModule)
 // and bootstrappers, whose source are bundled into the binary
 // as static data.
-// This class should not depend on a particular isolate, context, or
-// environment. Rather it should take them as arguments when necessary.
-// The instances of this class are per-process.
+// This class should not depend on any Environment, or depend on access to
+// the its own singleton - that should be encapsulated in NativeModuleEnv
+// instead.
 class NativeModuleLoader {
- public:
+ private:
+  // Only allow access from friends.
+  friend class NativeModuleEnv;
+  friend class CodeCacheBuilder;
+
   NativeModuleLoader();
-  // TODO(joyeecheung): maybe we should make this a singleton, instead of
-  // putting it in per_process.
   NativeModuleLoader(const NativeModuleLoader&) = delete;
   NativeModuleLoader& operator=(const NativeModuleLoader&) = delete;
-
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
-  v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context) const;
-  // Returns config.gypi as a JSON string
-  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate) const;
-
-  bool Exists(const char* id);
-
-  // For bootstrappers optional_env may be a nullptr.
-  // If an exception is encountered (e.g. source code contains
-  // syntax error), the returned value is empty.
-  v8::MaybeLocal<v8::Function> LookupAndCompile(
-      v8::Local<v8::Context> context,
-      const char* id,
-      std::vector<v8::Local<v8::String>>* parameters,
-      Environment* optional_env);
-
- private:
-  static void GetModuleCategories(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& info);
-  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
-  // Passing ids of builtin module source code into JS land as
-  // internalBinding('native_module').moduleIds
-  static void ModuleIdsGetter(v8::Local<v8::Name> property,
-                              const v8::PropertyCallbackInfo<v8::Value>& info);
-  // Passing config.gypi into JS land as internalBinding('native_module').config
-  static void ConfigStringGetter(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& info);
-  // Get code cache for a specific native module
-  static void GetCodeCache(const v8::FunctionCallbackInfo<v8::Value>& args);
-  v8::MaybeLocal<v8::Uint8Array> GetCodeCache(v8::Isolate* isolate,
-                                              const char* id) const;
-  // Compile a specific native module as a function
-  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static NativeModuleLoader* GetInstance();
 
   // Generated by tools/js2c.py as node_javascript.cc
   void LoadJavaScriptSource();  // Loads data into source_
   UnionBytes GetConfig();       // Return data for config.gypi
 
-  // Generated by tools/generate_code_cache.js as node_code_cache.cc when
-  // the build is configured with --code-cache-path=.... They are noops
-  // in node_code_cache_stub.cc
-  void LoadCodeCache();      // Loads data into code_cache_
-
-  // Compile a script as a NativeModule that can be loaded via
-  // NativeModule.p.require in JS land.
-  static v8::MaybeLocal<v8::Function> CompileAsModule(Environment* env,
-                                                      const char* id);
+  bool Exists(const char* id);
+  v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
+  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
+  std::vector<std::string> GetModuleIds();
 
-  void InitializeModuleCategories();
   struct ModuleCategories {
     bool is_initialized = false;
     std::set<std::string> can_be_required;
     std::set<std::string> cannot_be_required;
   };
+  void InitializeModuleCategories();
+  const std::set<std::string>& GetCannotBeRequired();
+  const std::set<std::string>& GetCanBeRequired();
 
-  ModuleCategories module_categories_;
+  bool CanBeRequired(const char* id);
+  bool CannotBeRequired(const char* id);
+
+  NativeModuleCacheMap* code_cache();
+  v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
+  enum class Result { kWithCache, kWithoutCache };
+  // If an exception is encountered (e.g. source code contains
+  // syntax error), the returned value is empty.
+  v8::MaybeLocal<v8::Function> LookupAndCompile(
+      v8::Local<v8::Context> context,
+      const char* id,
+      std::vector<v8::Local<v8::String>>* parameters,
+      Result* result);
+  v8::MaybeLocal<v8::Function> CompileAsModule(v8::Local<v8::Context> context,
+                                               const char* id,
+                                               Result* result);
 
+  static NativeModuleLoader instance_;
+  ModuleCategories module_categories_;
   NativeModuleRecordMap source_;
   NativeModuleCacheMap code_cache_;
   UnionBytes config_;
@@ -103,13 +81,8 @@ class NativeModuleLoader {
   // Used to synchronize access to the code cache map
   Mutex code_cache_mutex_;
 };
-
 }  // namespace native_module
 
-namespace per_process {
-extern native_module::NativeModuleLoader native_module_loader;
-}  // namespace per_process
-
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/node_native_module_env.cc b/src/node_native_module_env.cc
new file mode 100644
index 00000000000000..fc48436dc14d44
--- /dev/null
+++ b/src/node_native_module_env.cc
@@ -0,0 +1,229 @@
+#include "node_native_module_env.h"
+#include "env-inl.h"
+
+namespace node {
+namespace native_module {
+
+using v8::ArrayBuffer;
+using v8::Context;
+using v8::DEFAULT;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::IntegrityLevel;
+using v8::Isolate;
+using v8::Local;
+using v8::Maybe;
+using v8::MaybeLocal;
+using v8::Name;
+using v8::None;
+using v8::Object;
+using v8::PropertyCallbackInfo;
+using v8::ScriptCompiler;
+using v8::Set;
+using v8::SideEffectType;
+using v8::String;
+using v8::Uint8Array;
+using v8::Value;
+
+// TODO(joyeecheung): make these more general and put them into util.h
+Local<Set> ToJsSet(Local<Context> context, const std::set<std::string>& in) {
+  Isolate* isolate = context->GetIsolate();
+  Local<Set> out = Set::New(isolate);
+  for (auto const& x : in) {
+    out->Add(context, OneByteString(isolate, x.c_str(), x.size()))
+        .ToLocalChecked();
+  }
+  return out;
+}
+
+bool NativeModuleEnv::Exists(const char* id) {
+  return NativeModuleLoader::GetInstance()->Exists(id);
+}
+
+Local<Object> NativeModuleEnv::GetSourceObject(Local<Context> context) {
+  return NativeModuleLoader::GetInstance()->GetSourceObject(context);
+}
+
+Local<String> NativeModuleEnv::GetConfigString(Isolate* isolate) {
+  return NativeModuleLoader::GetInstance()->GetConfigString(isolate);
+}
+
+void NativeModuleEnv::GetModuleCategories(
+    Local<Name> property, const PropertyCallbackInfo<Value>& info) {
+  Environment* env = Environment::GetCurrent(info);
+  Isolate* isolate = env->isolate();
+  Local<Context> context = env->context();
+  Local<Object> result = Object::New(isolate);
+
+  // Copy from the per-process categories
+  std::set<std::string> cannot_be_required =
+      NativeModuleLoader::GetInstance()->GetCannotBeRequired();
+  std::set<std::string> can_be_required =
+      NativeModuleLoader::GetInstance()->GetCanBeRequired();
+
+  if (!env->owns_process_state()) {
+    can_be_required.erase("trace_events");
+    cannot_be_required.insert("trace_events");
+  }
+
+  result
+      ->Set(context,
+            OneByteString(isolate, "cannotBeRequired"),
+            ToJsSet(context, cannot_be_required))
+      .FromJust();
+  result
+      ->Set(context,
+            OneByteString(isolate, "canBeRequired"),
+            ToJsSet(context, can_be_required))
+      .FromJust();
+  info.GetReturnValue().Set(result);
+}
+
+void NativeModuleEnv::GetCacheUsage(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+  Local<Context> context = env->context();
+  Local<Object> result = Object::New(isolate);
+  result
+      ->Set(env->context(),
+            OneByteString(isolate, "compiledWithCache"),
+            ToJsSet(context, env->native_modules_with_cache))
+      .FromJust();
+  result
+      ->Set(env->context(),
+            OneByteString(isolate, "compiledWithoutCache"),
+            ToJsSet(context, env->native_modules_without_cache))
+      .FromJust();
+  args.GetReturnValue().Set(result);
+}
+
+void NativeModuleEnv::ModuleIdsGetter(Local<Name> property,
+                                      const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+
+  std::vector<std::string> ids =
+      NativeModuleLoader::GetInstance()->GetModuleIds();
+  info.GetReturnValue().Set(
+      ToV8Value(isolate->GetCurrentContext(), ids).ToLocalChecked());
+}
+
+void NativeModuleEnv::ConfigStringGetter(
+    Local<Name> property, const PropertyCallbackInfo<Value>& info) {
+  info.GetReturnValue().Set(GetConfigString(info.GetIsolate()));
+}
+
+void NativeModuleEnv::RecordResult(const char* id,
+                                   NativeModuleLoader::Result result,
+                                   Environment* env) {
+  if (result == NativeModuleLoader::Result::kWithCache) {
+    env->native_modules_with_cache.insert(id);
+  } else {
+    env->native_modules_without_cache.insert(id);
+  }
+}
+void NativeModuleEnv::CompileFunction(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args[0]->IsString());
+  node::Utf8Value id_v(env->isolate(), args[0].As<String>());
+  const char* id = *id_v;
+  NativeModuleLoader::Result result;
+  MaybeLocal<Function> maybe =
+      NativeModuleLoader::GetInstance()->CompileAsModule(
+          env->context(), id, &result);
+  RecordResult(id, result, env);
+  if (!maybe.IsEmpty()) {
+    args.GetReturnValue().Set(maybe.ToLocalChecked());
+  }
+}
+
+// Returns Local<Function> of the compiled module if return_code_cache
+// is false (we are only compiling the function).
+// Otherwise return a Local<Object> containing the cache.
+MaybeLocal<Function> NativeModuleEnv::LookupAndCompile(
+    Local<Context> context,
+    const char* id,
+    std::vector<Local<String>>* parameters,
+    Environment* optional_env) {
+  NativeModuleLoader::Result result;
+  MaybeLocal<Function> maybe =
+      NativeModuleLoader::GetInstance()->LookupAndCompile(
+          context, id, parameters, &result);
+  if (optional_env != nullptr) {
+    RecordResult(id, result, optional_env);
+  }
+  return maybe;
+}
+
+// This is supposed to be run only by the main thread in
+// tools/generate_code_cache.js
+void NativeModuleEnv::GetCodeCache(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+  CHECK(env->is_main_thread());
+
+  CHECK(args[0]->IsString());
+  node::Utf8Value id_v(isolate, args[0].As<String>());
+  const char* id = *id_v;
+
+  ScriptCompiler::CachedData* cached_data =
+      NativeModuleLoader::GetInstance()->GetCodeCache(id);
+  if (cached_data != nullptr) {
+    Local<ArrayBuffer> buf = ArrayBuffer::New(isolate, cached_data->length);
+    memcpy(buf->GetContents().Data(), cached_data->data, cached_data->length);
+    args.GetReturnValue().Set(Uint8Array::New(buf, 0, cached_data->length));
+  }
+}
+
+// TODO(joyeecheung): It is somewhat confusing that Class::Initialize
+// is used to initilaize to the binding, but it is the current convention.
+// Rename this across the code base to something that makes more sense.
+void NativeModuleEnv::Initialize(Local<Object> target,
+                                 Local<Value> unused,
+                                 Local<Context> context,
+                                 void* priv) {
+  Environment* env = Environment::GetCurrent(context);
+
+  target
+      ->SetAccessor(env->context(),
+                    env->config_string(),
+                    ConfigStringGetter,
+                    nullptr,
+                    MaybeLocal<Value>(),
+                    DEFAULT,
+                    None,
+                    SideEffectType::kHasNoSideEffect)
+      .Check();
+  target
+      ->SetAccessor(env->context(),
+                    FIXED_ONE_BYTE_STRING(env->isolate(), "moduleIds"),
+                    ModuleIdsGetter,
+                    nullptr,
+                    MaybeLocal<Value>(),
+                    DEFAULT,
+                    None,
+                    SideEffectType::kHasNoSideEffect)
+      .Check();
+
+  target
+      ->SetAccessor(env->context(),
+                    FIXED_ONE_BYTE_STRING(env->isolate(), "moduleCategories"),
+                    GetModuleCategories,
+                    nullptr,
+                    env->as_callback_data(),
+                    DEFAULT,
+                    None,
+                    SideEffectType::kHasNoSideEffect)
+      .Check();
+
+  env->SetMethod(target, "getCacheUsage", NativeModuleEnv::GetCacheUsage);
+  env->SetMethod(target, "getCodeCache", NativeModuleEnv::GetCodeCache);
+  env->SetMethod(target, "compileFunction", NativeModuleEnv::CompileFunction);
+  // internalBinding('native_module') should be frozen
+  target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
+}
+
+}  // namespace native_module
+}  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(
+    native_module, node::native_module::NativeModuleEnv::Initialize)
diff --git a/src/node_native_module_env.h b/src/node_native_module_env.h
new file mode 100644
index 00000000000000..2b1fabf89b9776
--- /dev/null
+++ b/src/node_native_module_env.h
@@ -0,0 +1,64 @@
+#ifndef SRC_NODE_NATIVE_MODULE_ENV_H_
+#define SRC_NODE_NATIVE_MODULE_ENV_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_native_module.h"
+
+namespace node {
+class Environment;
+
+namespace native_module {
+
+class NativeModuleEnv {
+ public:
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+
+  static v8::MaybeLocal<v8::Function> LookupAndCompile(
+      v8::Local<v8::Context> context,
+      const char* id,
+      std::vector<v8::Local<v8::String>>* parameters,
+      Environment* optional_env);
+
+  static v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
+  // Returns config.gypi as a JSON string
+  static v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
+  static bool Exists(const char* id);
+
+  // Loads data into NativeModuleLoader::.instance.code_cache_
+  // Generated by mkcodecache as node_code_cache.cc when
+  // the build is configured with --code-cache-path=.... They are noops
+  // in node_code_cache_stub.cc
+  static void InitializeCodeCache();
+
+ private:
+  static void RecordResult(const char* id,
+                           NativeModuleLoader::Result result,
+                           Environment* env);
+  static void GetModuleCategories(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Passing ids of builtin module source code into JS land as
+  // internalBinding('native_module').moduleIds
+  static void ModuleIdsGetter(v8::Local<v8::Name> property,
+                              const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Passing config.gypi into JS land as internalBinding('native_module').config
+  static void ConfigStringGetter(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Compile a specific native module as a function
+  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCodeCache(const v8::FunctionCallbackInfo<v8::Value>& args);
+};
+
+}  // namespace native_module
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_NATIVE_MODULE_ENV_H_
diff --git a/src/node_options.cc b/src/node_options.cc
index 31dca5bf176e54..c307c66a621d28 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -273,6 +273,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "experimental frozen intrinsics support",
             &EnvironmentOptions::frozen_intrinsics,
             kAllowedInEnvironment);
+  AddOption("--heapsnapshot-signal",
+            "Generate heap snapshot on specified signal",
+            &EnvironmentOptions::heap_snapshot_signal,
+            kAllowedInEnvironment);
   AddOption("--http-parser",
             "Select which HTTP parser to use; either 'legacy' or 'llhttp' "
             "(default: llhttp).",
@@ -755,7 +759,7 @@ void Initialize(Local<Object> target,
   target
       ->Set(
           context, FIXED_ONE_BYTE_STRING(isolate, "envSettings"), env_settings)
-      .FromJust();
+      .Check();
 
   Local<Object> types = Object::New(isolate);
   NODE_DEFINE_CONSTANT(types, kNoOp);
@@ -767,7 +771,7 @@ void Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(types, kHostPort);
   NODE_DEFINE_CONSTANT(types, kStringList);
   target->Set(context, FIXED_ONE_BYTE_STRING(isolate, "types"), types)
-      .FromJust();
+      .Check();
 }
 
 }  // namespace options_parser
diff --git a/src/node_options.h b/src/node_options.h
index e07ee7fb353065..59baea562a90ca 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -100,6 +100,7 @@ class EnvironmentOptions : public Options {
   bool experimental_vm_modules = false;
   bool expose_internals = false;
   bool frozen_intrinsics = false;
+  std::string heap_snapshot_signal;
   std::string http_parser = "llhttp";
   bool no_deprecation = false;
   bool no_force_async_hooks_checks = false;
diff --git a/src/node_os.cc b/src/node_os.cc
index 6ba4e54a3be649..5dd314690040a3 100644
--- a/src/node_os.cc
+++ b/src/node_os.cc
@@ -325,17 +325,17 @@ static void GetUserInfo(const FunctionCallbackInfo<Value>& args) {
 
   Local<Object> entry = Object::New(env->isolate());
 
-  entry->Set(env->context(), env->uid_string(), uid).FromJust();
-  entry->Set(env->context(), env->gid_string(), gid).FromJust();
+  entry->Set(env->context(), env->uid_string(), uid).Check();
+  entry->Set(env->context(), env->gid_string(), gid).Check();
   entry->Set(env->context(),
              env->username_string(),
-             username.ToLocalChecked()).FromJust();
+             username.ToLocalChecked()).Check();
   entry->Set(env->context(),
              env->homedir_string(),
-             homedir.ToLocalChecked()).FromJust();
+             homedir.ToLocalChecked()).Check();
   entry->Set(env->context(),
              env->shell_string(),
-             shell.ToLocalChecked()).FromJust();
+             shell.ToLocalChecked()).Check();
 
   args.GetReturnValue().Set(entry);
 }
@@ -401,7 +401,7 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "getPriority", GetPriority);
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "isBigEndian"),
-              Boolean::New(env->isolate(), IsBigEndian())).FromJust();
+              Boolean::New(env->isolate(), IsBigEndian())).Check();
 }
 
 }  // namespace os
diff --git a/src/node_perf.cc b/src/node_perf.cc
index 393c4747f9a883..b9e1c0cb9ca487 100644
--- a/src/node_perf.cc
+++ b/src/node_perf.cc
@@ -65,7 +65,7 @@ inline void InitObject(const PerformanceEntry& entry, Local<Object> obj) {
                                              NewStringType::kNormal)
                              .ToLocalChecked(),
                          attr)
-      .FromJust();
+      .Check();
   obj->DefineOwnProperty(context,
                          env->entry_type_string(),
                          String::NewFromUtf8(isolate,
@@ -73,15 +73,15 @@ inline void InitObject(const PerformanceEntry& entry, Local<Object> obj) {
                                              NewStringType::kNormal)
                              .ToLocalChecked(),
                          attr)
-      .FromJust();
+      .Check();
   obj->DefineOwnProperty(context,
                          env->start_time_string(),
                          Number::New(isolate, entry.startTime()),
-                         attr).FromJust();
+                         attr).Check();
   obj->DefineOwnProperty(context,
                          env->duration_string(),
                          Number::New(isolate, entry.duration()),
-                         attr).FromJust();
+                         attr).Check();
 }
 
 // Create a new PerformanceEntry object
@@ -245,7 +245,7 @@ void PerformanceGCCallback(Environment* env, void* ptr) {
     obj->DefineOwnProperty(context,
                            env->kind_string(),
                            Integer::New(env->isolate(), entry->gckind()),
-                           attr).FromJust();
+                           attr).Check();
     PerformanceEntry::Notify(env, entry->kind(), obj);
   }
 }
@@ -351,7 +351,7 @@ void TimerFunctionCall(const FunctionCallbackInfo<Value>& args) {
   Local<Object> obj;
   if (!entry.ToObject().ToLocal(&obj)) return;
   for (idx = 0; idx < count; idx++)
-    obj->Set(context, idx, args[idx]).FromJust();
+    obj->Set(context, idx, args[idx]).Check();
   PerformanceEntry::Notify(env, entry.kind(), obj);
 }
 
@@ -542,10 +542,10 @@ void Initialize(Local<Object> target,
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "observerCounts"),
-              state->observers.GetJSArray()).FromJust();
+              state->observers.GetJSArray()).Check();
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "milestones"),
-              state->milestones.GetJSArray()).FromJust();
+              state->milestones.GetJSArray()).Check();
 
   Local<String> performanceEntryString =
       FIXED_ONE_BYTE_STRING(isolate, "PerformanceEntry");
@@ -553,7 +553,7 @@ void Initialize(Local<Object> target,
   Local<FunctionTemplate> pe = FunctionTemplate::New(isolate);
   pe->SetClassName(performanceEntryString);
   Local<Function> fn = pe->GetFunction(context).ToLocalChecked();
-  target->Set(context, performanceEntryString, fn).FromJust();
+  target->Set(context, performanceEntryString, fn).Check();
   env->set_performance_entry_template(fn);
 
   env->SetMethod(target, "clearMark", ClearMark);
@@ -617,7 +617,7 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(eldh, "disable", ELDHistogramDisable);
   env->SetProtoMethod(eldh, "reset", ELDHistogramReset);
   target->Set(context, eldh_classname,
-              eldh->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              eldh->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 }  // namespace performance
diff --git a/src/node_process_object.cc b/src/node_process_object.cc
index 04d0c44add9afb..e533245703e8cc 100644
--- a/src/node_process_object.cc
+++ b/src/node_process_object.cc
@@ -157,13 +157,13 @@ void PatchProcessObject(const FunctionCallbackInfo<Value>& args) {
   // process.argv
   process->Set(context,
                FIXED_ONE_BYTE_STRING(isolate, "argv"),
-               ToV8Value(context, env->argv()).ToLocalChecked()).FromJust();
+               ToV8Value(context, env->argv()).ToLocalChecked()).Check();
 
   // process.execArgv
   process->Set(context,
                FIXED_ONE_BYTE_STRING(isolate, "execArgv"),
                ToV8Value(context, env->exec_argv())
-                   .ToLocalChecked()).FromJust();
+                   .ToLocalChecked()).Check();
 
   READONLY_PROPERTY(process, "pid",
                     Integer::New(isolate, uv_os_getpid()));
@@ -212,7 +212,7 @@ void PatchProcessObject(const FunctionCallbackInfo<Value>& args) {
                                   NewStringType::kInternalized,
                                   exec_path.size())
                   .ToLocalChecked())
-        .FromJust();
+        .Check();
   }
 
   // process.debugPort
diff --git a/src/node_serdes.cc b/src/node_serdes.cc
index 12ed313b033987..682f90f0c3d0df 100644
--- a/src/node_serdes.cc
+++ b/src/node_serdes.cc
@@ -284,7 +284,7 @@ DeserializerContext::DeserializerContext(Environment* env,
     data_(reinterpret_cast<const uint8_t*>(Buffer::Data(buffer))),
     length_(Buffer::Length(buffer)),
     deserializer_(env->isolate(), data_, length_, this) {
-  object()->Set(env->context(), env->buffer_string(), buffer).FromJust();
+  object()->Set(env->context(), env->buffer_string(), buffer).Check();
   deserializer_.SetExpectInlineWasm(true);
 
   MakeWeak();
@@ -471,7 +471,7 @@ void Initialize(Local<Object> target,
   ser->SetClassName(serializerString);
   target->Set(env->context(),
               serializerString,
-              ser->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              ser->GetFunction(env->context()).ToLocalChecked()).Check();
 
   Local<FunctionTemplate> des =
       env->NewFunctionTemplate(DeserializerContext::New);
@@ -496,7 +496,7 @@ void Initialize(Local<Object> target,
   des->SetClassName(deserializerString);
   target->Set(env->context(),
               deserializerString,
-              des->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              des->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 }  // anonymous namespace
diff --git a/src/node_stat_watcher.cc b/src/node_stat_watcher.cc
index f673c4085e54e1..e4346678c01980 100644
--- a/src/node_stat_watcher.cc
+++ b/src/node_stat_watcher.cc
@@ -55,7 +55,7 @@ void StatWatcher::Initialize(Environment* env, Local<Object> target) {
   env->SetProtoMethod(t, "start", StatWatcher::Start);
 
   target->Set(env->context(), statWatcherString,
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 
diff --git a/src/node_symbols.cc b/src/node_symbols.cc
index 36289b9f4148ae..af660b0a8e8377 100644
--- a/src/node_symbols.cc
+++ b/src/node_symbols.cc
@@ -18,7 +18,7 @@ static void Initialize(Local<Object> target,
 #define V(PropertyName, StringValue)                                           \
   target                                                                       \
       ->Set(env->context(), env->PropertyName()->Name(), env->PropertyName())  \
-      .FromJust();
+      .Check();
   PER_ISOLATE_SYMBOL_PROPERTIES(V)
 #undef V
 }
diff --git a/src/node_task_queue.cc b/src/node_task_queue.cc
index 64709f531d71c6..b14c806dec04be 100644
--- a/src/node_task_queue.cc
+++ b/src/node_task_queue.cc
@@ -131,7 +131,7 @@ static void Initialize(Local<Object> target,
   env->SetMethod(target, "runMicrotasks", RunMicrotasks);
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(isolate, "tickInfo"),
-              env->tick_info()->fields().GetJSArray()).FromJust();
+              env->tick_info()->fields().GetJSArray()).Check();
 
   Local<Object> events = Object::New(isolate);
   NODE_DEFINE_CONSTANT(events, kPromiseRejectWithNoHandler);
@@ -141,7 +141,7 @@ static void Initialize(Local<Object> target,
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"),
-              events).FromJust();
+              events).Check();
   env->SetMethod(target,
                  "setPromiseRejectCallback",
                  SetPromiseRejectCallback);
diff --git a/src/node_trace_events.cc b/src/node_trace_events.cc
index 1fad37743fb418..74ba5bb4800d67 100644
--- a/src/node_trace_events.cc
+++ b/src/node_trace_events.cc
@@ -134,7 +134,7 @@ void NodeCategorySet::Initialize(Local<Object> target,
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "CategorySet"),
               category_set->GetFunction(env->context()).ToLocalChecked())
-              .FromJust();
+              .Check();
 
   Local<String> isTraceCategoryEnabled =
       FIXED_ONE_BYTE_STRING(env->isolate(), "isTraceCategoryEnabled");
@@ -145,9 +145,9 @@ void NodeCategorySet::Initialize(Local<Object> target,
   Local<Object> binding = context->GetExtrasBindingObject();
   target->Set(context, isTraceCategoryEnabled,
               binding->Get(context, isTraceCategoryEnabled).ToLocalChecked())
-                  .FromJust();
+                  .Check();
   target->Set(context, trace,
-              binding->Get(context, trace).ToLocalChecked()).FromJust();
+              binding->Get(context, trace).ToLocalChecked()).Check();
 }
 
 }  // namespace node
diff --git a/src/node_union_bytes.h b/src/node_union_bytes.h
index 0034f184cc38ca..996d9880a48224 100644
--- a/src/node_union_bytes.h
+++ b/src/node_union_bytes.h
@@ -7,7 +7,6 @@
 // A union of const uint8_t* or const uint16_t* data that can be
 // turned into external v8::String when given an isolate.
 
-#include "env.h"
 #include "v8.h"
 
 namespace node {
diff --git a/src/node_util.cc b/src/node_util.cc
index b1cdc11a998ea3..960e194f76711a 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -220,7 +220,7 @@ void Initialize(Local<Object> target,
 #define V(name, _)                                                            \
   target->Set(context,                                                        \
               FIXED_ONE_BYTE_STRING(env->isolate(), #name),                   \
-              Integer::NewFromUnsigned(env->isolate(), index++)).FromJust();
+              Integer::NewFromUnsigned(env->isolate(), index++)).Check();
   {
     uint32_t index = 0;
     PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)
@@ -261,7 +261,7 @@ void Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(constants, SKIP_SYMBOLS);
   target->Set(context,
               FIXED_ONE_BYTE_STRING(env->isolate(), "propertyFilter"),
-              constants).FromJust();
+              constants).Check();
 
   Local<String> should_abort_on_uncaught_toggle =
       FIXED_ONE_BYTE_STRING(env->isolate(), "shouldAbortOnUncaughtToggle");
@@ -279,7 +279,7 @@ void Initialize(Local<Object> target,
   weak_ref->SetClassName(weak_ref_string);
   env->SetProtoMethod(weak_ref, "get", WeakReference::Get);
   target->Set(context, weak_ref_string,
-              weak_ref->GetFunction(context).ToLocalChecked()).FromJust();
+              weak_ref->GetFunction(context).ToLocalChecked()).Check();
 }
 
 }  // namespace util
diff --git a/src/node_v8.cc b/src/node_v8.cc
index 8ed0e416702e0b..5adc53b84d87c4 100644
--- a/src/node_v8.cc
+++ b/src/node_v8.cc
@@ -139,12 +139,12 @@ void Initialize(Local<Object> target,
                                     "heapStatisticsArrayBuffer"),
               ArrayBuffer::New(env->isolate(),
                                env->heap_statistics_buffer(),
-                               heap_statistics_buffer_byte_length)).FromJust();
+                               heap_statistics_buffer_byte_length)).Check();
 
 #define V(i, _, name)                                                         \
   target->Set(env->context(),                                                 \
               FIXED_ONE_BYTE_STRING(env->isolate(), #name),                   \
-              Uint32::NewFromUnsigned(env->isolate(), i)).FromJust();
+              Uint32::NewFromUnsigned(env->isolate(), i)).Check();
 
   HEAP_STATISTICS_PROPERTIES(V)
 #undef V
@@ -154,7 +154,7 @@ void Initialize(Local<Object> target,
                                     "kHeapSpaceStatisticsPropertiesCount"),
               Uint32::NewFromUnsigned(env->isolate(),
                                       kHeapSpaceStatisticsPropertiesCount))
-              .FromJust();
+              .Check();
 
   size_t number_of_heap_spaces = env->isolate()->NumberOfHeapSpaces();
 
@@ -169,11 +169,11 @@ void Initialize(Local<Object> target,
                                                         s.space_name(),
                                                         NewStringType::kNormal)
                                         .ToLocalChecked();
-    heap_spaces->Set(env->context(), i, heap_space_name).FromJust();
+    heap_spaces->Set(env->context(), i, heap_space_name).Check();
   }
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "kHeapSpaces"),
-              heap_spaces).FromJust();
+              heap_spaces).Check();
 
   env->SetMethod(target,
                  "updateHeapSpaceStatisticsArrayBuffer",
@@ -193,12 +193,12 @@ void Initialize(Local<Object> target,
               ArrayBuffer::New(env->isolate(),
                                env->heap_space_statistics_buffer(),
                                heap_space_statistics_buffer_byte_length))
-              .FromJust();
+              .Check();
 
 #define V(i, _, name)                                                         \
   target->Set(env->context(),                                                 \
               FIXED_ONE_BYTE_STRING(env->isolate(), #name),                   \
-              Uint32::NewFromUnsigned(env->isolate(), i)).FromJust();
+              Uint32::NewFromUnsigned(env->isolate(), i)).Check();
 
   HEAP_SPACE_STATISTICS_PROPERTIES(V)
 #undef V
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 7de9c355f65b6b..bdf324fa047624 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -84,12 +84,12 @@ Worker::Worker(Environment* env,
 
   object()->Set(env->context(),
                 env->message_port_string(),
-                parent_port_->object()).FromJust();
+                parent_port_->object()).Check();
 
   object()->Set(env->context(),
                 env->thread_id_string(),
                 Number::New(env->isolate(), static_cast<double>(thread_id_)))
-      .FromJust();
+      .Check();
 
 #if NODE_USE_V8_PLATFORM && HAVE_INSPECTOR
   inspector_parent_handle_ =
@@ -372,7 +372,7 @@ void Worker::OnThreadStopped() {
     // Reset the parent port as we're closing it now anyway.
     object()->Set(env()->context(),
                   env()->message_port_string(),
-                  Undefined(env()->isolate())).FromJust();
+                  Undefined(env()->isolate())).Check();
 
     Local<Value> code = Integer::New(env()->isolate(), exit_code_);
     MakeCallback(env()->onexit_string(), 1, &code);
@@ -602,7 +602,7 @@ void InitWorker(Local<Object> target,
     w->SetClassName(workerString);
     target->Set(env->context(),
                 workerString,
-                w->GetFunction(env->context()).ToLocalChecked()).FromJust();
+                w->GetFunction(env->context()).ToLocalChecked()).Check();
   }
 
   env->SetMethod(target, "getEnvMessagePort", GetEnvMessagePort);
@@ -611,19 +611,19 @@ void InitWorker(Local<Object> target,
       ->Set(env->context(),
             env->thread_id_string(),
             Number::New(env->isolate(), static_cast<double>(env->thread_id())))
-      .FromJust();
+      .Check();
 
   target
       ->Set(env->context(),
             FIXED_ONE_BYTE_STRING(env->isolate(), "isMainThread"),
             Boolean::New(env->isolate(), env->is_main_thread()))
-      .FromJust();
+      .Check();
 
   target
       ->Set(env->context(),
             FIXED_ONE_BYTE_STRING(env->isolate(), "ownsProcessState"),
             Boolean::New(env->isolate(), env->owns_process_state()))
-      .FromJust();
+      .Check();
 }
 
 }  // anonymous namespace
diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index e333576aa5c87c..b5abcfa5850833 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -1225,7 +1225,7 @@ struct MakeClass {
     z->SetClassName(zlibString);
     target->Set(env->context(),
                 zlibString,
-                z->GetFunction(env->context()).ToLocalChecked()).FromJust();
+                z->GetFunction(env->context()).ToLocalChecked()).Check();
   }
 };
 
@@ -1241,7 +1241,7 @@ void Initialize(Local<Object> target,
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "ZLIB_VERSION"),
-              FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION)).FromJust();
+              FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION)).Check();
 }
 
 }  // anonymous namespace
diff --git a/src/pipe_wrap.cc b/src/pipe_wrap.cc
index cafa33f9af14bf..26ccfd8a47caee 100644
--- a/src/pipe_wrap.cc
+++ b/src/pipe_wrap.cc
@@ -90,7 +90,7 @@ void PipeWrap::Initialize(Local<Object> target,
 
   target->Set(env->context(),
               pipeString,
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
   env->set_pipe_constructor_template(t);
 
   // Create FunctionTemplate for PipeConnectWrap.
@@ -101,7 +101,7 @@ void PipeWrap::Initialize(Local<Object> target,
   cwt->SetClassName(wrapString);
   target->Set(env->context(),
               wrapString,
-              cwt->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              cwt->GetFunction(env->context()).ToLocalChecked()).Check();
 
   // Define constants
   Local<Object> constants = Object::New(env->isolate());
@@ -112,7 +112,7 @@ void PipeWrap::Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(constants, UV_WRITABLE);
   target->Set(context,
               env->constants_string(),
-              constants).FromJust();
+              constants).Check();
 }
 
 
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index 583851cdbb53d2..a75f271d1c77b8 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -64,7 +64,7 @@ class ProcessWrap : public HandleWrap {
 
     target->Set(env->context(),
                 processString,
-                constructor->GetFunction(context).ToLocalChecked()).FromJust();
+                constructor->GetFunction(context).ToLocalChecked()).Check();
   }
 
   SET_NO_MEMORY_INFO()
@@ -261,7 +261,7 @@ class ProcessWrap : public HandleWrap {
       CHECK_EQ(wrap->process_.data, wrap);
       wrap->object()->Set(context, env->pid_string(),
                           Integer::New(env->isolate(),
-                                       wrap->process_.pid)).FromJust();
+                                       wrap->process_.pid)).Check();
     }
 
     if (options.args) {
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index ba5ceb95025fd0..90b91f35a86c8b 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -59,7 +59,7 @@ class SignalWrap : public HandleWrap {
 
     target->Set(env->context(), signalString,
                 constructor->GetFunction(env->context()).ToLocalChecked())
-                .FromJust();
+                .Check();
   }
 
   SET_NO_MEMORY_INFO()
diff --git a/src/spawn_sync.cc b/src/spawn_sync.cc
index 6e5c3360cd495d..fb233a07daa0eb 100644
--- a/src/spawn_sync.cc
+++ b/src/spawn_sync.cc
@@ -677,22 +677,22 @@ Local<Object> SyncProcessRunner::BuildResultObject() {
 
   if (GetError() != 0) {
     js_result->Set(context, env()->error_string(),
-                   Integer::New(env()->isolate(), GetError())).FromJust();
+                   Integer::New(env()->isolate(), GetError())).Check();
   }
 
   if (exit_status_ >= 0) {
     if (term_signal_ > 0) {
       js_result->Set(context, env()->status_string(),
-                     Null(env()->isolate())).FromJust();
+                     Null(env()->isolate())).Check();
     } else {
       js_result->Set(context, env()->status_string(),
                      Number::New(env()->isolate(),
-                                 static_cast<double>(exit_status_))).FromJust();
+                                 static_cast<double>(exit_status_))).Check();
     }
   } else {
     // If exit_status_ < 0 the process was never started because of some error.
     js_result->Set(context, env()->status_string(),
-                   Null(env()->isolate())).FromJust();
+                   Null(env()->isolate())).Check();
   }
 
   if (term_signal_ > 0)
@@ -701,20 +701,20 @@ Local<Object> SyncProcessRunner::BuildResultObject() {
                                        signo_string(term_signal_),
                                        v8::NewStringType::kNormal)
                        .ToLocalChecked())
-        .FromJust();
+        .Check();
   else
     js_result->Set(context, env()->signal_string(),
-                   Null(env()->isolate())).FromJust();
+                   Null(env()->isolate())).Check();
 
   if (exit_status_ >= 0)
     js_result->Set(context, env()->output_string(),
-                   BuildOutputArray()).FromJust();
+                   BuildOutputArray()).Check();
   else
     js_result->Set(context, env()->output_string(),
-                   Null(env()->isolate())).FromJust();
+                   Null(env()->isolate())).Check();
 
   js_result->Set(context, env()->pid_string(),
-                 Number::New(env()->isolate(), uv_process_.pid)).FromJust();
+                 Number::New(env()->isolate(), uv_process_.pid)).Check();
 
   return scope.Escape(js_result);
 }
@@ -731,9 +731,9 @@ Local<Array> SyncProcessRunner::BuildOutputArray() {
   for (uint32_t i = 0; i < stdio_pipes_.size(); i++) {
     SyncProcessStdioPipe* h = stdio_pipes_[i].get();
     if (h != nullptr && h->writable())
-      js_output->Set(context, i, h->GetOutputAsBuffer(env())).FromJust();
+      js_output->Set(context, i, h->GetOutputAsBuffer(env())).Check();
     else
-      js_output->Set(context, i, Null(env()->isolate())).FromJust();
+      js_output->Set(context, i, Null(env()->isolate())).Check();
   }
 
   return scope.Escape(js_output);
@@ -1045,7 +1045,7 @@ Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
                 i,
                 value->ToString(env()->isolate()->GetCurrentContext())
                     .ToLocalChecked())
-          .FromJust();
+          .Check();
     }
 
     Maybe<size_t> maybe_size = StringBytes::StorageSize(isolate, value, UTF8);
diff --git a/src/stream_base-inl.h b/src/stream_base-inl.h
index 08a02e186cfe73..65af037d152763 100644
--- a/src/stream_base-inl.h
+++ b/src/stream_base-inl.h
@@ -170,7 +170,7 @@ inline int StreamBase::Shutdown(v8::Local<v8::Object> req_wrap_obj) {
   if (msg != nullptr) {
     req_wrap_obj->Set(
         env->context(),
-        env->error_string(), OneByteString(env->isolate(), msg)).FromJust();
+        env->error_string(), OneByteString(env->isolate(), msg)).Check();
     ClearError();
   }
 
@@ -223,7 +223,7 @@ inline StreamWriteResult StreamBase::Write(
   if (msg != nullptr) {
     req_wrap_obj->Set(env->context(),
                       env->error_string(),
-                      OneByteString(env->isolate(), msg)).FromJust();
+                      OneByteString(env->isolate(), msg)).Check();
     ClearError();
   }
 
@@ -295,7 +295,7 @@ inline void StreamReq::Done(int status, const char* error_str) {
     async_wrap->object()->Set(env->context(),
                               env->error_string(),
                               OneByteString(env->isolate(), error_str))
-                              .FromJust();
+                              .Check();
   }
 
   OnDone(status);
diff --git a/src/stream_base.cc b/src/stream_base.cc
index 310e490f052e7c..695d19c123ede3 100644
--- a/src/stream_base.cc
+++ b/src/stream_base.cc
@@ -276,7 +276,7 @@ int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
     // collected before `AfterWrite` is called.
     req_wrap_obj->Set(env->context(),
                       env->handle_string(),
-                      send_handle_obj).FromJust();
+                      send_handle_obj).Check();
   }
 
   StreamWriteResult res = Write(&buf, 1, send_handle, req_wrap_obj);
diff --git a/src/stream_pipe.cc b/src/stream_pipe.cc
index a57ce274fad57a..bacf8fe771ccee 100644
--- a/src/stream_pipe.cc
+++ b/src/stream_pipe.cc
@@ -31,13 +31,13 @@ StreamPipe::StreamPipe(StreamBase* source,
   // if that applies to the given streams (for example, Http2Streams use
   // weak references).
   obj->Set(env()->context(), env()->source_string(), source->GetObject())
-      .FromJust();
+      .Check();
   source->GetObject()->Set(env()->context(), env()->pipe_target_string(), obj)
-      .FromJust();
+      .Check();
   obj->Set(env()->context(), env()->sink_string(), sink->GetObject())
-      .FromJust();
+      .Check();
   sink->GetObject()->Set(env()->context(), env()->pipe_source_string(), obj)
-      .FromJust();
+      .Check();
 }
 
 StreamPipe::~StreamPipe() {
@@ -267,7 +267,7 @@ void InitializeStreamPipe(Local<Object> target,
   target
       ->Set(context, stream_pipe_string,
             pipe->GetFunction(context).ToLocalChecked())
-      .FromJust();
+      .Check();
 }
 
 }  // anonymous namespace
diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc
index a9f942150b2332..1ec8386fbbb534 100644
--- a/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@ -89,7 +89,7 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
 
   target->Set(env->context(),
               wrapString,
-              sw->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              sw->GetFunction(env->context()).ToLocalChecked()).Check();
   env->set_shutdown_wrap_template(sw->InstanceTemplate());
 
   Local<FunctionTemplate> ww =
@@ -101,7 +101,7 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
   ww->Inherit(AsyncWrap::GetConstructorTemplate(env));
   target->Set(env->context(),
               writeWrapString,
-              ww->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              ww->GetFunction(env->context()).ToLocalChecked()).Check();
   env->set_write_wrap_template(ww->InstanceTemplate());
 
   NODE_DEFINE_CONSTANT(target, kReadBytesOrError);
@@ -109,7 +109,7 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(target, kBytesWritten);
   NODE_DEFINE_CONSTANT(target, kLastWriteWasAsync);
   target->Set(context, FIXED_ONE_BYTE_STRING(env->isolate(), "streamBaseState"),
-              env->stream_base_state().GetJSArray()).FromJust();
+              env->stream_base_state().GetJSArray()).Check();
 }
 
 
@@ -274,7 +274,7 @@ void LibuvStreamWrap::OnUvRead(ssize_t nread, const uv_buf_t* buf) {
           ->Set(env()->context(),
                 env()->pending_handle_string(),
                 pending_obj.ToLocalChecked())
-          .FromJust();
+          .Check();
     }
   }
 
diff --git a/src/string_decoder.cc b/src/string_decoder.cc
index 90ceb2c222e319..210983de2ae0b3 100644
--- a/src/string_decoder.cc
+++ b/src/string_decoder.cc
@@ -309,11 +309,11 @@ void InitializeStringDecoder(Local<Object> target,
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "encodings"),
-              encodings).FromJust();
+              encodings).Check();
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "kSize"),
-              Integer::New(isolate, sizeof(StringDecoder))).FromJust();
+              Integer::New(isolate, sizeof(StringDecoder))).Check();
 
   env->SetMethod(target, "decode", DecodeData);
   env->SetMethod(target, "flush", FlushData);
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index aedb079ccffc23..89c4e215bbe6ae 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -107,7 +107,7 @@ void TCPWrap::Initialize(Local<Object> target,
 
   target->Set(env->context(),
               tcpString,
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
   env->set_tcp_constructor_template(t);
 
   // Create FunctionTemplate for TCPConnectWrap.
@@ -119,7 +119,7 @@ void TCPWrap::Initialize(Local<Object> target,
   cwt->SetClassName(wrapString);
   target->Set(env->context(),
               wrapString,
-              cwt->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              cwt->GetFunction(env->context()).ToLocalChecked()).Check();
 
   // Define constants
   Local<Object> constants = Object::New(env->isolate());
@@ -128,7 +128,7 @@ void TCPWrap::Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(constants, UV_TCP_IPV6ONLY);
   target->Set(context,
               env->constants_string(),
-              constants).FromJust();
+              constants).Check();
 }
 
 
@@ -353,13 +353,13 @@ Local<Object> AddressToJS(Environment* env,
     port = ntohs(a6->sin6_port);
     info->Set(env->context(),
               env->address_string(),
-              OneByteString(env->isolate(), ip)).FromJust();
+              OneByteString(env->isolate(), ip)).Check();
     info->Set(env->context(),
               env->family_string(),
-              env->ipv6_string()).FromJust();
+              env->ipv6_string()).Check();
     info->Set(env->context(),
               env->port_string(),
-              Integer::New(env->isolate(), port)).FromJust();
+              Integer::New(env->isolate(), port)).Check();
     break;
 
   case AF_INET:
@@ -368,19 +368,19 @@ Local<Object> AddressToJS(Environment* env,
     port = ntohs(a4->sin_port);
     info->Set(env->context(),
               env->address_string(),
-              OneByteString(env->isolate(), ip)).FromJust();
+              OneByteString(env->isolate(), ip)).Check();
     info->Set(env->context(),
               env->family_string(),
-              env->ipv4_string()).FromJust();
+              env->ipv4_string()).Check();
     info->Set(env->context(),
               env->port_string(),
-              Integer::New(env->isolate(), port)).FromJust();
+              Integer::New(env->isolate(), port)).Check();
     break;
 
   default:
     info->Set(env->context(),
               env->address_string(),
-              String::Empty(env->isolate())).FromJust();
+              String::Empty(env->isolate())).Check();
   }
 
   return scope.Escape(info);
diff --git a/src/timers.cc b/src/timers.cc
index b11df62be21e21..ef07d908f476bd 100644
--- a/src/timers.cc
+++ b/src/timers.cc
@@ -57,7 +57,7 @@ void Initialize(Local<Object> target,
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "immediateInfo"),
-              env->immediate_info()->fields().GetJSArray()).FromJust();
+              env->immediate_info()->fields().GetJSArray()).Check();
 }
 
 
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index 14802b1dfb74b8..a034dd42a6e351 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -436,13 +436,13 @@ Local<Value> TLSWrap::GetSSLError(int status, int* err, std::string* msg) {
 
         if (ls != nullptr)
           obj->Set(context, env()->library_string(),
-                   OneByteString(isolate, ls)).FromJust();
+                   OneByteString(isolate, ls)).Check();
         if (fs != nullptr)
           obj->Set(context, env()->function_string(),
-                   OneByteString(isolate, fs)).FromJust();
+                   OneByteString(isolate, fs)).Check();
         if (rs != nullptr) {
           obj->Set(context, env()->reason_string(),
-                   OneByteString(isolate, rs)).FromJust();
+                   OneByteString(isolate, rs)).Check();
 
           // SSL has no API to recover the error name from the number, so we
           // transform reason strings like "this error" to "ERR_SSL_THIS_ERROR",
@@ -457,7 +457,7 @@ Local<Value> TLSWrap::GetSSLError(int status, int* err, std::string* msg) {
           }
           obj->Set(context, env()->code_string(),
                    OneByteString(isolate, ("ERR_SSL_" + code).c_str()))
-                     .FromJust();
+                     .Check();
         }
 
         if (msg != nullptr)
@@ -1094,7 +1094,7 @@ void TLSWrap::Initialize(Local<Object> target,
 
   target->Set(env->context(),
               tlsWrapString,
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
 }  // namespace node
diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc
index 33dd4dbdacf6a3..557f95f26fd231 100644
--- a/src/tty_wrap.cc
+++ b/src/tty_wrap.cc
@@ -117,8 +117,8 @@ void TTYWrap::GetWindowSize(const FunctionCallbackInfo<Value>& args) {
 
   if (err == 0) {
     Local<Array> a = args[0].As<Array>();
-    a->Set(env->context(), 0, Integer::New(env->isolate(), width)).FromJust();
-    a->Set(env->context(), 1, Integer::New(env->isolate(), height)).FromJust();
+    a->Set(env->context(), 0, Integer::New(env->isolate(), width)).Check();
+    a->Set(env->context(), 1, Integer::New(env->isolate(), height)).Check();
   }
 
   args.GetReturnValue().Set(err);
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 59df0232fabc4d..3c66db2155ab74 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -139,7 +139,7 @@ void UDPWrap::Initialize(Local<Object> target,
 
   target->Set(env->context(),
               udpString,
-              t->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              t->GetFunction(env->context()).ToLocalChecked()).Check();
   env->set_udp_constructor_function(
       t->GetFunction(env->context()).ToLocalChecked());
 
@@ -152,13 +152,13 @@ void UDPWrap::Initialize(Local<Object> target,
   swt->SetClassName(sendWrapString);
   target->Set(env->context(),
               sendWrapString,
-              swt->GetFunction(env->context()).ToLocalChecked()).FromJust();
+              swt->GetFunction(env->context()).ToLocalChecked()).Check();
 
   Local<Object> constants = Object::New(env->isolate());
   NODE_DEFINE_CONSTANT(constants, UV_UDP_IPV6ONLY);
   target->Set(context,
               env->constants_string(),
-              constants).FromJust();
+              constants).Check();
 }
 
 
diff --git a/src/util.h b/src/util.h
index a9de8f8636c11b..7d371809cba7c3 100644
--- a/src/util.h
+++ b/src/util.h
@@ -582,7 +582,7 @@ inline v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
   do {                                                                         \
     obj->DefineOwnProperty(                                                    \
            context, FIXED_ONE_BYTE_STRING(isolate, name), value, v8::ReadOnly) \
-        .FromJust();                                                           \
+        .Check();                                                              \
   } while (0)
 
 #define READONLY_DONT_ENUM_PROPERTY(obj, name, var)                            \
@@ -592,7 +592,7 @@ inline v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
            OneByteString(isolate, name),                                       \
            var,                                                                \
            static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum))    \
-        .FromJust();                                                           \
+        .Check();                                                              \
   } while (0)
 
 #define READONLY_FALSE_PROPERTY(obj, name)                                     \
@@ -621,7 +621,7 @@ inline v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
                             constant_name,                                     \
                             constant_value,                                    \
                             constant_attributes)                               \
-        .FromJust();                                                           \
+        .Check();                                                              \
   } while (0)
 
 enum Endianness {
diff --git a/src/uv.cc b/src/uv.cc
index 59469fc3075a52..0c937e876ff775 100644
--- a/src/uv.cc
+++ b/src/uv.cc
@@ -111,7 +111,7 @@ void Initialize(Local<Object> target,
               FIXED_ONE_BYTE_STRING(isolate, "errname"),
               env->NewFunctionTemplate(ErrName)
                   ->GetFunction(env->context())
-                  .ToLocalChecked()).FromJust();
+                  .ToLocalChecked()).Check();
 
   // TODO(joyeecheung): This should be deprecated in user land in favor of
   // `util.getSystemErrorName(err)`.
@@ -124,7 +124,7 @@ void Initialize(Local<Object> target,
     const std::string prefixed_name = prefix + error.name;
     Local<String> name = OneByteString(isolate, prefixed_name.c_str());
     Local<Integer> value = Integer::New(isolate, error.value);
-    target->DefineOwnProperty(context, name, value, attributes).FromJust();
+    target->DefineOwnProperty(context, name, value, attributes).Check();
   }
 
   env->SetMethod(target, "getErrorMap", GetErrMap);
diff --git a/test/code-cache/test-code-cache-generator.js b/test/code-cache/test-code-cache-generator.js
index 78a2b1c9a639a0..a117a2e6a6ea94 100644
--- a/test/code-cache/test-code-cache-generator.js
+++ b/test/code-cache/test-code-cache-generator.js
@@ -30,9 +30,9 @@ if (child.status !== 0) {
 }
 
 // Verifies that:
-// - node::LoadCodeCache()
+// - NativeModuleEnv::InitializeCodeCache()
 // are defined in the generated code.
-// See src/node_native_module.h for explanations.
+// See src/node_native_module_env.h for explanations.
 
 const rl = readline.createInterface({
   input: fs.createReadStream(dest),
@@ -42,7 +42,7 @@ const rl = readline.createInterface({
 let hasCacheDef = false;
 
 rl.on('line', common.mustCallAtLeast((line) => {
-  if (line.includes('LoadCodeCache(')) {
+  if (line.includes('InitializeCodeCache(')) {
     hasCacheDef = true;
   }
 }, 2));
diff --git a/test/parallel/test-crypto-keygen.js b/test/parallel/test-crypto-keygen.js
index 07a0a18c301196..c65f25e172e75c 100644
--- a/test/parallel/test-crypto-keygen.js
+++ b/test/parallel/test-crypto-keygen.js
@@ -449,6 +449,29 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
   }));
 }
 
+// Test invalid parameter encoding.
+{
+  common.expectsError(() => generateKeyPairSync('ec', {
+    namedCurve: 'P-256',
+    paramEncoding: 'otherEncoding',
+    publicKeyEncoding: {
+      type: 'spki',
+      format: 'pem'
+    },
+    privateKeyEncoding: {
+      type: 'pkcs8',
+      format: 'pem',
+      cipher: 'aes-128-cbc',
+      passphrase: 'top secret'
+    }
+  }), {
+    type: TypeError,
+    code: 'ERR_INVALID_OPT_VALUE',
+    message: 'The value "otherEncoding" is invalid for ' +
+    'option "paramEncoding"'
+  });
+}
+
 {
   // Test the util.promisified API with async RSA key generation.
   promisify(generateKeyPair)('rsa', {
diff --git a/test/sequential/test-heapdump-flag.js b/test/sequential/test-heapdump-flag.js
new file mode 100644
index 00000000000000..65401b9d7165ff
--- /dev/null
+++ b/test/sequential/test-heapdump-flag.js
@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+
+if (common.isWindows)
+  common.skip('test not supported on Windows');
+
+const assert = require('assert');
+
+if (process.argv[2] === 'child') {
+  const fs = require('fs');
+
+  assert.strictEqual(process.listenerCount('SIGUSR2'), 1);
+  process.kill(process.pid, 'SIGUSR2');
+  process.kill(process.pid, 'SIGUSR2');
+
+  // Asynchronously wait for the snapshot. Use an async loop to be a bit more
+  // robust in case platform or machine differences throw off the timing.
+  (function validate() {
+    const files = fs.readdirSync(process.cwd());
+
+    if (files.length === 0)
+      return setImmediate(validate);
+
+    assert.strictEqual(files.length, 2);
+
+    for (let i = 0; i < files.length; i++) {
+      assert(/^Heap\..+\.heapsnapshot$/.test(files[i]));
+      JSON.parse(fs.readFileSync(files[i]));
+    }
+  })();
+} else {
+  const { spawnSync } = require('child_process');
+  const tmpdir = require('../common/tmpdir');
+
+  tmpdir.refresh();
+  const args = ['--heapsnapshot-signal', 'SIGUSR2', __filename, 'child'];
+  const child = spawnSync(process.execPath, args, { cwd: tmpdir.path });
+
+  assert.strictEqual(child.status, 0);
+  assert.strictEqual(child.signal, null);
+}
diff --git a/tools/generate_code_cache.js b/tools/generate_code_cache.js
index f324c3d779c191..8afbc14a9bce4d 100644
--- a/tools/generate_code_cache.js
+++ b/tools/generate_code_cache.js
@@ -63,7 +63,7 @@ function getInitalizer(key, cache) {
                   `${defName}, static_cast<int>(arraysize(${defName})), ` +
                   'policy)';
   const initializer =
-    'code_cache_.emplace(\n' +
+    'code_cache->emplace(\n' +
     `  "${key}",\n` +
     `  ${dataDef}\n` +
     ');';
@@ -107,8 +107,7 @@ for (const key of [...canBeRequired].sort(lexical)) {
               `, total = ${formatSize(totalCacheSize)}`);
 }
 
-const result = `#include "node_native_module.h"
-#include "node_internals.h"
+const result = `#include "node_native_module_env.h"
 
 // This file is generated by tools/generate_code_cache.js
 // and is used when configure is run with \`--code-cache-path\`
@@ -117,7 +116,13 @@ namespace node {
 namespace native_module {
 ${cacheDefinitions.join('\n\n')}
 
-void NativeModuleLoader::LoadCodeCache() {
+void NativeModuleEnv::InitializeCodeCache() {
+  NativeModuleCacheMap* code_cache =
+      NativeModuleLoader::GetInstance()->code_cache();
+  if (!code_cache->empty()) {
+    return;
+  }
+
   auto policy = v8::ScriptCompiler::CachedData::BufferPolicy::BufferNotOwned;
   ${cacheInitializers.join('\n  ')}
 }
diff --git a/vcbuild.bat b/vcbuild.bat
index 3128bc5db4a482..73405b46ed6516 100644
--- a/vcbuild.bat
+++ b/vcbuild.bat
@@ -211,7 +211,7 @@ if not "%target%"=="Clean" goto skip-clean
 rmdir /Q /S "%~dp0%config%\%TARGET_NAME%" > nul 2> nul
 :skip-clean
 
-if defined noprojgen if defined nobuild if not defined sign if not defined msi goto licensertf
+if defined noprojgen if defined nobuild goto :after-build
 
 @rem Set environment for msbuild
 
@@ -301,7 +301,7 @@ where /R . /T *.gyp? >> .gyp_configure_stamp
 
 :msbuild
 @rem Skip build if requested.
-if defined nobuild goto sign
+if defined nobuild goto :after-build
 
 @rem Build the sln with msbuild.
 set "msbcpu=/m:2"
@@ -319,10 +319,13 @@ if defined msbuild_args set "extra_msbuild_args=%extra_msbuild_args% %msbuild_ar
 msbuild node.sln %msbcpu% /t:%target% /p:Configuration=%config% /p:Platform=%msbplatform% /clp:NoItemAndPropertyList;Verbosity=minimal /nologo %extra_msbuild_args%
 if errorlevel 1 (
   if not defined project_generated echo Building Node with reused solution failed. To regenerate project files use "vcbuild projgen"
-  goto exit
+  exit /B 1
 )
 if "%target%" == "Clean" goto exit
 
+:after-build
+if EXIST out\%config% mklink /D %config% out\%config%
+
 :sign
 @rem Skip signing unless the `sign` option was specified.
 if not defined sign goto licensertf
@@ -334,7 +337,7 @@ if errorlevel 1 echo Failed to sign exe&goto exit
 @rem Skip license.rtf generation if not requested.
 if not defined licensertf goto stage_package
 
-%config%\node.exe tools\license2rtf.js < LICENSE > %config%\license.rtf
+%node_exe% tools\license2rtf.js < LICENSE > %config%\license.rtf
 if errorlevel 1 echo Failed to generate license.rtf&goto exit
 
 :stage_package
@@ -553,7 +556,7 @@ goto node-tests
 
 :node-test-inspect
 set USE_EMBEDDED_NODE_INSPECT=1
-%config%\node tools\test-npm-package.js --install deps\node-inspect test
+%node_exe% tools\test-npm-package.js --install deps\node-inspect test
 goto node-tests
 
 :node-tests
@@ -635,12 +638,12 @@ if defined lint_js_ci goto lint-js-ci
 if not defined lint_js goto lint-md-build
 if not exist tools\node_modules\eslint goto no-lint
 echo running lint-js
-%config%\node tools\node_modules\eslint\bin\eslint.js --cache --report-unused-disable-directives --rule "linebreak-style: 0" --ext=.js,.mjs,.md .eslintrc.js benchmark doc lib test tools
+%node_exe% tools\node_modules\eslint\bin\eslint.js --cache --report-unused-disable-directives --rule "linebreak-style: 0" --ext=.js,.mjs,.md .eslintrc.js benchmark doc lib test tools
 goto lint-md-build
 
 :lint-js-ci
 echo running lint-js-ci
-%config%\node tools\lint-js.js -J -f tap -o test-eslint.tap benchmark doc lib test tools
+%node_exe% tools\lint-js.js -J -f tap -o test-eslint.tap benchmark doc lib test tools
 goto lint-md-build
 
 :no-lint
@@ -663,7 +666,7 @@ for /D %%D IN (doc\*) do (
     set "lint_md_files="%%F" !lint_md_files!"
   )
 )
-%config%\node tools\lint-md.js -q -f %lint_md_files%
+%node_exe% tools\lint-md.js -q -f %lint_md_files%
 ENDLOCAL
 goto exit