diff --git a/.eslintrc.js b/.eslintrc.js
index 7333382fe3..a38335ee21 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -39,7 +39,6 @@ module.exports = {
       files: [
         'doc/api/esm.md',
         '*.mjs',
-        'test/es-module/test-esm-example-loader.js',
       ],
       parserOptions: { sourceType: 'module' },
     },
diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h
index 01fb56b55d..bc532e5ec5 100644
--- a/deps/v8/include/v8.h
+++ b/deps/v8/include/v8.h
@@ -1219,6 +1219,19 @@ class V8_EXPORT Module {
   Local<UnboundModuleScript> GetUnboundModuleScript();
 };
 
+/**
+ * A Dynamic JavaScript module
+ */
+class V8_EXPORT DynamicModule : public Module {
+ public:
+  /**
+   * Set an export value, corresponding to an export name
+   */
+  bool SetExport(Isolate* isolate, Local<String> export_name,
+                 Local<Value> value);
+  V8_INLINE static DynamicModule* Cast(v8::Module* module);
+};
+
 /**
  * A compiled JavaScript script, tied to a Context which was active when the
  * script was compiled.
@@ -1547,6 +1560,12 @@ class V8_EXPORT ScriptCompiler {
       CompileOptions options = kNoCompileOptions,
       NoCacheReason no_cache_reason = kNoCacheNoReason);
 
+  /**
+   * Create a new Dynamic Module.
+   */
+  static V8_WARN_UNUSED_RESULT MaybeLocal<DynamicModule> CreateDynamicModule(
+      Isolate* isolate);
+
   /**
    * Compile a function for a given context. This is equivalent to running
    *
@@ -6421,6 +6440,15 @@ typedef void (*AddHistogramSampleCallback)(void* histogram, int sample);
 typedef void (*BeforeCallEnteredCallback)(Isolate*);
 typedef void (*CallCompletedCallback)(Isolate*);
 
+/**
+ * HostExecuteDynamicModuleCallback is called at the exact point
+ * of execution of a dynamic module in the graph.
+ *
+ * It should call Module::SetExport for each defined export.
+ */
+typedef void (*HostExecuteDynamicModuleCallback)(Local<Context> context,
+                                                 Local<DynamicModule> module);
+
 /**
  * HostImportModuleDynamicallyCallback is called when we require the
  * embedder to load a module. This is used as part of the dynamic
@@ -7450,6 +7478,13 @@ class V8_EXPORT Isolate {
   void SetAbortOnUncaughtExceptionCallback(
       AbortOnUncaughtExceptionCallback callback);
 
+  /*
+   * This specifies the callback called by Dynamic Module records
+   * at their exact point of execution in the module graph.
+   */
+  void SetHostExecuteDynamicModuleCallback(
+      HostExecuteDynamicModuleCallback callback);
+
   /**
    * This specifies the callback called by the upcoming dynamic
    * import() language feature to load modules.
@@ -10163,6 +10198,13 @@ WasmCompiledModule* WasmCompiledModule::Cast(v8::Value* value) {
   return static_cast<WasmCompiledModule*>(value);
 }
 
+DynamicModule* DynamicModule::Cast(v8::Module* value) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(value);
+#endif
+  return static_cast<DynamicModule*>(value);
+}
+
 Promise::Resolver* Promise::Resolver::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
   CheckCast(value);
diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc
index 64676f06c1..82ff14b3aa 100644
--- a/deps/v8/src/api.cc
+++ b/deps/v8/src/api.cc
@@ -2292,6 +2292,79 @@ MaybeLocal<Value> Module::Evaluate(Local<Context> context) {
   RETURN_ESCAPED(result);
 }
 
+class IsIdentifierHelper {
+ public:
+  IsIdentifierHelper() : is_identifier_(false), first_char_(true) {}
+
+  bool Check(i::String* string) {
+    i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
+    if (cons_string == nullptr) return is_identifier_;
+    // We don't support cons strings here.
+    return false;
+  }
+  void VisitOneByteString(const uint8_t* chars, int length) {
+    for (int i = 0; i < length; ++i) {
+      if (first_char_) {
+        first_char_ = false;
+        is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
+      } else {
+        is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
+      }
+    }
+  }
+  void VisitTwoByteString(const uint16_t* chars, int length) {
+    for (int i = 0; i < length; ++i) {
+      if (first_char_) {
+        first_char_ = false;
+        is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
+      } else {
+        is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
+      }
+    }
+  }
+
+ private:
+  bool is_identifier_;
+  bool first_char_;
+  i::UnicodeCache unicode_cache_;
+  DISALLOW_COPY_AND_ASSIGN(IsIdentifierHelper);
+};
+
+bool DynamicModule::SetExport(Isolate* v8_isolate, Local<String> export_name,
+                              Local<Value> value) {
+  Utils::ApiCheck(
+      GetStatus() >= kEvaluating, "v8::Module::SetExport",
+      "v8::DynamicModule::SetExport must be used after instantiation");
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
+  i::Handle<i::Module> self = Utils::OpenHandle(this);
+  i::Handle<i::String> name = Utils::OpenHandle(*(export_name));
+  i::Handle<i::Object> object(self->exports()->Lookup(name), isolate);
+
+  i::Handle<i::Object> val = Utils::OpenHandle(*(value));
+
+  // Exports can be defined while executing
+  if (!object->IsCell()) {
+    if (GetStatus() == kEvaluating) {
+      i::Handle<i::String> internal_name =
+          isolate->factory()->InternalizeString(name);
+      // Return *false* for any invalid identifier passed
+      IsIdentifierHelper helper;
+      if (!helper.Check(*internal_name)) return false;
+      auto cell = i::Module::CreateDynamicExport(isolate, self, internal_name);
+      cell->set_value(*val);
+      return true;
+    }
+    else {
+      Utils::ApiCheck(object->IsCell(), "v8::Module::SetExport",
+                      "v8::Module::SetExport unable to find local export name");
+    }
+  }
+
+  auto cell = i::Handle<i::Cell>::cast(object);
+  cell->set_value(*val);
+  return true;
+}
+
 namespace {
 
 i::Compiler::ScriptDetails GetScriptDetails(
@@ -2417,44 +2490,12 @@ MaybeLocal<Module> ScriptCompiler::CompileModule(
   return ToApiHandle<Module>(i_isolate->factory()->NewModule(shared));
 }
 
+MaybeLocal<DynamicModule> ScriptCompiler::CreateDynamicModule(
+    Isolate* isolate) {
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
-class IsIdentifierHelper {
- public:
-  IsIdentifierHelper() : is_identifier_(false), first_char_(true) {}
-
-  bool Check(i::String* string) {
-    i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
-    if (cons_string == nullptr) return is_identifier_;
-    // We don't support cons strings here.
-    return false;
-  }
-  void VisitOneByteString(const uint8_t* chars, int length) {
-    for (int i = 0; i < length; ++i) {
-      if (first_char_) {
-        first_char_ = false;
-        is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
-      } else {
-        is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
-      }
-    }
-  }
-  void VisitTwoByteString(const uint16_t* chars, int length) {
-    for (int i = 0; i < length; ++i) {
-      if (first_char_) {
-        first_char_ = false;
-        is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
-      } else {
-        is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
-      }
-    }
-  }
-
- private:
-  bool is_identifier_;
-  bool first_char_;
-  i::UnicodeCache unicode_cache_;
-  DISALLOW_COPY_AND_ASSIGN(IsIdentifierHelper);
-};
+  return ToApiHandle<DynamicModule>(i_isolate->factory()->NewDynamicModule());
+}
 
 MaybeLocal<Function> ScriptCompiler::CompileFunctionInContext(
     Local<Context> v8_context, Source* source, size_t arguments_count,
@@ -8286,6 +8327,12 @@ void Isolate::SetAbortOnUncaughtExceptionCallback(
   isolate->SetAbortOnUncaughtExceptionCallback(callback);
 }
 
+void Isolate::SetHostExecuteDynamicModuleCallback(
+    HostExecuteDynamicModuleCallback callback) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+  isolate->SetHostExecuteDynamicModuleCallback(callback);
+}
+
 void Isolate::SetHostImportModuleDynamicallyCallback(
     HostImportModuleDynamicallyCallback callback) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
diff --git a/deps/v8/src/heap/factory.cc b/deps/v8/src/heap/factory.cc
index 9535eb4b88..ce6a75ae6f 100644
--- a/deps/v8/src/heap/factory.cc
+++ b/deps/v8/src/heap/factory.cc
@@ -3053,6 +3053,36 @@ Handle<Module> Factory::NewModule(Handle<SharedFunctionInfo> code) {
   module->set_import_meta(roots.the_hole_value());
   module->set_dfs_index(-1);
   module->set_dfs_ancestor_index(-1);
+  module->set_module_type(Module::Type::kSourceTextModule);
+  return module;
+}
+
+Handle<Module> Factory::NewDynamicModule() {
+  Handle<ObjectHashTable> exports = ObjectHashTable::New(isolate(), 0);
+  // For dynamic modules, regular_exports is an
+  // ArrayList until execution completion.
+  Handle<ArrayList> regular_exports = ArrayList::New(isolate(), 0);
+  Handle<ArrayList> dynamic_namespaces = ArrayList::New(isolate(), 0);
+
+  ReadOnlyRoots roots(isolate());
+
+  Handle<Module> module = Handle<Module>::cast(NewStruct(MODULE_TYPE, TENURED));
+
+  module->set_code(roots.undefined_value());
+  module->set_exports(*exports);
+  module->set_regular_exports(*regular_exports);
+  // Dynamic modules reuse regular_imports to track dynamic_namespaces.
+  module->set_regular_imports(*dynamic_namespaces);
+  module->set_hash(isolate()->GenerateIdentityHash(Smi::kMaxValue));
+  module->set_module_namespace(roots.undefined_value());
+  module->set_requested_modules(roots.empty_fixed_array());
+  // module->set_script();
+  module->set_status(Module::kUninstantiated);
+  module->set_exception(roots.the_hole_value());
+  module->set_import_meta(roots.the_hole_value());
+  module->set_dfs_index(-1);
+  module->set_dfs_ancestor_index(-1);
+  module->set_module_type(Module::Type::kDynamicModule);
   return module;
 }
 
diff --git a/deps/v8/src/heap/factory.h b/deps/v8/src/heap/factory.h
index 8c6d32090e..825035164a 100644
--- a/deps/v8/src/heap/factory.h
+++ b/deps/v8/src/heap/factory.h
@@ -635,6 +635,8 @@ class V8_EXPORT_PRIVATE Factory {
 
   Handle<Module> NewModule(Handle<SharedFunctionInfo> code);
 
+  Handle<Module> NewDynamicModule();
+
   Handle<JSArrayBuffer> NewJSArrayBuffer(
       SharedFlag shared = SharedFlag::kNotShared,
       PretenureFlag pretenure = NOT_TENURED);
diff --git a/deps/v8/src/isolate.cc b/deps/v8/src/isolate.cc
index e6a9e95a2f..ac4341b5aa 100644
--- a/deps/v8/src/isolate.cc
+++ b/deps/v8/src/isolate.cc
@@ -4042,6 +4042,18 @@ void Isolate::SetHostInitializeImportMetaObjectCallback(
   host_initialize_import_meta_object_callback_ = callback;
 }
 
+void Isolate::RunHostExecuteDynamicModuleCallback(Handle<Context> context,
+                                                  Handle<Module> module) {
+  v8::Local<v8::Context> api_context = Utils::ToLocal(context);
+  host_execute_dynamic_module_callback_(
+      api_context, Utils::Convert<v8::internal::Object, DynamicModule>(module));
+}
+
+void Isolate::SetHostExecuteDynamicModuleCallback(
+    HostExecuteDynamicModuleCallback callback) {
+  host_execute_dynamic_module_callback_ = callback;
+}
+
 MaybeHandle<Object> Isolate::RunPrepareStackTraceCallback(
     Handle<Context> context, Handle<JSObject> error) {
   v8::Local<v8::Context> api_context = Utils::ToLocal(context);
diff --git a/deps/v8/src/isolate.h b/deps/v8/src/isolate.h
index c25f143cf8..c6f0e63f2b 100644
--- a/deps/v8/src/isolate.h
+++ b/deps/v8/src/isolate.h
@@ -1506,6 +1506,11 @@ class Isolate : private HiddenFactory {
   Handle<JSObject> RunHostInitializeImportMetaObjectCallback(
       Handle<Module> module);
 
+  void SetHostExecuteDynamicModuleCallback(
+      HostExecuteDynamicModuleCallback callback);
+  void RunHostExecuteDynamicModuleCallback(Handle<Context>,
+                                           Handle<Module> module);
+
   void SetPrepareStackTraceCallback(PrepareStackTraceCallback callback);
   MaybeHandle<Object> RunPrepareStackTraceCallback(Handle<Context>,
                                                    Handle<JSObject> Error);
@@ -1731,6 +1736,8 @@ class Isolate : private HiddenFactory {
   HostImportModuleDynamicallyCallback host_import_module_dynamically_callback_;
   HostInitializeImportMetaObjectCallback
       host_initialize_import_meta_object_callback_;
+  HostExecuteDynamicModuleCallback host_execute_dynamic_module_callback_ =
+      nullptr;
   base::Mutex rail_mutex_;
   double load_start_time_ms_;
 
diff --git a/deps/v8/src/messages.h b/deps/v8/src/messages.h
index 05d287faae..0c1c66d08c 100644
--- a/deps/v8/src/messages.h
+++ b/deps/v8/src/messages.h
@@ -598,6 +598,8 @@ class ErrorUtils : public AllStatic {
   T(DuplicateExport, "Duplicate export of '%'")                                \
   T(DuplicateProto,                                                            \
     "Duplicate __proto__ fields are not allowed in object literals")           \
+  T(DynamicModuleStarExport,                                                   \
+    "Star exports from dynamic module '%' are not allowed")                    \
   T(ForInOfLoopInitializer,                                                    \
     "% loop variable declaration may not have an initializer.")                \
   T(ForInOfLoopMultiBindings,                                                  \
diff --git a/deps/v8/src/objects/module-inl.h b/deps/v8/src/objects/module-inl.h
index 1a4f2b3efa..451bc54b66 100644
--- a/deps/v8/src/objects/module-inl.h
+++ b/deps/v8/src/objects/module-inl.h
@@ -30,6 +30,7 @@ SMI_ACCESSORS(Module, status, kStatusOffset)
 SMI_ACCESSORS(Module, dfs_index, kDfsIndexOffset)
 SMI_ACCESSORS(Module, dfs_ancestor_index, kDfsAncestorIndexOffset)
 SMI_ACCESSORS(Module, hash, kHashOffset)
+SMI_ACCESSORS(Module, module_type, kModuleTypeOffset)
 
 ModuleInfo* Module::info() const {
   return (status() >= kEvaluating)
diff --git a/deps/v8/src/objects/module.cc b/deps/v8/src/objects/module.cc
index c4d2626e60..bf6bc6d75c 100644
--- a/deps/v8/src/objects/module.cc
+++ b/deps/v8/src/objects/module.cc
@@ -114,29 +114,22 @@ int Module::ImportIndex(int cell_index) {
   return -cell_index - 1;
 }
 
-void Module::CreateIndirectExport(Isolate* isolate, Handle<Module> module,
-                                  Handle<String> name,
-                                  Handle<ModuleInfoEntry> entry) {
-  Handle<ObjectHashTable> exports(module->exports(), isolate);
-  DCHECK(exports->Lookup(name)->IsTheHole(isolate));
-  exports = ObjectHashTable::Put(exports, name, entry);
-  module->set_exports(*exports);
-}
-
-void Module::CreateExport(Isolate* isolate, Handle<Module> module,
-                          int cell_index, Handle<FixedArray> names) {
-  DCHECK_LT(0, names->length());
-  Handle<Cell> cell =
-      isolate->factory()->NewCell(isolate->factory()->undefined_value());
-  module->regular_exports()->set(ExportIndex(cell_index), *cell);
+Handle<Cell> Module::CreateDynamicExport(Isolate* isolate,
+                                         Handle<Module> module,
+                                         Handle<String> name) {
+  DCHECK_EQ(module->module_type(), kDynamicModule);
+  Handle<ArrayList> regular_exports =
+      handle(ArrayList::cast(module->regular_exports()), isolate);
+   Handle<Cell> cell =
+      isolate->factory()->NewCell(isolate->factory()->the_hole_value());
+  regular_exports = ArrayList::Add(isolate, regular_exports, cell);
+  module->set_regular_exports(*regular_exports);
 
   Handle<ObjectHashTable> exports(module->exports(), isolate);
-  for (int i = 0, n = names->length(); i < n; ++i) {
-    Handle<String> name(String::cast(names->get(i)), isolate);
-    DCHECK(exports->Lookup(name)->IsTheHole(isolate));
-    exports = ObjectHashTable::Put(exports, name, cell);
-  }
-  module->set_exports(*exports);
+  DCHECK(exports->Lookup(name)->IsTheHole(isolate));
+  exports = ObjectHashTable::Put(exports, name, cell);
+   module->set_exports(*exports);
+  return cell;
 }
 
 Cell* Module::GetCell(int cell_index) {
@@ -174,7 +167,11 @@ void Module::PrintStatusTransition(Status new_status) {
     StdoutStream os;
     os << "Changing module status from " << status() << " to " << new_status
        << " for ";
-    script()->GetNameOrSourceURL()->Print(os);
+    if (module_type() == kDynamicModule) {
+      os << "[dynamic]\n";
+    } else {
+      script()->GetNameOrSourceURL()->Print(os);
+    }
 #ifndef OBJECT_PRINT
     os << "\n";
 #endif  // OBJECT_PRINT
@@ -250,7 +247,7 @@ void Module::RecordError(Isolate* isolate) {
   Object* the_exception = isolate->pending_exception();
   DCHECK(!the_exception->IsTheHole(isolate));
 
-  set_code(info());
+  if (module_type() != kDynamicModule) set_code(info());
 #ifdef DEBUG
   PrintStatusTransition(Module::kErrored);
 #endif  // DEBUG
@@ -269,6 +266,7 @@ SharedFunctionInfo* Module::GetSharedFunctionInfo() const {
   DisallowHeapAllocation no_alloc;
   DCHECK_NE(status(), Module::kEvaluating);
   DCHECK_NE(status(), Module::kEvaluated);
+  DCHECK_NE(module_type(), Module::kDynamicModule);
   switch (status()) {
     case kUninstantiated:
     case kPreInstantiating:
@@ -318,6 +316,17 @@ MaybeHandle<Cell> Module::ResolveExport(Isolate* isolate, Handle<Module> module,
     return Handle<Cell>::cast(object);
   }
 
+  // Dynamic modules allocate export cells as they are resolved.
+  if (module->module_type() == kDynamicModule) {
+    if (module->status() == kEvaluated) {
+      return isolate->Throw<Cell>(isolate->factory()->NewSyntaxError(
+                                      MessageTemplate::kUnresolvableExport,
+                                      module_specifier, export_name),
+                                  &loc);
+    }
+    return CreateDynamicExport(isolate, module, export_name);
+  }
+
   // Check for cycle before recursing.
   {
     // Attempt insertion with a null string set.
@@ -346,6 +355,7 @@ MaybeHandle<Cell> Module::ResolveExport(Isolate* isolate, Handle<Module> module,
     // Not yet resolved indirect export.
     Handle<ModuleInfoEntry> entry = Handle<ModuleInfoEntry>::cast(object);
     Handle<String> import_name(String::cast(entry->import_name()), isolate);
+
     Handle<Script> script(module->script(), isolate);
     MessageLocation new_loc(script, entry->beg_pos(), entry->end_pos());
 
@@ -436,13 +446,16 @@ bool Module::Instantiate(Isolate* isolate, Handle<Module> module,
   if (FLAG_trace_module_status) {
     StdoutStream os;
     os << "Instantiating module ";
-    module->script()->GetNameOrSourceURL()->Print(os);
+    if (module->module_type() == kDynamicModule) {
+      os << "[dynamic]\n";
+    } else {
+      module->script()->GetNameOrSourceURL()->Print(os);
+    }
 #ifndef OBJECT_PRINT
     os << "\n";
 #endif  // OBJECT_PRINT
   }
 #endif  // DEBUG
-
   if (!PrepareInstantiate(isolate, module, context, callback)) {
     ResetGraph(isolate, module);
     return false;
@@ -472,6 +485,8 @@ bool Module::PrepareInstantiate(Isolate* isolate, Handle<Module> module,
   module->SetStatus(kPreInstantiating);
   STACK_CHECK(isolate, false);
 
+  if (module->module_type() == kDynamicModule) return true;
+
   // Obtain requested modules.
   Handle<ModuleInfo> module_info(module->info(), isolate);
   Handle<FixedArray> module_requests(module_info->module_requests(), isolate);
@@ -499,12 +514,21 @@ bool Module::PrepareInstantiate(Isolate* isolate, Handle<Module> module,
   }
 
   // Set up local exports.
-  // TODO(neis): Create regular_exports array here instead of in factory method?
   for (int i = 0, n = module_info->RegularExportCount(); i < n; ++i) {
     int cell_index = module_info->RegularExportCellIndex(i);
     Handle<FixedArray> export_names(module_info->RegularExportExportNames(i),
                                     isolate);
-    CreateExport(isolate, module, cell_index, export_names);
+    Handle<Cell> cell =
+        isolate->factory()->NewCell(isolate->factory()->undefined_value());
+    module->regular_exports()->set(ExportIndex(cell_index), *cell);
+
+    Handle<ObjectHashTable> exports(module->exports(), isolate);
+    for (int i = 0, n = export_names->length(); i < n; ++i) {
+      Handle<String> name(String::cast(export_names->get(i)), isolate);
+      DCHECK(exports->Lookup(name)->IsTheHole(isolate));
+      exports = ObjectHashTable::Put(exports, name, cell);
+    }
+    module->set_exports(*exports);
   }
 
   // Partially set up indirect exports.
@@ -517,9 +541,30 @@ bool Module::PrepareInstantiate(Isolate* isolate, Handle<Module> module,
     Handle<ModuleInfoEntry> entry(
         ModuleInfoEntry::cast(special_exports->get(i)), isolate);
     Handle<Object> export_name(entry->export_name(), isolate);
-    if (export_name->IsUndefined(isolate)) continue;  // Star export.
-    CreateIndirectExport(isolate, module, Handle<String>::cast(export_name),
-                         entry);
+
+    // Star export.
+    if (export_name->IsUndefined(isolate)) {
+      int module_request = entry->module_request();
+      Handle<Module> requested_module(
+          Module::cast(requested_modules->get(module_request)), isolate);
+      if (requested_module->module_type() == kDynamicModule) {
+        Handle<String> specifier(
+            String::cast(
+                module->info()->module_requests()->get(module_request)),
+            isolate);
+        isolate->Throw(*isolate->factory()->NewSyntaxError(
+            MessageTemplate::kDynamicModuleStarExport, specifier));
+        module->RecordError(isolate);
+        return false;
+      }
+      continue;
+    }
+
+    Handle<ObjectHashTable> exports(module->exports(), isolate);
+    Handle<String> name = Handle<String>::cast(export_name);
+    DCHECK(exports->Lookup(name)->IsTheHole(isolate));
+    exports = ObjectHashTable::Put(exports, name, entry);
+    module->set_exports(*exports);
   }
 
   DCHECK_EQ(module->status(), kPreInstantiating);
@@ -555,16 +600,21 @@ bool Module::MaybeTransitionComponent(Isolate* isolate, Handle<Module> module,
   DCHECK_LE(module->dfs_ancestor_index(), module->dfs_index());
   if (module->dfs_ancestor_index() == module->dfs_index()) {
     // This is the root of its strongly connected component.
+    // Attempt to transition together.
     Handle<Module> ancestor;
-    do {
-      ancestor = stack->front();
-      stack->pop_front();
+    for (auto& ancestor : *stack) {
       DCHECK_EQ(ancestor->status(),
                 new_status == kInstantiated ? kInstantiating : kEvaluating);
       if (new_status == kInstantiated) {
         if (!RunInitializationCode(isolate, ancestor)) return false;
       }
       ancestor->SetStatus(new_status);
+      if (*ancestor == *module) break;
+    }
+    // On success, clear the stack.
+    do {
+      ancestor = stack->front();
+      stack->pop_front();
     } while (*ancestor != *module);
   }
   return true;
@@ -578,6 +628,11 @@ bool Module::FinishInstantiate(Isolate* isolate, Handle<Module> module,
   DCHECK_EQ(module->status(), kPreInstantiating);
   STACK_CHECK(isolate, false);
 
+  if (module->module_type() == kDynamicModule) {
+    module->SetStatus(Module::kInstantiated);
+    return true;
+  }
+
   // Instantiate SharedFunctionInfo and mark module as instantiating for
   // the recursion.
   Handle<SharedFunctionInfo> shared(SharedFunctionInfo::cast(module->code()),
@@ -661,7 +716,11 @@ MaybeHandle<Object> Module::Evaluate(Isolate* isolate, Handle<Module> module) {
   if (FLAG_trace_module_status) {
     StdoutStream os;
     os << "Evaluating module ";
-    module->script()->GetNameOrSourceURL()->Print(os);
+    if (module->module_type() == kDynamicModule) {
+      os << "[dynamic]\n";
+    } else {
+      module->script()->GetNameOrSourceURL()->Print(os);
+    }
 #ifndef OBJECT_PRINT
     os << "\n";
 #endif  // OBJECT_PRINT
@@ -691,70 +750,6 @@ MaybeHandle<Object> Module::Evaluate(Isolate* isolate, Handle<Module> module) {
   return result;
 }
 
-MaybeHandle<Object> Module::Evaluate(Isolate* isolate, Handle<Module> module,
-                                     ZoneForwardList<Handle<Module>>* stack,
-                                     unsigned* dfs_index) {
-  if (module->status() == kErrored) {
-    isolate->Throw(module->GetException());
-    return MaybeHandle<Object>();
-  }
-  if (module->status() >= kEvaluating) {
-    return isolate->factory()->undefined_value();
-  }
-  DCHECK_EQ(module->status(), kInstantiated);
-  STACK_CHECK(isolate, MaybeHandle<Object>());
-
-  Handle<JSGeneratorObject> generator(JSGeneratorObject::cast(module->code()),
-                                      isolate);
-  module->set_code(
-      generator->function()->shared()->scope_info()->ModuleDescriptorInfo());
-  module->SetStatus(kEvaluating);
-  module->set_dfs_index(*dfs_index);
-  module->set_dfs_ancestor_index(*dfs_index);
-  stack->push_front(module);
-  (*dfs_index)++;
-
-  // Recursion.
-  Handle<FixedArray> requested_modules(module->requested_modules(), isolate);
-  for (int i = 0, length = requested_modules->length(); i < length; ++i) {
-    Handle<Module> requested_module(Module::cast(requested_modules->get(i)),
-                                    isolate);
-    RETURN_ON_EXCEPTION(
-        isolate, Evaluate(isolate, requested_module, stack, dfs_index), Object);
-
-    DCHECK_GE(requested_module->status(), kEvaluating);
-    DCHECK_NE(requested_module->status(), kErrored);
-    SLOW_DCHECK(
-        // {requested_module} is evaluating iff it's on the {stack}.
-        (requested_module->status() == kEvaluating) ==
-        std::count_if(stack->begin(), stack->end(), [&](Handle<Module> m) {
-          return *m == *requested_module;
-        }));
-
-    if (requested_module->status() == kEvaluating) {
-      module->set_dfs_ancestor_index(
-          std::min(module->dfs_ancestor_index(),
-                   requested_module->dfs_ancestor_index()));
-    }
-  }
-
-  // Evaluation of module body.
-  Handle<JSFunction> resume(
-      isolate->native_context()->generator_next_internal(), isolate);
-  Handle<Object> result;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate, result, Execution::Call(isolate, resume, generator, 0, nullptr),
-      Object);
-  DCHECK(static_cast<JSIteratorResult*>(JSObject::cast(*result))
-             ->done()
-             ->BooleanValue(isolate));
-
-  CHECK(MaybeTransitionComponent(isolate, module, stack, kEvaluated));
-  return handle(
-      static_cast<JSIteratorResult*>(JSObject::cast(*result))->value(),
-      isolate);
-}
-
 namespace {
 
 void FetchStarExports(Isolate* isolate, Handle<Module> module, Zone* zone,
@@ -829,36 +824,39 @@ void FetchStarExports(Isolate* isolate, Handle<Module> module, Zone* zone,
   module->set_exports(*exports);
 }
 
-}  // anonymous namespace
+void FinalizeModuleNamespace(Isolate* isolate, Handle<Module> module,
+                             Handle<JSModuleNamespace> ns) {
+  Zone zone(isolate->allocator(), ZONE_NAME);
+  UnorderedModuleSet visited(&zone);
 
-Handle<JSModuleNamespace> Module::GetModuleNamespace(Isolate* isolate,
-                                                     Handle<Module> module,
-                                                     int module_request) {
-  Handle<Module> requested_module(
-      Module::cast(module->requested_modules()->get(module_request)), isolate);
-  return Module::GetModuleNamespace(isolate, requested_module);
-}
+  FetchStarExports(isolate, module, &zone, &visited);
 
-Handle<JSModuleNamespace> Module::GetModuleNamespace(Isolate* isolate,
-                                                     Handle<Module> module) {
-  Handle<HeapObject> object(module->module_namespace(), isolate);
-  ReadOnlyRoots roots(isolate);
-  if (!object->IsUndefined(roots)) {
-    // Namespace object already exists.
-    return Handle<JSModuleNamespace>::cast(object);
+#ifdef DEBUG
+  if (FLAG_trace_module_status) {
+    StdoutStream os;
+    os << "Finalizing module namespace ";
+    if (module->module_type() == Module::kDynamicModule) {
+      os << "[dynamic]\n";
+    } else {
+      module->script()->GetNameOrSourceURL()->Print(os);
+    }
+#ifndef OBJECT_PRINT
+    os << "\n";
+#endif  // OBJECT_PRINT
   }
+#endif  // DEBU
 
   // Collect the export names.
-  Zone zone(isolate->allocator(), ZONE_NAME);
-  UnorderedModuleSet visited(&zone);
-  FetchStarExports(isolate, module, &zone, &visited);
+  ReadOnlyRoots roots(isolate);
   Handle<ObjectHashTable> exports(module->exports(), isolate);
   ZoneVector<Handle<String>> names(&zone);
   names.reserve(exports->NumberOfElements());
   for (int i = 0, n = exports->Capacity(); i < n; ++i) {
     Object* key;
     if (!exports->ToKey(roots, i, &key)) continue;
-    names.push_back(handle(String::cast(key), isolate));
+    Handle<Cell> cell(Cell::cast(exports->ValueAt(i)), isolate);
+    Handle<String> name = handle(String::cast(key), isolate);
+    names.push_back(name);
   }
   DCHECK_EQ(static_cast<int>(names.size()), exports->NumberOfElements());
 
@@ -869,11 +867,6 @@ Handle<JSModuleNamespace> Module::GetModuleNamespace(Isolate* isolate,
                      ComparisonResult::kLessThan;
             });
 
-  // Create the namespace object (initially empty).
-  Handle<JSModuleNamespace> ns = isolate->factory()->NewJSModuleNamespace();
-  ns->set_module(*module);
-  module->set_module_namespace(*ns);
-
   // Create the properties in the namespace object. Transition the object
   // to dictionary mode so that property addition is faster.
   PropertyAttributes attr = DONT_DELETE;
@@ -885,7 +878,6 @@ Handle<JSModuleNamespace> Module::GetModuleNamespace(Isolate* isolate,
         ns, name, Accessors::MakeModuleNamespaceEntryInfo(isolate, name),
         PropertyDetails(kAccessor, attr, PropertyCellType::kMutable));
   }
-  JSObject::PreventExtensions(ns, kThrowOnError).ToChecked();
 
   // Optimize the namespace object as a prototype, for two reasons:
   // - The object's map is guaranteed not to be shared. ICs rely on this.
@@ -896,6 +888,141 @@ Handle<JSModuleNamespace> Module::GetModuleNamespace(Isolate* isolate,
   Handle<PrototypeInfo> proto_info =
       Map::GetOrCreatePrototypeInfo(Handle<JSObject>::cast(ns), isolate);
   proto_info->set_module_namespace(*ns);
+}
+
+}  // anonymous namespace
+
+MaybeHandle<Object> Module::Evaluate(Isolate* isolate, Handle<Module> module,
+                                     ZoneForwardList<Handle<Module>>* stack,
+                                     unsigned* dfs_index) {
+  if (module->status() == kErrored) {
+    isolate->Throw(module->GetException());
+    return MaybeHandle<Object>();
+  }
+  if (module->status() >= kEvaluating) {
+    return isolate->factory()->undefined_value();
+  }
+  DCHECK_EQ(module->status(), kInstantiated);
+  STACK_CHECK(isolate, MaybeHandle<Object>());
+
+  if (module->module_type() == kDynamicModule) {
+    ReadOnlyRoots roots(isolate);
+    module->SetStatus(kEvaluating);
+    isolate->RunHostExecuteDynamicModuleCallback(
+        handle(isolate->context(), isolate), module);
+    // Ensure that all exports are defined.
+    Handle<ObjectHashTable> exports(module->exports(), isolate);
+    for (int i = 0, n = exports->Capacity(); i < n; ++i) {
+      Object* key;
+      if (!exports->ToKey(roots, i, &key)) continue;
+      Handle<Cell> cell(Cell::cast(exports->ValueAt(i)), isolate);
+      Handle<Object> value(cell->value(), isolate);
+      if (value->IsTheHole()) {
+        Handle<String> name = handle(String::cast(key), isolate);
+        isolate->Throw(*isolate->factory()->NewReferenceError(
+            MessageTemplate::kModuleExportUndefined, name));
+        module->RecordError(isolate);
+        return MaybeHandle<Object>();
+      }
+    }
+
+    // Convert the regular_exports ArrayList into a FixedArray.
+    Handle<ArrayList> regular_exports =
+        handle(ArrayList::cast(module->regular_exports()), isolate);
+    module->set_regular_exports(*ArrayList::Elements(isolate, regular_exports));
+
+    module->SetStatus(kEvaluated);
+
+    Handle<HeapObject> object(module->module_namespace(), isolate);
+    if (object->IsJSModuleNamespace()) {
+      Handle<JSModuleNamespace> ns = Handle<JSModuleNamespace>::cast(object);
+      FinalizeModuleNamespace(isolate, module, ns);
+    }
+    return isolate->factory()->undefined_value();
+  }
+
+  Handle<JSGeneratorObject> generator(JSGeneratorObject::cast(module->code()),
+                                      isolate);
+  module->set_code(
+      generator->function()->shared()->scope_info()->ModuleDescriptorInfo());
+
+  module->SetStatus(kEvaluating);
+  module->set_dfs_index(*dfs_index);
+  module->set_dfs_ancestor_index(*dfs_index);
+  stack->push_front(module);
+  (*dfs_index)++;
+
+  // Recursion.
+  Handle<FixedArray> requested_modules(module->requested_modules(), isolate);
+  for (int i = 0, length = requested_modules->length(); i < length; ++i) {
+    Handle<Module> requested_module(Module::cast(requested_modules->get(i)),
+                                    isolate);
+    RETURN_ON_EXCEPTION(
+        isolate, Evaluate(isolate, requested_module, stack, dfs_index), Object);
+
+    DCHECK_GE(requested_module->status(), kEvaluating);
+    DCHECK_NE(requested_module->status(), kErrored);
+    SLOW_DCHECK(
+        // {requested_module} is evaluating iff it's on the {stack}.
+        (requested_module->status() == kEvaluating) ==
+        std::count_if(stack->begin(), stack->end(), [&](Handle<Module> m) {
+          return *m == *requested_module;
+        }));
+
+    if (requested_module->status() == kEvaluating) {
+      module->set_dfs_ancestor_index(
+          std::min(module->dfs_ancestor_index(),
+                   requested_module->dfs_ancestor_index()));
+    }
+  }
+
+  // Evaluation of module body.
+  Handle<JSFunction> resume(
+      isolate->native_context()->generator_next_internal(), isolate);
+  Handle<Object> result;
+  ASSIGN_RETURN_ON_EXCEPTION(
+      isolate, result, Execution::Call(isolate, resume, generator, 0, nullptr),
+      Object);
+  DCHECK(static_cast<JSIteratorResult*>(JSObject::cast(*result))
+             ->done()
+             ->BooleanValue(isolate));
+
+  CHECK(MaybeTransitionComponent(isolate, module, stack, kEvaluated));
+  return handle(
+      static_cast<JSIteratorResult*>(JSObject::cast(*result))->value(),
+      isolate);
+}
+
+Handle<JSModuleNamespace> Module::GetModuleNamespace(Isolate* isolate,
+                                                     Handle<Module> module,
+                                                     int module_request) {
+  Handle<Module> requested_module(
+      Module::cast(module->requested_modules()->get(module_request)), isolate);
+  return Module::GetModuleNamespace(isolate, requested_module);
+}
+
+Handle<JSModuleNamespace> Module::GetModuleNamespace(Isolate* isolate,
+                                                     Handle<Module> module) {
+  Handle<HeapObject> object(module->module_namespace(), isolate);
+  ReadOnlyRoots roots(isolate);
+  if (!object->IsUndefined(roots)) {
+    // Namespace object already exists.
+    return Handle<JSModuleNamespace>::cast(object);
+  }
+
+  // Create the namespace object (initially empty).
+  Handle<JSModuleNamespace> ns = isolate->factory()->NewJSModuleNamespace();
+  ns->set_module(*module);
+
+  JSObject::PreventExtensions(ns, kThrowOnError).ToChecked();
+
+  if (module->module_type() != kDynamicModule ||
+      module->status() == kEvaluated) {
+    FinalizeModuleNamespace(isolate, module, ns);
+  }
+
+  module->set_module_namespace(*ns);
+
   return ns;
 }
 
diff --git a/deps/v8/src/objects/module.h b/deps/v8/src/objects/module.h
index fd9f9ace80..17f054efa4 100644
--- a/deps/v8/src/objects/module.h
+++ b/deps/v8/src/objects/module.h
@@ -65,6 +65,10 @@ class Module : public Struct, public NeverReadOnlySpaceObject {
     kErrored
   };
 
+  // TODO(neis): Don't store those in the module object?
+  DECL_INT_ACCESSORS(dfs_index)
+  DECL_INT_ACCESSORS(dfs_ancestor_index)
+
   // The exception in the case {status} is kErrored.
   Object* GetException();
 
@@ -88,6 +92,10 @@ class Module : public Struct, public NeverReadOnlySpaceObject {
   // a JSObject afterwards.
   DECL_ACCESSORS(import_meta, Object)
 
+  // Whether this module represents a dynamic module
+  DECL_INT_ACCESSORS(module_type)
+  enum Type { kSourceTextModule, kDynamicModule };
+
   // Get the ModuleInfo associated with the code.
   inline ModuleInfo* info() const;
 
@@ -112,6 +120,10 @@ class Module : public Struct, public NeverReadOnlySpaceObject {
   static int ImportIndex(int cell_index);
   static int ExportIndex(int cell_index);
 
+  static Handle<Cell> CreateDynamicExport(Isolate* isolate,
+                                          Handle<Module> module,
+                                          Handle<String> name);
+
   // Get the namespace object for [module_request] of [module].  If it doesn't
   // exist yet, it is created.
   static Handle<JSModuleNamespace> GetModuleNamespace(Isolate* isolate,
@@ -137,25 +149,14 @@ class Module : public Struct, public NeverReadOnlySpaceObject {
   static const int kExceptionOffset = kDfsAncestorIndexOffset + kPointerSize;
   static const int kScriptOffset = kExceptionOffset + kPointerSize;
   static const int kImportMetaOffset = kScriptOffset + kPointerSize;
-  static const int kSize = kImportMetaOffset + kPointerSize;
+  static const int kModuleTypeOffset = kImportMetaOffset + kPointerSize;
+  static const int kSize = kModuleTypeOffset + kPointerSize;
 
  private:
   friend class Factory;
 
   DECL_ACCESSORS(exception, Object)
 
-  // TODO(neis): Don't store those in the module object?
-  DECL_INT_ACCESSORS(dfs_index)
-  DECL_INT_ACCESSORS(dfs_ancestor_index)
-
-  // Helpers for Instantiate and Evaluate.
-
-  static void CreateExport(Isolate* isolate, Handle<Module> module,
-                           int cell_index, Handle<FixedArray> names);
-  static void CreateIndirectExport(Isolate* isolate, Handle<Module> module,
-                                   Handle<String> name,
-                                   Handle<ModuleInfoEntry> entry);
-
   // The [must_resolve] argument indicates whether or not an exception should be
   // thrown in case the module does not provide an export named [name]
   // (including when a cycle is detected).  An exception is always thrown in the
diff --git a/deps/v8/test/cctest/test-modules.cc b/deps/v8/test/cctest/test-modules.cc
index 2523b83a16..843eb4f685 100644
--- a/deps/v8/test/cctest/test-modules.cc
+++ b/deps/v8/test/cctest/test-modules.cc
@@ -3,12 +3,15 @@
 // found in the LICENSE file.
 
 #include "src/flags.h"
+#include "src/ostreams.h"
 
 #include "test/cctest/cctest.h"
 
 namespace {
 
+using v8::Array;
 using v8::Context;
+using v8::DynamicModule;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
@@ -380,11 +383,13 @@ TEST(ModuleNamespace) {
   Local<Module> module =
       ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
   CHECK_EQ(Module::kUninstantiated, module->GetStatus());
+
   CHECK(module
             ->InstantiateModule(env.local(),
                                 CompileSpecifierAsModuleResolveCallback)
             .FromJust());
   CHECK_EQ(Module::kInstantiated, module->GetStatus());
+
   Local<Value> ns = module->GetModuleNamespace();
   CHECK_EQ(Module::kInstantiated, module->GetStatus());
   Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
@@ -436,6 +441,7 @@ TEST(ModuleNamespace) {
 
   CHECK(!try_catch.HasCaught());
   CHECK_EQ(Module::kInstantiated, module->GetStatus());
+
   module->Evaluate(env.local()).ToLocalChecked();
   CHECK_EQ(Module::kEvaluated, module->GetStatus());
 
@@ -471,4 +477,326 @@ TEST(ModuleNamespace) {
 
   CHECK(!try_catch.HasCaught());
 }
+
+static Local<DynamicModule> dynamic;
+
+void HostExecuteDynamicModuleCallback(Local<Context> context,
+                                      Local<DynamicModule> module) {
+  Isolate* isolate = context->GetIsolate();
+  auto val = v8::Number::New(isolate, 10);
+  module->SetExport(isolate, v8_str("test"), val);
+}
+
+MaybeLocal<Module> ResolveCallbackDynamicModule(Local<Context> context,
+                                                Local<String> specifier,
+                                                Local<Module> referrer) {
+  Isolate* isolate = CcTest::isolate();
+  if (specifier->StrictEquals(v8_str("dynamic"))) {
+    return dynamic;
+  } else if (specifier->StrictEquals(v8_str("./dep1.js"))) {
+    return dep1;
+  } else if (specifier->StrictEquals(v8_str("./dep2.js"))) {
+    return dep2;
+  } else {
+    isolate->ThrowException(v8_str("boom"));
+    return MaybeLocal<Module>();
+  }
+}
+
+TEST(DynamicModule) {
+  Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
+  LocalContext env;
+  v8::TryCatch try_catch(isolate);
+
+  dynamic = ScriptCompiler::CreateDynamicModule(isolate).ToLocalChecked();
+
+  isolate->SetHostExecuteDynamicModuleCallback(
+      HostExecuteDynamicModuleCallback);
+
+  Local<String> source_text = v8_str("export { test as p } from 'dynamic'");
+  ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
+  ScriptCompiler::Source source(source_text, origin);
+  Local<Module> module =
+      ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
+  CHECK_EQ(module->GetStatus(), Module::kUninstantiated);
+  CHECK(module->InstantiateModule(env.local(), ResolveCallbackDynamicModule)
+            .FromJust());
+
+  CHECK_EQ(Module::kInstantiated, module->GetStatus());
+  CHECK_EQ(Module::kInstantiated, dynamic->GetStatus());
+
+  module->Evaluate(env.local()).ToLocalChecked();
+
+  CHECK_EQ(Module::kEvaluated, module->GetStatus());
+  CHECK_EQ(Module::kEvaluated, dynamic->GetStatus());
+
+  Local<Value> ns = module->GetModuleNamespace();
+  Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
+
+  // export was set by dynamic execute hook
+  {
+    auto testVal = nsobj->Get(env.local(), v8_str("p")).ToLocalChecked();
+    CHECK_EQ(10, testVal->Int32Value(env.local()).FromJust());
+  }
+
+  // export can be mutated
+  {
+    auto val = v8::Number::New(isolate, 5);
+    dynamic->SetExport(isolate, v8_str("test"), val);
+
+    auto testVal = nsobj->Get(env.local(), v8_str("p")).ToLocalChecked();
+    CHECK_EQ(5, testVal->Int32Value(env.local()).FromJust());
+  }
+
+  CHECK(!try_catch.HasCaught());
+}
+
+TEST(DynamicModuleNamespaces) {
+  Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
+  LocalContext env;
+  v8::TryCatch try_catch(isolate);
+
+  dynamic = ScriptCompiler::CreateDynamicModule(isolate).ToLocalChecked();
+
+  isolate->SetHostExecuteDynamicModuleCallback(
+      HostExecuteDynamicModuleCallback);
+
+  {
+    Local<String> source_text = v8_str("export * from 'dynamic'");
+    ScriptOrigin origin = ModuleOrigin(v8_str("dep1.js"), CcTest::isolate());
+    ScriptCompiler::Source source(source_text, origin);
+    dep1 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
+  }
+
+  Local<String> source_text =
+      v8_str("import * as X from './dep1.js'; export { X }");
+  ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
+  ScriptCompiler::Source source(source_text, origin);
+  Local<Module> module =
+      ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
+  CHECK_EQ(module->GetStatus(), Module::kUninstantiated);
+  CHECK(module->InstantiateModule(env.local(), ResolveCallbackDynamicModule)
+            .FromJust());
+
+  CHECK_EQ(Module::kInstantiated, module->GetStatus());
+  CHECK_EQ(Module::kInstantiated, dep1->GetStatus());
+  CHECK_EQ(Module::kInstantiated, dynamic->GetStatus());
+
+  module->Evaluate(env.local()).ToLocalChecked();
+
+  CHECK_EQ(Module::kEvaluated, module->GetStatus());
+  CHECK_EQ(Module::kEvaluated, dep1->GetStatus());
+  CHECK_EQ(Module::kEvaluated, dynamic->GetStatus());
+
+  {
+    Local<Value> ns = dynamic->GetModuleNamespace();
+    Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
+
+    auto testVal = nsobj->Get(env.local(), v8_str("test")).ToLocalChecked();
+    CHECK_EQ(10, testVal->Int32Value(env.local()).FromJust());
+  }
+
+  {
+    Local<Value> ns = dep1->GetModuleNamespace();
+    Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
+
+    auto testVal = nsobj->Get(env.local(), v8_str("test")).ToLocalChecked();
+    CHECK_EQ(10, testVal->Int32Value(env.local()).FromJust());
+  }
+
+  Local<Value> ns = module->GetModuleNamespace();
+  Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
+
+  Local<Value> dyn_ns = nsobj->Get(env.local(), v8_str("X")).ToLocalChecked();
+  Local<v8::Object> dyn_nsobj = dyn_ns->ToObject(env.local()).ToLocalChecked();
+
+  auto testVal = dyn_nsobj->Get(env.local(), v8_str("test")).ToLocalChecked();
+  CHECK_EQ(10, testVal->Int32Value(env.local()).FromJust());
+
+  CHECK(!try_catch.HasCaught());
+}
+
+TEST(DynamicStarExportsFail) {
+  Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
+  LocalContext env;
+  v8::TryCatch try_catch(isolate);
+
+  dynamic = ScriptCompiler::CreateDynamicModule(isolate).ToLocalChecked();
+
+  isolate->SetHostExecuteDynamicModuleCallback(
+      HostExecuteDynamicModuleCallback);
+
+  Local<String> source_text = v8_str("export * from 'dynamic'");
+  ScriptOrigin origin = ModuleOrigin(v8_str("dep1.js"), CcTest::isolate());
+  ScriptCompiler::Source source(source_text, origin);
+  dep1 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
+
+  CHECK_EQ(dep1->GetStatus(), Module::kUninstantiated);
+
+  CHECK(dep1->InstantiateModule(env.local(), ResolveCallbackDynamicModule)
+            .IsNothing());
+
+  CHECK_EQ(dep1->GetStatus(), Module::kErrored);
+  CHECK_EQ(dynamic->GetStatus(), Module::kUninstantiated);
+
+  Local<v8::Object> SyntaxError =
+      CompileRun("SyntaxError")->ToObject(env.local()).ToLocalChecked();
+
+  CHECK(try_catch.HasCaught());
+  CHECK(try_catch.Exception()->InstanceOf(env.local(), SyntaxError).FromJust());
+}
+
+TEST(DynamicUnfinishedModuleNamespaces) {
+  Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
+  LocalContext env;
+  v8::TryCatch try_catch(isolate);
+
+  dynamic = ScriptCompiler::CreateDynamicModule(isolate).ToLocalChecked();
+
+  isolate->SetHostExecuteDynamicModuleCallback(
+      HostExecuteDynamicModuleCallback);
+
+  {
+    Local<String> source_text = v8_str(
+        "import './dep2.js';"
+        "import * as X from 'dynamic';"
+        "export function getNS () { return X; }");
+    ScriptOrigin origin = ModuleOrigin(v8_str("dep1.js"), CcTest::isolate());
+    ScriptCompiler::Source source(source_text, origin);
+    dep1 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
+  }
+
+  {
+    Local<String> source_text = v8_str(
+        "import { getNS } from './dep1.js';"
+        "const X = getNS();"
+        "import { test as _test } from './dep2.js';"
+        "export var exists = !!X;"
+        "export var test = X.test;"
+        "export var toStringTag = X[Symbol.toStringTag];"
+        "export var isExtensible = Object.isExtensible(X);"
+        "export var proto = X.__proto__;"
+        "export var keys = Object.keys(X).join(',');"
+        "export var ownKeys = "
+        "  Reflect.ownKeys(X).map(x => x.toString()).join(',');"
+        "export var ns = X;"
+        "export var definedProperty = true;"
+        "try { Object.defineProperty(X, 'test', { value () {} }); }"
+        "catch { definedProperty = false; }"
+        "export var preventedExtensions = true;"
+        "try { Object.preventExtensions(X); }"
+        "catch { preventedExtensions = false; }");
+    ScriptOrigin origin = ModuleOrigin(v8_str("dep2.js"), CcTest::isolate());
+    ScriptCompiler::Source source(source_text, origin);
+    dep2 = ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
+  }
+
+  CHECK_EQ(dep1->GetStatus(), Module::kUninstantiated);
+  CHECK(dep1->InstantiateModule(env.local(), ResolveCallbackDynamicModule)
+            .FromJust());
+
+  CHECK_EQ(Module::kInstantiated, dep1->GetStatus());
+  CHECK_EQ(Module::kInstantiated, dep2->GetStatus());
+  CHECK_EQ(Module::kInstantiated, dynamic->GetStatus());
+
+  Local<Value> ns = dynamic->GetModuleNamespace();
+  Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
+
+  auto testVal = nsobj->Get(env.local(), v8_str("test")).ToLocalChecked();
+  CHECK(testVal->IsUndefined());
+
+  dep1->Evaluate(env.local()).ToLocalChecked();
+
+  CHECK_EQ(Module::kEvaluated, dep1->GetStatus());
+  CHECK_EQ(Module::kEvaluated, dep2->GetStatus());
+  CHECK_EQ(Module::kEvaluated, dynamic->GetStatus());
+
+  testVal = nsobj->Get(env.local(), v8_str("test")).ToLocalChecked();
+  CHECK_EQ(10, testVal->Int32Value(env.local()).FromJust());
+
+  {
+    Local<Value> ns = dep2->GetModuleNamespace();
+    Local<v8::Object> nsobj = ns->ToObject(env.local()).ToLocalChecked();
+
+    auto testVal = nsobj->Get(env.local(), v8_str("exists")).ToLocalChecked();
+    CHECK(testVal->IsTrue());
+
+    testVal = nsobj->Get(env.local(), v8_str("test")).ToLocalChecked();
+    CHECK(testVal->IsUndefined());
+
+    testVal = nsobj->Get(env.local(), v8_str("toStringTag")).ToLocalChecked();
+    CHECK(testVal.As<String>()->StrictEquals(v8_str("Module")));
+
+    testVal = nsobj->Get(env.local(), v8_str("isExtensible")).ToLocalChecked();
+    CHECK(testVal->IsFalse());
+
+    testVal = nsobj->Get(env.local(), v8_str("proto")).ToLocalChecked();
+    CHECK(testVal->IsUndefined());
+
+    testVal = nsobj->Get(env.local(), v8_str("keys")).ToLocalChecked();
+    CHECK(testVal.As<String>()->StrictEquals(v8_str("")));
+
+    testVal = nsobj->Get(env.local(), v8_str("ownKeys")).ToLocalChecked();
+    CHECK(testVal.As<String>()->StrictEquals(
+        v8_str("Symbol(Symbol.toStringTag)")));
+
+    testVal =
+        nsobj->Get(env.local(), v8_str("definedProperty")).ToLocalChecked();
+    CHECK(testVal->IsFalse());
+
+    testVal =
+        nsobj->Get(env.local(), v8_str("preventedExtensions")).ToLocalChecked();
+    CHECK(testVal->IsTrue());
+
+    testVal = nsobj->Get(env.local(), v8_str("ns")).ToLocalChecked();
+    nsobj = testVal->ToObject(env.local()).ToLocalChecked();
+
+    testVal = nsobj->Get(env.local(), v8_str("test")).ToLocalChecked();
+    CHECK_EQ(10, testVal->Int32Value(env.local()).FromJust());
+  }
+
+  CHECK(!try_catch.HasCaught());
+}
+
+TEST(DynamicModuleUnknownExport) {
+  Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
+  LocalContext env;
+  v8::TryCatch try_catch(isolate);
+
+  Local<v8::Object> ReferenceError =
+      CompileRun("ReferenceError")->ToObject(env.local()).ToLocalChecked();
+
+  dynamic = ScriptCompiler::CreateDynamicModule(isolate).ToLocalChecked();
+
+  isolate->SetHostExecuteDynamicModuleCallback(
+      HostExecuteDynamicModuleCallback);
+
+  Local<String> source_text = v8_str("export { p } from 'dynamic'");
+  ScriptOrigin origin = ModuleOrigin(v8_str("file.js"), CcTest::isolate());
+  ScriptCompiler::Source source(source_text, origin);
+  Local<Module> module =
+      ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
+  CHECK_EQ(module->GetStatus(), Module::kUninstantiated);
+  CHECK(module->InstantiateModule(env.local(), ResolveCallbackDynamicModule)
+            .FromJust());
+
+  CHECK_EQ(Module::kInstantiated, module->GetStatus());
+  CHECK_EQ(Module::kInstantiated, dynamic->GetStatus());
+
+  CHECK(module->Evaluate(env.local()).IsEmpty());
+
+  CHECK_EQ(Module::kErrored, module->GetStatus());
+  CHECK_EQ(Module::kErrored, dynamic->GetStatus());
+
+  CHECK(try_catch.HasCaught());
+  // ExportNameUndefined
+  CHECK(try_catch.Exception()
+            ->InstanceOf(env.local(), ReferenceError)
+            .FromJust());
+}
 }  // anonymous namespace
diff --git a/doc/api/cli.md b/doc/api/cli.md
index ee0dd14bdf..da56c6b4ae 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -169,13 +169,6 @@ added: REPLACEME
 
 Enable experimental diagnostic report feature.
 
-### `--experimental-vm-modules`
-<!-- YAML
-added: v9.6.0
--->
-
-Enable experimental ES Module support in the `vm` module.
-
 ### `--force-fips`
 <!-- YAML
 added: v6.0.0
@@ -255,13 +248,6 @@ default) is not firewall-protected.**
 
 See the [debugging security implications][] section for more information.
 
-### `--loader=file`
-<!-- YAML
-added: v9.0.0
--->
-
-Specify the `file` of the custom [experimental ECMAScript Module][] loader.
-
 ### `--max-http-header-size=size`
 <!-- YAML
 added: v11.6.0
@@ -692,13 +678,11 @@ Node.js options that are allowed are:
 - `--experimental-modules`
 - `--experimental-repl-await`
 - `--experimental-report`
-- `--experimental-vm-modules`
 - `--force-fips`
 - `--icu-data-dir`
 - `--inspect`
 - `--inspect-brk`
 - `--inspect-port`
-- `--loader`
 - `--max-http-header-size`
 - `--napi-modules`
 - `--no-deprecation`
@@ -884,7 +868,6 @@ greater than `4` (its current default value). For more information, see the
 [debugger]: debugger.html
 [debugging security implications]: https://nodejs.org/en/docs/guides/debugging-getting-started/#security-implications
 [emit_warning]: process.html#process_process_emitwarning_warning_type_code_ctor
-[experimental ECMAScript Module]: esm.html#esm_loader_hooks
 [libuv threadpool documentation]: http://docs.libuv.org/en/latest/threadpool.html
 [remote code execution]: https://www.owasp.org/index.php/Code_Injection
 [secureProtocol]: tls.html#tls_tls_createsecurecontext_options
diff --git a/doc/api/errors.md b/doc/api/errors.md
index f95e33855c..aaff1447a5 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1447,13 +1447,6 @@ a `dynamicInstantiate` hook.
 A `MessagePort` was found in the object passed to a `postMessage()` call,
 but not provided in the `transferList` for that call.
 
-<a id="ERR_MISSING_MODULE"></a>
-### ERR_MISSING_MODULE
-
-> Stability: 1 - Experimental
-
-An [ES6 module][] could not be resolved.
-
 <a id="ERR_MISSING_PLATFORM_FOR_WORKER"></a>
 ### ERR_MISSING_PLATFORM_FOR_WORKER
 
@@ -1461,12 +1454,12 @@ The V8 platform used by this instance of Node.js does not support creating
 Workers. This is caused by lack of embedder support for Workers. In particular,
 this error will not occur with standard builds of Node.js.
 
-<a id="ERR_MODULE_RESOLUTION_LEGACY"></a>
-### ERR_MODULE_RESOLUTION_LEGACY
+<a id="ERR_MODULE_NOT_FOUND"></a>
+### ERR_MODULE_NOT_FOUND
 
 > Stability: 1 - Experimental
 
-A failure occurred resolving imports in an [ES6 module][].
+An [ESM module][] could not be resolved.
 
 <a id="ERR_MULTIPLE_CALLBACK"></a>
 ### ERR_MULTIPLE_CALLBACK
diff --git a/doc/api/esm.md b/doc/api/esm.md
index bed1dd7b92..df368db700 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -8,23 +8,20 @@
 <!--name=esm-->
 
 Node.js contains support for ES Modules based upon the
-[Node.js EP for ES Modules][].
+[Node.js EP for ES Modules][] and the [ESM Minimal Kernel][].
 
-Not all features of the EP are complete and will be landing as both VM support
-and implementation is ready. Error messages are still being polished.
+The minimal feature set is designed to be compatible with all potential
+future implementations. Expect major changes in the implementation including
+interoperability support, specifier resolution, and default behavior.
 
 ## Enabling
 
 <!-- type=misc -->
 
-The `--experimental-modules` flag can be used to enable features for loading
-ESM modules.
-
-Once this has been set, files ending with `.mjs` will be able to be loaded
-as ES Modules.
+Modules are enabled by default for files ending with `.mjs`:
 
 ```sh
-node --experimental-modules my-app.mjs
+node my-app.mjs
 ```
 
 ## Features
@@ -54,6 +51,10 @@ property:
 
 ## Notable differences between `import` and `require`
 
+### Mandatory file extensions
+
+You must provide a file extension when using the `import` keyword.
+
 ### No NODE_PATH
 
 `NODE_PATH` is not part of resolving `import` specifiers. Please use symlinks
@@ -78,31 +79,32 @@ Modules will be loaded multiple times if the `import` specifier used to resolve
 them have a different query or fragment.
 
 ```js
-import './foo?query=1'; // loads ./foo with query of "?query=1"
-import './foo?query=2'; // loads ./foo with query of "?query=2"
+import './foo.mjs?query=1'; // loads ./foo.mjs with query of "?query=1"
+import './foo.mjs?query=2'; // loads ./foo.mjs with query of "?query=2"
 ```
 
 For now, only modules using the `file:` protocol can be loaded.
 
-## Interop with existing modules
+## CommonJS, JSON, and Native Modules
 
-All CommonJS, JSON, and C++ modules can be used with `import`.
+CommonJS, JSON, and Native modules can be used with [`module.createRequireFromPath()`][].
 
-Modules loaded this way will only be loaded once, even if their query
-or fragment string differs between `import` statements.
+```js
+// cjs.js
+module.exports = 'cjs';
 
-When loaded via `import` these modules will provide a single `default` export
-representing the value of `module.exports` at the time they finished evaluating.
+// esm.mjs
+import { createRequireFromPath as createRequire } from 'module';
+import { fileURLToPath as fromPath } from 'url';
 
-```js
-// foo.js
-module.exports = { one: 1 };
+const require = createRequire(fromPath(import.meta.url));
 
-// bar.js
-import foo from './foo.js';
-foo.one === 1; // true
+const cjs = require('./cjs');
+cjs === 'cjs'; // true
 ```
 
+## Builtin modules
+
 Builtin modules will provide named exports of their public API, as well as a
 default export which can be used for, among other things, modifying the named
 exports. Named exports of builtin modules are updated when the corresponding
@@ -132,127 +134,143 @@ fs.readFileSync = () => Buffer.from('Hello, ESM');
 fs.readFileSync === readFileSync;
 ```
 
-## Loader hooks
-
-<!-- type=misc -->
-
-To customize the default module resolution, loader hooks can optionally be
-provided via a `--loader ./loader-name.mjs` argument to Node.js.
-
-When hooks are used they only apply to ES module loading and not to any
-CommonJS modules loaded.
-
-### Resolve hook
-
-The resolve hook returns the resolved file URL and module format for a
-given module specifier and parent file URL:
-
-```js
-const baseURL = new URL('file://');
-baseURL.pathname = `${process.cwd()}/`;
-
-export async function resolve(specifier,
-                              parentModuleURL = baseURL,
-                              defaultResolver) {
-  return {
-    url: new URL(specifier, parentModuleURL).href,
-    format: 'esm'
-  };
-}
-```
-
-The `parentModuleURL` is provided as `undefined` when performing main Node.js
-load itself.
-
-The default Node.js ES module resolution function is provided as a third
-argument to the resolver for easy compatibility workflows.
-
-In addition to returning the resolved file URL value, the resolve hook also
-returns a `format` property specifying the module format of the resolved
-module. This can be one of the following:
-
-| `format` | Description |
-| --- | --- |
-| `'esm'` | Load a standard JavaScript module |
-| `'cjs'` | Load a node-style CommonJS module |
-| `'builtin'` | Load a node builtin CommonJS module |
-| `'json'` | Load a JSON file |
-| `'addon'` | Load a [C++ Addon][addons] |
-| `'dynamic'` | Use a [dynamic instantiate hook][] |
-
-For example, a dummy loader to load JavaScript restricted to browser resolution
-rules with only JS file extension and Node.js builtin modules support could
-be written:
-
-```js
-import path from 'path';
-import process from 'process';
-import Module from 'module';
-
-const builtins = Module.builtinModules;
-const JS_EXTENSIONS = new Set(['.js', '.mjs']);
-
-const baseURL = new URL('file://');
-baseURL.pathname = `${process.cwd()}/`;
-
-export function resolve(specifier, parentModuleURL = baseURL, defaultResolve) {
-  if (builtins.includes(specifier)) {
-    return {
-      url: specifier,
-      format: 'builtin'
-    };
-  }
-  if (/^\.{0,2}[/]/.test(specifier) !== true && !specifier.startsWith('file:')) {
-    // For node_modules support:
-    // return defaultResolve(specifier, parentModuleURL);
-    throw new Error(
-      `imports must begin with '/', './', or '../'; '${specifier}' does not`);
-  }
-  const resolved = new URL(specifier, parentModuleURL);
-  const ext = path.extname(resolved.pathname);
-  if (!JS_EXTENSIONS.has(ext)) {
-    throw new Error(
-      `Cannot load file with non-JavaScript file extension ${ext}.`);
-  }
-  return {
-    url: resolved.href,
-    format: 'esm'
-  };
-}
-```
-
-With this loader, running:
-
-```console
-NODE_OPTIONS='--experimental-modules --loader ./custom-loader.mjs' node x.js
-```
-
-would load the module `x.js` as an ES module with relative resolution support
-(with `node_modules` loading skipped in this example).
-
-### Dynamic instantiate hook
-
-To create a custom dynamic module that doesn't correspond to one of the
-existing `format` interpretations, the `dynamicInstantiate` hook can be used.
-This hook is called only for modules that return `format: 'dynamic'` from
-the `resolve` hook.
-
-```js
-export async function dynamicInstantiate(url) {
-  return {
-    exports: ['customExportName'],
-    execute: (exports) => {
-      // Get and set functions provided for pre-allocated export names
-      exports.customExportName.set('value');
-    }
-  };
-}
-```
-
-With the list of module exports provided upfront, the `execute` function will
-then be called at the exact point of module evaluation order for that module
-in the import tree.
+## Resolution Algorithm
+
+### Features
+
+The resolver has the following properties:
+
+* FileURL-based resolution as is used by ES modules
+* Support for builtin module loading
+* Relative and absolute URL resolution
+* No default extensions
+* No folder mains
+* Bare specifier package resolution lookup through node_modules
+
+### Resolver Algorithm
+
+The algorithm to load an ES module specifier is given through the
+**ESM_RESOLVE** method below. It returns the resolved URL for a
+module specifier relative to a parentURL, in addition to the unique module
+format for that resolved URL given by the **ESM_FORMAT** routine.
+
+The _"esm"_ format is returned for an ECMAScript Module, while the
+_"legacy"_ format is used to indicate loading through the legacy
+CommonJS loader. Additional formats such as _"wasm"_ or _"addon"_ can be
+extended in future updates.
+
+In the following algorithms, all subroutine errors are propogated as errors
+of these top-level routines.
+
+_isMain_ is **true** when resolving the Node.js application entry point.
+
+**ESM_RESOLVE(_specifier_, _parentURL_, _isMain_)**
+> 1. Let _resolvedURL_ be **undefined**.
+> 1. If _specifier_ is a valid URL, then
+>    1. Set _resolvedURL_ to the result of parsing and reserializing
+>       _specifier_ as a URL.
+> 1. Otherwise, if _specifier_ starts with _"/"_, then
+>    1. Throw an _Invalid Specifier_ error.
+> 1. Otherwise, if _specifier_ starts with _"./"_ or _"../"_, then
+>    1. Set _resolvedURL_ to the URL resolution of _specifier_ relative to
+>       _parentURL_.
+> 1. Otherwise,
+>    1. Note: _specifier_ is now a bare specifier.
+>    1. Set _resolvedURL_ the result of
+>       **PACKAGE_RESOLVE**(_specifier_, _parentURL_).
+> 1. If the file at _resolvedURL_ does not exist, then
+>    1. Throw a _Module Not Found_ error.
+> 1. Let _format_ be the result of **ESM_FORMAT**(_url_, _isMain_).
+> 1. Load _resolvedURL_ as module format, _format_.
+
+PACKAGE_RESOLVE(_packageSpecifier_, _parentURL_)
+> 1. Let _packageName_ be *undefined*.
+> 1. Let _packageSubpath_ be *undefined*.
+> 1. If _packageSpecifier_ is an empty string, then
+>    1. Throw an _Invalid Specifier_ error.
+> 1. If _packageSpecifier_ does not start with _"@"_, then
+>    1. Set _packageName_ to the substring of _packageSpecifier_ until the
+>       first _"/"_ separator or the end of the string.
+> 1. Otherwise,
+>    1. If _packageSpecifier_ does not contain a _"/"_ separator, then
+>       1. Throw an _Invalid Specifier_ error.
+>    1. Set _packageName_ to the substring of _packageSpecifier_
+>       until the second _"/"_ separator or the end of the string.
+> 1. Let _packageSubpath_ be the substring of _packageSpecifier_ from the
+>    position at the length of _packageName_ plus one, if any.
+> 1. Assert: _packageName_ is a valid package name or scoped package name.
+> 1. Assert: _packageSubpath_ is either empty, or a path without a leading
+>    separator.
+> 1. If _packageSubpath_ contains any _"."_ or _".."_ segments or percent
+>    encoded strings for _"/"_ or _"\"_ then,
+>    1. Throw an _Invalid Specifier_ error.
+> 1. If _packageSubpath_ is empty and _packageName_ is a Node.js builtin
+>    module, then
+>    1. Return the string _"node:"_ concatenated with _packageSpecifier_.
+> 1. While _parentURL_ is not the file system root,
+>    1. Set _parentURL_ to the parent folder URL of _parentURL_.
+>    1. Let _packageURL_ be the URL resolution of the string concatenation of
+>       _parentURL_, _"/node_modules/"_ and _packageSpecifier_.
+>    1. If the folder at _packageURL_ does not exist, then
+>       1. Set _parentURL_ to the parent URL path of _parentURL_.
+>       1. Continue the next loop iteration.
+>    1. Let _pjson_be the result of **READ_PACKAGE_JSON**(_packageURL_).
+>    1. If _packageSubpath_ is empty, then
+>       1. Return the result of **PACKAGE_MAIN_RESOLVE**(_packageURL_,
+>          _pjson_).
+>    1. Otherwise,
+>       1. Return the URL resolution of _packageSubpath_ in _packageURL_.
+> 1. Throw a _Module Not Found_ error.
+
+PACKAGE_MAIN_RESOLVE(_packageURL_, _pjson_)
+> 1. If _pjson_ is **null**, then
+>    1. Throw a _Module Not Found_ error.
+> 1. If _pjson.main_ is a String, then
+>    1. Let _resolvedMain_ be the concatenation of _packageURL_, "/", and
+>       _"pjson.main"_.
+>    1. If the file at _resolvedMain_ exists, then
+>       1. Return _resolvedMain_.
+> 1. If _pjson.type_ is equal to _"esm"_, then
+>    1. Throw a _Module Not Found_ error.
+> 1. Let _legacyMainURL_ be the result applying the legacy
+>    **LOAD_AS_DIRECTORY** CommonJS resolver to _packageURL_, throwing a
+>    _Module Not Found_ error for no resolution.
+> 1. If _legacyMainURL_ does not end in _".js"_ then,
+>    1. Throw an _Unsupported File Extension_ error.
+> 1. Return _legacyMainURL_.
+
+**ESM_FORMAT(_url_, _isMain_)**
+> 1. Assert: _url_ corresponds to an existing file.
+> 1. Let _pjson_ be the result of **READ_PACKAGE_BOUNDARY**(_url_).
+> 1. If _pjson_ is **null** and _isMain_ is **true**, then
+>    1. Return _"legacy"_.
+> 1. If _pjson.type_ exists and is _"esm"_, then
+>    1. If _url_ does not end in _".js"_ or _".mjs"_, then
+>       1. Throw an _Unsupported File Extension_ error.
+>    1. Return _"esm"_.
+> 1. Otherwise,
+>    1. If _url_ ends in _".mjs"_, then
+>       1. Return _"esm"_.
+>    1. Otherwise,
+>       1. Return _"legacy"_.
+
+READ_PACKAGE_BOUNDARY(_url_)
+> 1. Let _boundaryURL_ be _url_.
+> 1. While _boundaryURL_ is not the file system root,
+>    1. Let _pjson_ be the result of **READ_PACKAGE_JSON**(_boundaryURL_).
+>    1. If _pjson_ is not **null**, then
+>       1. Return _pjson_.
+>    1. Set _boundaryURL_ to the parent URL of _boundaryURL_.
+> 1. Return **null**.
+
+READ_PACKAGE_JSON(_packageURL_)
+> 1. Let _pjsonURL_ be the resolution of _"package.json"_ within _packageURL_.
+> 1. If the file at _pjsonURL_ does not exist, then
+>    1. Return **null**.
+> 1. If the file at _packageURL_ does not parse as valid JSON, then
+>    1. Throw an _Invalid Package Configuration_ error.
+> 1. Return the parsed JSON source of the file at _url_.
 
 [Node.js EP for ES Modules]: https://github.com/nodejs/node-eps/blob/master/002-es-modules.md
-[addons]: addons.html
-[dynamic instantiate hook]: #esm_dynamic_instantiate_hook
+[`module.createRequireFromPath()`]: modules.html#modules_module_createrequirefrompath_filename
+[ESM Minimal Kernel]: https://github.com/nodejs/modules/blob/master/doc/plan-for-new-modules-implementation.md
diff --git a/doc/api/vm.md b/doc/api/vm.md
index 808ed2f00d..bc46d090ee 100644
--- a/doc/api/vm.md
+++ b/doc/api/vm.md
@@ -85,17 +85,6 @@ changes:
     depending on whether code cache data is produced successfully.
     This option is **deprecated** in favor of `script.createCachedData()`.
     **Default:** `false`.
-  * `importModuleDynamically` {Function} Called during evaluation of this module
-    when `import()` is called. If this option is not specified, calls to
-    `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental API for the `--experimental-modules`
-    flag, and should not be considered stable.
-     * `specifier` {string} specifier passed to `import()`
-     * `module` {vm.SourceTextModule}
-     * Returns: {Module Namespace Object|vm.SourceTextModule} Returning a
-       `vm.SourceTextModule` is recommended in order to take advantage of error
-       tracking, and to avoid issues with namespaces that contain `then`
-       function exports.
 
 If `options` is a string, then it specifies the filename.
 
@@ -301,366 +290,6 @@ console.log(globalVar);
 // 1000
 ```
 
-## Class: vm.SourceTextModule
-<!-- YAML
-added: v9.6.0
--->
-
-> Stability: 1 - Experimental
-
-*This feature is only available with the `--experimental-vm-modules` command
-flag enabled.*
-
-The `vm.SourceTextModule` class provides a low-level interface for using
-ECMAScript modules in VM contexts. It is the counterpart of the `vm.Script`
-class that closely mirrors [Source Text Module Record][]s as defined in the
-ECMAScript specification.
-
-Unlike `vm.Script` however, every `vm.SourceTextModule` object is bound to a
-context from its creation. Operations on `vm.SourceTextModule` objects are
-intrinsically asynchronous, in contrast with the synchronous nature of
-`vm.Script` objects. With the help of async functions, however, manipulating
-`vm.SourceTextModule` objects is fairly straightforward.
-
-Using a `vm.SourceTextModule` object requires four distinct steps:
-creation/parsing, linking, instantiation, and evaluation. These four steps are
-illustrated in the following example.
-
-This implementation lies at a lower level than the [ECMAScript Module
-loader][]. There is also currently no way to interact with the Loader, though
-support is planned.
-
-```js
-const vm = require('vm');
-
-const contextifiedSandbox = vm.createContext({ secret: 42 });
-
-(async () => {
-  // Step 1
-  //
-  // Create a Module by constructing a new `vm.SourceTextModule` object. This
-  // parses the provided source text, throwing a `SyntaxError` if anything goes
-  // wrong. By default, a Module is created in the top context. But here, we
-  // specify `contextifiedSandbox` as the context this Module belongs to.
-  //
-  // Here, we attempt to obtain the default export from the module "foo", and
-  // put it into local binding "secret".
-
-  const bar = new vm.SourceTextModule(`
-    import s from 'foo';
-    s;
-  `, { context: contextifiedSandbox });
-
-  // Step 2
-  //
-  // "Link" the imported dependencies of this Module to it.
-  //
-  // The provided linking callback (the "linker") accepts two arguments: the
-  // parent module (`bar` in this case) and the string that is the specifier of
-  // the imported module. The callback is expected to return a Module that
-  // corresponds to the provided specifier, with certain requirements documented
-  // in `module.link()`.
-  //
-  // If linking has not started for the returned Module, the same linker
-  // callback will be called on the returned Module.
-  //
-  // Even top-level Modules without dependencies must be explicitly linked. The
-  // callback provided would never be called, however.
-  //
-  // The link() method returns a Promise that will be resolved when all the
-  // Promises returned by the linker resolve.
-  //
-  // Note: This is a contrived example in that the linker function creates a new
-  // "foo" module every time it is called. In a full-fledged module system, a
-  // cache would probably be used to avoid duplicated modules.
-
-  async function linker(specifier, referencingModule) {
-    if (specifier === 'foo') {
-      return new vm.SourceTextModule(`
-        // The "secret" variable refers to the global variable we added to
-        // "contextifiedSandbox" when creating the context.
-        export default secret;
-      `, { context: referencingModule.context });
-
-      // Using `contextifiedSandbox` instead of `referencingModule.context`
-      // here would work as well.
-    }
-    throw new Error(`Unable to resolve dependency: ${specifier}`);
-  }
-  await bar.link(linker);
-
-  // Step 3
-  //
-  // Instantiate the top-level Module.
-  //
-  // Only the top-level Module needs to be explicitly instantiated; its
-  // dependencies will be recursively instantiated by instantiate().
-
-  bar.instantiate();
-
-  // Step 4
-  //
-  // Evaluate the Module. The evaluate() method returns a Promise with a single
-  // property "result" that contains the result of the very last statement
-  // executed in the Module. In the case of `bar`, it is `s;`, which refers to
-  // the default export of the `foo` module, the `secret` we set in the
-  // beginning to 42.
-
-  const { result } = await bar.evaluate();
-
-  console.log(result);
-  // Prints 42.
-})();
-```
-
-### Constructor: new vm.SourceTextModule(code[, options])
-
-* `code` {string} JavaScript Module code to parse
-* `options`
-  * `url` {string} URL used in module resolution and stack traces. **Default:**
-    `'vm:module(i)'` where `i` is a context-specific ascending index.
-  * `context` {Object} The [contextified][] object as returned by the
-    `vm.createContext()` method, to compile and evaluate this `Module` in.
-  * `lineOffset` {integer} Specifies the line number offset that is displayed
-    in stack traces produced by this `Module`. **Default:** `0`.
-  * `columnOffset` {integer} Specifies the column number offset that is
-    displayed in stack traces produced by this `Module`. **Default:** `0`.
-  * `initializeImportMeta` {Function} Called during evaluation of this `Module`
-    to initialize the `import.meta`.
-    * `meta` {import.meta}
-    * `module` {vm.SourceTextModule}
-  * `importModuleDynamically` {Function} Called during evaluation of this module
-    when `import()` is called. If this option is not specified, calls to
-    `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-     * `specifier` {string} specifier passed to `import()`
-     * `module` {vm.SourceTextModule}
-     * Returns: {Module Namespace Object|vm.SourceTextModule} Returning a
-       `vm.SourceTextModule` is recommended in order to take advantage of error
-       tracking, and to avoid issues with namespaces that contain `then`
-       function exports.
-
-Creates a new ES `Module` object.
-
-Properties assigned to the `import.meta` object that are objects may
-allow the `Module` to access information outside the specified `context`, if the
-object is created in the top level context. Use `vm.runInContext()` to create
-objects in a specific context.
-
-```js
-const vm = require('vm');
-
-const contextifiedSandbox = vm.createContext({ secret: 42 });
-
-(async () => {
-  const module = new vm.SourceTextModule(
-    'Object.getPrototypeOf(import.meta.prop).secret = secret;',
-    {
-      initializeImportMeta(meta) {
-        // Note: this object is created in the top context. As such,
-        // Object.getPrototypeOf(import.meta.prop) points to the
-        // Object.prototype in the top context rather than that in
-        // the sandbox.
-        meta.prop = {};
-      }
-    });
-  // Since module has no dependencies, the linker function will never be called.
-  await module.link(() => {});
-  module.instantiate();
-  await module.evaluate();
-
-  // Now, Object.prototype.secret will be equal to 42.
-  //
-  // To fix this problem, replace
-  //     meta.prop = {};
-  // above with
-  //     meta.prop = vm.runInContext('{}', contextifiedSandbox);
-})();
-```
-
-### module.dependencySpecifiers
-
-* {string[]}
-
-The specifiers of all dependencies of this module. The returned array is frozen
-to disallow any changes to it.
-
-Corresponds to the `[[RequestedModules]]` field of
-[Source Text Module Record][]s in the ECMAScript specification.
-
-### module.error
-
-* {any}
-
-If the `module.status` is `'errored'`, this property contains the exception
-thrown by the module during evaluation. If the status is anything else,
-accessing this property will result in a thrown exception.
-
-The value `undefined` cannot be used for cases where there is not a thrown
-exception due to possible ambiguity with `throw undefined;`.
-
-Corresponds to the `[[EvaluationError]]` field of [Source Text Module Record][]s
-in the ECMAScript specification.
-
-### module.evaluate([options])
-
-* `options` {Object}
-  * `timeout` {integer} Specifies the number of milliseconds to evaluate
-    before terminating execution. If execution is interrupted, an [`Error`][]
-    will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have
-    been attached via `process.on('SIGINT')` will be disabled during script
-    execution, but will continue to work after that. If execution is
-    interrupted, an [`Error`][] will be thrown. **Default:** `false`.
-* Returns: {Promise}
-
-Evaluate the module.
-
-This must be called after the module has been instantiated; otherwise it will
-throw an error. It could be called also when the module has already been
-evaluated, in which case it will do one of the following two things:
-
-- return `undefined` if the initial evaluation ended in success (`module.status`
-  is `'evaluated'`)
-- rethrow the same exception the initial evaluation threw if the initial
-  evaluation ended in an error (`module.status` is `'errored'`)
-
-This method cannot be called while the module is being evaluated
-(`module.status` is `'evaluating'`) to prevent infinite recursion.
-
-Corresponds to the [Evaluate() concrete method][] field of [Source Text Module
-Record][]s in the ECMAScript specification.
-
-### module.instantiate()
-
-Instantiate the module. This must be called after linking has completed
-(`linkingStatus` is `'linked'`); otherwise it will throw an error. It may also
-throw an exception if one of the dependencies does not provide an export the
-parent module requires.
-
-However, if this function succeeded, further calls to this function after the
-initial instantiation will be no-ops, to be consistent with the ECMAScript
-specification.
-
-Unlike other methods operating on `Module`, this function completes
-synchronously and returns nothing.
-
-Corresponds to the [Instantiate() concrete method][] field of [Source Text
-Module Record][]s in the ECMAScript specification.
-
-### module.link(linker)
-
-* `linker` {Function}
-  * `specifier` {string} The specifier of the requested module:
-    <!-- eslint-skip -->
-    ```js
-    import foo from 'foo';
-    //              ^^^^^ the module specifier
-    ```
-  * `referencingModule` {vm.SourceTextModule} The `Module` object `link()` is
-    called on.
-  * Returns: {vm.SourceTextModule|Promise}
-* Returns: {Promise}
-
-Link module dependencies. This method must be called before instantiation, and
-can only be called once per module.
-
-The function is expected to return a `Module` object or a `Promise` that
-eventually resolves to a `Module` object. The returned `Module` must satisfy the
-following two invariants:
-
-- It must belong to the same context as the parent `Module`.
-- Its `linkingStatus` must not be `'errored'`.
-
-If the returned `Module`'s `linkingStatus` is `'unlinked'`, this method will be
-recursively called on the returned `Module` with the same provided `linker`
-function.
-
-`link()` returns a `Promise` that will either get resolved when all linking
-instances resolve to a valid `Module`, or rejected if the linker function either
-throws an exception or returns an invalid `Module`.
-
-The linker function roughly corresponds to the implementation-defined
-[HostResolveImportedModule][] abstract operation in the ECMAScript
-specification, with a few key differences:
-
-- The linker function is allowed to be asynchronous while
-  [HostResolveImportedModule][] is synchronous.
-- The linker function is executed during linking, a Node.js-specific stage
-  before instantiation, while [HostResolveImportedModule][] is called during
-  instantiation.
-
-The actual [HostResolveImportedModule][] implementation used during module
-instantiation is one that returns the modules linked during linking. Since at
-that point all modules would have been fully linked already, the
-[HostResolveImportedModule][] implementation is fully synchronous per
-specification.
-
-### module.linkingStatus
-
-* {string}
-
-The current linking status of `module`. It will be one of the following values:
-
-- `'unlinked'`: `module.link()` has not yet been called.
-- `'linking'`: `module.link()` has been called, but not all Promises returned by
-  the linker function have been resolved yet.
-- `'linked'`: `module.link()` has been called, and all its dependencies have
-  been successfully linked.
-- `'errored'`: `module.link()` has been called, but at least one of its
-  dependencies failed to link, either because the callback returned a `Promise`
-  that is rejected, or because the `Module` the callback returned is invalid.
-
-### module.namespace
-
-* {Object}
-
-The namespace object of the module. This is only available after instantiation
-(`module.instantiate()`) has completed.
-
-Corresponds to the [GetModuleNamespace][] abstract operation in the ECMAScript
-specification.
-
-### module.status
-
-* {string}
-
-The current status of the module. Will be one of:
-
-- `'uninstantiated'`: The module is not instantiated. It may because of any of
-  the following reasons:
-
-  - The module was just created.
-  - `module.instantiate()` has been called on this module, but it failed for
-    some reason.
-
-  This status does not convey any information regarding if `module.link()` has
-  been called. See `module.linkingStatus` for that.
-
-- `'instantiating'`: The module is currently being instantiated through a
-  `module.instantiate()` call on itself or a parent module.
-
-- `'instantiated'`: The module has been instantiated successfully, but
-  `module.evaluate()` has not yet been called.
-
-- `'evaluating'`: The module is being evaluated through a `module.evaluate()` on
-  itself or a parent module.
-
-- `'evaluated'`: The module has been successfully evaluated.
-
-- `'errored'`: The module has been evaluated, but an exception was thrown.
-
-Other than `'errored'`, this status string corresponds to the specification's
-[Source Text Module Record][]'s `[[Status]]` field. `'errored'` corresponds to
-`'evaluated'` in the specification, but with `[[EvaluationError]]` set to a
-value that is not `undefined`.
-
-### module.url
-
-* {string}
-
-The URL of the current module, as set in the constructor.
-
 ## vm.compileFunction(code[, params[, options]])
 <!-- YAML
 added: v10.10.0
@@ -811,18 +440,6 @@ changes:
     depending on whether code cache data is produced successfully.
     This option is **deprecated** in favor of `script.createCachedData()`.
     **Default:** `false`.
-  * `importModuleDynamically` {Function} Called during evaluation of this module
-    when `import()` is called. If this option is not specified, calls to
-    `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental API for the `--experimental-modules`
-    flag, and should not be considered stable.
-     * `specifier` {string} specifier passed to `import()`
-     * `module` {vm.SourceTextModule}
-     * Returns: {Module Namespace Object|vm.SourceTextModule} Returning a
-       `vm.SourceTextModule` is recommended in order to take advantage of error
-       tracking, and to avoid issues with namespaces that contain `then`
-       function exports.
-* Returns: {any} the result of the very last statement executed in the script.
 
 The `vm.runInContext()` method compiles `code`, runs it within the context of
 the `contextifiedSandbox`, then returns the result. Running code does not have
@@ -909,17 +526,6 @@ changes:
     depending on whether code cache data is produced successfully.
     This option is **deprecated** in favor of `script.createCachedData()`.
     **Default:** `false`.
-  * `importModuleDynamically` {Function} Called during evaluation of this module
-    when `import()` is called. If this option is not specified, calls to
-    `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental API for the `--experimental-modules`
-    flag, and should not be considered stable.
-     * `specifier` {string} specifier passed to `import()`
-     * `module` {vm.SourceTextModule}
-     * Returns: {Module Namespace Object|vm.SourceTextModule} Returning a
-       `vm.SourceTextModule` is recommended in order to take advantage of error
-       tracking, and to avoid issues with namespaces that contain `then`
-       function exports.
 * Returns: {any} the result of the very last statement executed in the script.
 
 The `vm.runInNewContext()` first contextifies the given `sandbox` object (or
@@ -987,17 +593,6 @@ changes:
     depending on whether code cache data is produced successfully.
     This option is **deprecated** in favor of `script.createCachedData()`.
     **Default:** `false`.
-  * `importModuleDynamically` {Function} Called during evaluation of this module
-    when `import()` is called. If this option is not specified, calls to
-    `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental API for the `--experimental-modules`
-    flag, and should not be considered stable.
-     * `specifier` {string} specifier passed to `import()`
-     * `module` {vm.SourceTextModule}
-     * Returns: {Module Namespace Object|vm.SourceTextModule} Returning a
-       `vm.SourceTextModule` is recommended in order to take advantage of error
-       tracking, and to avoid issues with namespaces that contain `then`
-       function exports.
 * Returns: {any} the result of the very last statement executed in the script.
 
 `vm.runInThisContext()` compiles `code`, runs it within the context of the
@@ -1114,7 +709,6 @@ the `process.nextTick()` and `queueMicrotask()` functions.
 This issue occurs because all contexts share the same microtask and nextTick
 queues.
 
-[`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`]: errors.html#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING
 [`Error`]: errors.html#errors_class_error
 [`URL`]: url.html#url_class_url
 [`eval()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
@@ -1124,12 +718,6 @@ queues.
 [`vm.createContext()`]: #vm_vm_createcontext_sandbox_options
 [`vm.runInContext()`]: #vm_vm_runincontext_code_contextifiedsandbox_options
 [`vm.runInThisContext()`]: #vm_vm_runinthiscontext_code_options
-[ECMAScript Module Loader]: esm.html#esm_ecmascript_modules
-[Evaluate() concrete method]: https://tc39.github.io/ecma262/#sec-moduleevaluation
-[GetModuleNamespace]: https://tc39.github.io/ecma262/#sec-getmodulenamespace
-[HostResolveImportedModule]: https://tc39.github.io/ecma262/#sec-hostresolveimportedmodule
-[Instantiate() concrete method]: https://tc39.github.io/ecma262/#sec-moduledeclarationinstantiation
-[Source Text Module Record]: https://tc39.github.io/ecma262/#sec-source-text-module-records
 [V8 Embedder's Guide]: https://v8.dev/docs/embed#contexts
 [contextified]: #vm_what_does_it_mean_to_contextify_an_object
 [global object]: https://es5.github.io/#x15.1
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index dec4f12ea6..035d39df22 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -241,8 +241,7 @@ function startup() {
   }
 
   const experimentalModules = getOptionValue('--experimental-modules');
-  const experimentalVMModules = getOptionValue('--experimental-vm-modules');
-  if (experimentalModules || experimentalVMModules) {
+  if (experimentalModules) {
     if (experimentalModules) {
       process.emitWarning(
         'The ESM module loader is experimental.',
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index f8d7aafeec..7f2c73b642 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -864,11 +864,6 @@ E('ERR_MISSING_ARGS',
 E('ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK',
   'The ES Module loader may not return a format of \'dynamic\' when no ' +
   'dynamicInstantiate function was provided', Error);
-E('ERR_MISSING_MODULE', 'Cannot find module %s', Error);
-E('ERR_MODULE_RESOLUTION_LEGACY',
-  '%s not found by import in %s.' +
-    ' Legacy behavior in require() would have found it at %s',
-  Error);
 E('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times', Error);
 E('ERR_NAPI_CONS_FUNCTION', 'Constructor must be a function', TypeError);
 E('ERR_NAPI_INVALID_DATAVIEW_ARGS',
@@ -966,13 +961,15 @@ E('ERR_UNHANDLED_ERROR',
     if (err === undefined) return msg;
     return `${msg} (${err})`;
   }, Error);
+// This should probably be a `TypeError`.
 E('ERR_UNKNOWN_CREDENTIAL', '%s identifier does not exist: %s', Error);
 E('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s', TypeError);
 
 // This should probably be a `TypeError`.
-E('ERR_UNKNOWN_FILE_EXTENSION', 'Unknown file extension: %s', Error);
 E('ERR_UNKNOWN_MODULE_FORMAT', 'Unknown module format: %s', RangeError);
 E('ERR_UNKNOWN_SIGNAL', 'Unknown signal: %s', TypeError);
+E('ERR_UNSUPPORTED_FILE_EXTENSION', 'Unsupported file extension: \'%s\' ' +
+  'imported from %s', Error);
 
 E('ERR_V8BREAKITERATOR',
   'Full ICU data not installed. See https://github.com/nodejs/node/wiki/Intl',
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 1dcf5ef6ac..666bdecbbd 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -58,15 +58,10 @@ const { validateString } = require('internal/validators');
 module.exports = Module;
 
 let asyncESM;
-let ModuleJob;
-let createDynamicModule;
 let decorateErrorStack;
 
 function lazyLoadESM() {
   asyncESM = require('internal/process/esm_loader');
-  ModuleJob = require('internal/modules/esm/module_job');
-  createDynamicModule = require(
-    'internal/modules/esm/create_dynamic_module');
   decorateErrorStack = require('internal/util').decorateErrorStack;
 }
 
@@ -628,28 +623,14 @@ Module.prototype.load = function(filename) {
   var extension = findLongestRegisteredExtension(filename);
   Module._extensions[extension](this, filename);
   this.loaded = true;
-
+  
   if (experimentalModules) {
-    if (asyncESM === undefined) lazyLoadESM();
     const ESMLoader = asyncESM.ESMLoader;
     const url = `${pathToFileURL(filename)}`;
     const module = ESMLoader.moduleMap.get(url);
-    // Create module entry at load time to snapshot exports correctly
-    const exports = this.exports;
-    if (module !== undefined) { // called from cjs translator
-      module.reflect.onReady((reflect) => {
-        reflect.exports.default.set(exports);
-      });
-    } else { // preemptively cache
-      ESMLoader.moduleMap.set(
-        url,
-        new ModuleJob(ESMLoader, url, async () => {
-          return createDynamicModule(
-            ['default'], url, (reflect) => {
-              reflect.exports.default.set(exports);
-            });
-        })
-      );
+    // Preemptively cache for ESM loader if not initiated there.
+    if (module === undefined) {
+      ESMLoader.cjsCache.set(url, exports);
     }
   }
 };
@@ -788,7 +769,11 @@ if (experimentalModules) {
 // bootstrap main module.
 Module.runMain = function() {
   // Load the main module--the command line argument.
-  if (experimentalModules) {
+  const base = path.basename(process.argv[1]);
+  const ext = path.extname(base);
+  const isESM = ext === '.mjs';
+
+  if (experimentalModules && isESM) {
     if (asyncESM === undefined) lazyLoadESM();
     asyncESM.loaderPromise.then((loader) => {
       return loader.import(pathToFileURL(process.argv[1]).pathname);
diff --git a/lib/internal/modules/esm/create_dynamic_module.js b/lib/internal/modules/esm/create_dynamic_module.js
deleted file mode 100644
index d4356b4b67..0000000000
--- a/lib/internal/modules/esm/create_dynamic_module.js
+++ /dev/null
@@ -1,56 +0,0 @@
-'use strict';
-
-const { ModuleWrap, callbackMap } = internalBinding('module_wrap');
-const debug = require('util').debuglog('esm');
-const ArrayJoin = Function.call.bind(Array.prototype.join);
-const ArrayMap = Function.call.bind(Array.prototype.map);
-
-const createDynamicModule = (exports, url = '', evaluate) => {
-  debug('creating ESM facade for %s with exports: %j', url, exports);
-  const names = ArrayMap(exports, (name) => `${name}`);
-
-  const source = `
-${ArrayJoin(ArrayMap(names, (name) =>
-    `let $${name};
-export { $${name} as ${name} };
-import.meta.exports.${name} = {
-  get: () => $${name},
-  set: (v) => $${name} = v,
-};`), '\n')
-}
-
-import.meta.done();
-`;
-
-  const m = new ModuleWrap(source, `${url}`);
-  m.link(() => 0);
-  m.instantiate();
-
-  const readyfns = new Set();
-  const reflect = {
-    namespace: m.namespace(),
-    exports: {},
-    onReady: (cb) => { readyfns.add(cb); },
-  };
-
-  callbackMap.set(m, {
-    initializeImportMeta: (meta, wrap) => {
-      meta.exports = reflect.exports;
-      meta.done = () => {
-        evaluate(reflect);
-        reflect.onReady = (cb) => cb(reflect);
-        for (const fn of readyfns) {
-          readyfns.delete(fn);
-          fn(reflect);
-        }
-      };
-    },
-  });
-
-  return {
-    module: m,
-    reflect,
-  };
-};
-
-module.exports = createDynamicModule;
diff --git a/lib/internal/modules/esm/default_resolve.js b/lib/internal/modules/esm/default_resolve.js
index 2cf9014a67..1e784e710a 100644
--- a/lib/internal/modules/esm/default_resolve.js
+++ b/lib/internal/modules/esm/default_resolve.js
@@ -1,7 +1,5 @@
 'use strict';
 
-const { URL } = require('url');
-const CJSmodule = require('internal/modules/cjs/loader');
 const internalFS = require('internal/fs/utils');
 const { NativeModule } = require('internal/bootstrap/loaders');
 const { extname } = require('path');
@@ -9,47 +7,24 @@ const { realpathSync } = require('fs');
 const { getOptionValue } = require('internal/options');
 const preserveSymlinks = getOptionValue('--preserve-symlinks');
 const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
-const {
-  ERR_MISSING_MODULE,
-  ERR_MODULE_RESOLUTION_LEGACY,
-  ERR_UNKNOWN_FILE_EXTENSION
-} = require('internal/errors').codes;
+const { ERR_UNSUPPORTED_FILE_EXTENSION } = require('internal/errors').codes;
 const { resolve: moduleWrapResolve } = internalBinding('module_wrap');
-const StringStartsWith = Function.call.bind(String.prototype.startsWith);
 const { pathToFileURL, fileURLToPath } = require('internal/url');
 
 const realpathCache = new Map();
 
-function search(target, base) {
-  if (base === undefined) {
-    // We cannot search without a base.
-    throw new ERR_MISSING_MODULE(target);
-  }
-  try {
-    return moduleWrapResolve(target, base);
-  } catch (e) {
-    e.stack; // cause V8 to generate stack before rethrow
-    let error = e;
-    try {
-      const questionedBase = new URL(base);
-      const tmpMod = new CJSmodule(questionedBase.pathname, null);
-      tmpMod.paths = CJSmodule._nodeModulePaths(
-        new URL('./', questionedBase).pathname);
-      const found = CJSmodule._resolveFilename(target, tmpMod);
-      error = new ERR_MODULE_RESOLUTION_LEGACY(target, base, found);
-    } catch {
-      // ignore
-    }
-    throw error;
-  }
-}
-
 const extensionFormatMap = {
   '__proto__': null,
   '.mjs': 'esm',
-  '.json': 'json',
-  '.node': 'addon',
-  '.js': 'cjs'
+  '.js': 'esm'
+};
+
+const legacyExtensionFormatMap = {
+  '__proto__': null,
+  '.js': 'cjs',
+  '.json': 'cjs',
+  '.mjs': 'esm',
+  '.node': 'cjs'
 };
 
 function resolve(specifier, parentURL) {
@@ -60,18 +35,14 @@ function resolve(specifier, parentURL) {
     };
   }
 
-  let url;
-  try {
-    url = search(specifier,
-                 parentURL || pathToFileURL(`${process.cwd()}/`).href);
-  } catch (e) {
-    if (typeof e.message === 'string' &&
-        StringStartsWith(e.message, 'Cannot find module'))
-      e.code = 'MODULE_NOT_FOUND';
-    throw e;
-  }
-
   const isMain = parentURL === undefined;
+  if (isMain)
+    parentURL = pathToFileURL(`${process.cwd()}/`).href;
+
+  const resolved = moduleWrapResolve(specifier, parentURL, isMain);
+
+  let url = resolved.url;
+  const legacy = resolved.legacy;
 
   if (isMain ? !preserveSymlinksMain : !preserveSymlinks) {
     const real = realpathSync(fileURLToPath(url), {
@@ -84,18 +55,17 @@ function resolve(specifier, parentURL) {
   }
 
   const ext = extname(url.pathname);
+  let format = (legacy ? legacyExtensionFormatMap : extensionFormatMap)[ext];
 
-  let format = extensionFormatMap[ext];
   if (!format) {
     if (isMain)
-      format = 'cjs';
+      format = legacy ? 'cjs' : 'esm';
     else
-      throw new ERR_UNKNOWN_FILE_EXTENSION(url.pathname);
+      throw new ERR_UNSUPPORTED_FILE_EXTENSION(fileURLToPath(url),
+                                               fileURLToPath(parentURL));
   }
 
   return { url: `${url}`, format };
 }
 
 module.exports = resolve;
-// exported for tests
-module.exports.search = search;
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index a1a1621909..63e4ec1d03 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -12,9 +12,7 @@ const { validateString } = require('internal/validators');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
 const defaultResolve = require('internal/modules/esm/default_resolve');
-const createDynamicModule = require(
-  'internal/modules/esm/create_dynamic_module');
-const translators = require('internal/modules/esm/translators');
+const { translators } = require('internal/modules/esm/translators');
 
 const FunctionBind = Function.call.bind(Function.prototype.bind);
 
@@ -32,6 +30,9 @@ class Loader {
     // Registry of loaded modules, akin to `require.cache`
     this.moduleMap = new ModuleMap();
 
+    // map of already-loaded CJS modules to use
+    this.cjsCache = new Map();
+
     // The resolver has the signature
     //   (specifier : string, parentURL : string, defaultResolve)
     //       -> Promise<{ url : string, format: string }>
@@ -122,10 +123,10 @@ class Loader {
 
       loaderInstance = async (url) => {
         debug(`Translating dynamic ${url}`);
-        const { exports, execute } = await this._dynamicInstantiate(url);
-        return createDynamicModule(exports, url, (reflect) => {
+        const execute = await this._dynamicInstantiate(url);
+        return new ModuleWrap(url, (setDynamicExport) => {
           debug(`Loading dynamic ${url}`);
-          execute(reflect.exports);
+          execute(setDynamicExport);
         });
       };
     } else {
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index fbb29aef78..8ca1f0e999 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const { ModuleWrap } = internalBinding('module_wrap');
+const { ModuleWrap, DynamicModuleWrap } = internalBinding('module_wrap');
 const { SafeSet, SafePromise } = require('internal/safe_globals');
 const { decorateErrorStack } = require('internal/util');
 const assert = require('assert');
@@ -15,23 +15,22 @@ class ModuleJob {
     this.loader = loader;
     this.isMain = isMain;
 
-    // This is a Promise<{ module, reflect }>, whose fields will be copied
+    // This is a Promise<module>, which will be copied
     // onto `this` by `link()` below once it has been resolved.
-    this.modulePromise = moduleProvider(url, isMain);
+    this.modulePromise = moduleProvider.call(loader, url, isMain);
     this.module = undefined;
     this.reflect = undefined;
 
     // Wait for the ModuleWrap instance being linked with all dependencies.
     const link = async () => {
-      ({ module: this.module,
-         reflect: this.reflect } = await this.modulePromise);
-      assert(this.module instanceof ModuleWrap);
+      this.module = await this.modulePromise;
+      assert(this.module instanceof ModuleWrap || this.module instanceof DynamicModuleWrap);
 
       const dependencyJobs = [];
       const promises = this.module.link(async (specifier) => {
         const jobPromise = this.loader.getModuleJob(specifier, url);
         dependencyJobs.push(jobPromise);
-        return (await (await jobPromise).modulePromise).module;
+        return (await jobPromise).modulePromise;
       });
 
       if (promises !== undefined)
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 776b8d584d..d1a61ade2b 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -1,31 +1,25 @@
 'use strict';
 
 const { NativeModule } = require('internal/bootstrap/loaders');
-const { ModuleWrap, callbackMap } = internalBinding('module_wrap');
+const { ModuleWrap, DynamicModuleWrap, callbackMap } = internalBinding('module_wrap');
 const {
-  stripShebang,
-  stripBOM
+  stripShebang
 } = require('internal/modules/cjs/helpers');
 const CJSModule = require('internal/modules/cjs/loader');
 const internalURLModule = require('internal/url');
-const createDynamicModule = require(
-  'internal/modules/esm/create_dynamic_module');
 const fs = require('fs');
-const { _makeLong } = require('path');
 const { SafeMap } = require('internal/safe_globals');
 const { URL } = require('url');
 const { debuglog, promisify } = require('util');
 const esmLoader = require('internal/process/esm_loader');
 
 const readFileAsync = promisify(fs.readFile);
-const readFileSync = fs.readFileSync;
 const StringReplace = Function.call.bind(String.prototype.replace);
-const JsonParse = JSON.parse;
 
 const debug = debuglog('esm');
 
 const translators = new SafeMap();
-module.exports = translators;
+exports.translators = translators;
 
 function initializeImportMeta(meta, { url }) {
   meta.url = url;
@@ -37,7 +31,7 @@ async function importModuleDynamically(specifier, { url }) {
 }
 
 // Strategy for loading a standard JavaScript module
-translators.set('esm', async (url) => {
+translators.set('esm', async function(url) {
   const source = `${await readFileAsync(new URL(url))}`;
   debug(`Translating StandardModule ${url}`);
   const module = new ModuleWrap(stripShebang(source), url);
@@ -45,78 +39,69 @@ translators.set('esm', async (url) => {
     initializeImportMeta,
     importModuleDynamically,
   });
-  return {
-    module,
-    reflect: undefined,
-  };
+  return module;
 });
 
 // Strategy for loading a node-style CommonJS module
 const isWindows = process.platform === 'win32';
 const winSepRegEx = /\//g;
-translators.set('cjs', async (url, isMain) => {
+translators.set('cjs', async function(url, isMain) {
   debug(`Translating CJSModule ${url}`);
   const pathname = internalURLModule.fileURLToPath(new URL(url));
-  const module = CJSModule._cache[
-    isWindows ? StringReplace(pathname, winSepRegEx, '\\') : pathname];
-  if (module && module.loaded) {
-    const exports = module.exports;
-    return createDynamicModule(['default'], url, (reflect) => {
-      reflect.exports.default.set(exports);
+  let module = this.cjsCache.get(url);
+  if (!module) {
+    const cjsModule = CJSModule._cache[
+      isWindows ? StringReplace(pathname, winSepRegEx, '\\') : pathname];
+    if (cjsModule && cjsModule.loaded)
+      module = cjsModule.exports;
+  }
+  if (module) {
+    this.cjsCache.delete(url);
+    return new DynamicModuleWrap(url, (module) => {
+      for (const exportName of Object.keys(cached)) {
+        if (exportName === 'default') continue;
+        let exportValue;
+        try {
+          exportValue = cached[exportName];
+        }
+        catch {
+          continue;
+        }
+        module.setExport(exportName, exportValue);
+      }
+      module.setExport('default', cached);
     });
   }
-  return createDynamicModule(['default'], url, () => {
+  return new DynamicModuleWrap(url, (module) => {
     debug(`Loading CJSModule ${url}`);
-    // We don't care about the return val of _load here because Module#load
-    // will handle it for us by checking the loader registry and filling the
-    // exports like above
-    CJSModule._load(pathname, undefined, isMain);
+    const exports = CJSModule._load(pathname, undefined, isMain);
+    for (const exportName of Object.keys(exports)) {
+      if (exportName === 'default') continue;
+      let exportValue;
+      try {
+        exportValue = exports[exportName];
+      }
+      catch {
+        continue;
+      }
+      module.setExport(exportName, exportValue);
+    }
+    module.setExport('default', exports);
   });
 });
 
 // Strategy for loading a node builtin CommonJS module that isn't
 // through normal resolution
-translators.set('builtin', async (url) => {
+translators.set('builtin', async function(url) {
   debug(`Translating BuiltinModule ${url}`);
   // slice 'node:' scheme
   const id = url.slice(5);
   NativeModule.require(id);
   const module = NativeModule.map.get(id);
-  return createDynamicModule(
-    [...module.exportKeys, 'default'], url, (reflect) => {
-      debug(`Loading BuiltinModule ${url}`);
-      module.reflect = reflect;
-      for (const key of module.exportKeys)
-        reflect.exports[key].set(module.exports[key]);
-      reflect.exports.default.set(module.exports);
-    });
-});
-
-// Strategy for loading a node native module
-translators.set('addon', async (url) => {
-  debug(`Translating NativeModule ${url}`);
-  return createDynamicModule(['default'], url, (reflect) => {
-    debug(`Loading NativeModule ${url}`);
-    const module = { exports: {} };
-    const pathname = internalURLModule.fileURLToPath(new URL(url));
-    process.dlopen(module, _makeLong(pathname));
-    reflect.exports.default.set(module.exports);
-  });
-});
-
-// Strategy for loading a JSON file
-translators.set('json', async (url) => {
-  debug(`Translating JSONModule ${url}`);
-  return createDynamicModule(['default'], url, (reflect) => {
-    debug(`Loading JSONModule ${url}`);
-    const pathname = internalURLModule.fileURLToPath(new URL(url));
-    const content = readFileSync(pathname, 'utf8');
-    try {
-      const exports = JsonParse(stripBOM(content));
-      reflect.exports.default.set(exports);
-    } catch (err) {
-      err.message = pathname + ': ' + err.message;
-      throw err;
-    }
+  return new DynamicModuleWrap(url, (module) => {
+    debug(`Loading BuiltinModule ${url}`);
+    for (const key of module.exportKeys)
+      module.setExport(key, module.exports[key]);
+    module.setExport('default', module.exports);
   });
 });
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index f81053a1c3..20e6bceba9 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -6,7 +6,6 @@ const {
   callbackMap,
 } = internalBinding('module_wrap');
 
-const { pathToFileURL } = require('internal/url');
 const Loader = require('internal/modules/esm/loader');
 const {
   wrapToModuleMap,
@@ -39,23 +38,13 @@ setInitializeImportMetaObjectCallback(initializeImportMetaObject);
 setImportModuleDynamicallyCallback(importModuleDynamicallyCallback);
 
 let loaderResolve;
-exports.loaderPromise = new Promise((resolve, reject) => {
-  loaderResolve = resolve;
-});
+exports.loaderPromise = new Promise((resolve) => loaderResolve = resolve);
 
 exports.ESMLoader = undefined;
 
 exports.setup = function() {
-  let ESMLoader = new Loader();
+  const ESMLoader = new Loader();
   const loaderPromise = (async () => {
-    const userLoader = require('internal/options').getOptionValue('--loader');
-    if (userLoader) {
-      const hooks = await ESMLoader.import(
-        userLoader, pathToFileURL(`${process.cwd()}/`).href);
-      ESMLoader = new Loader();
-      ESMLoader.hook(hooks);
-      exports.ESMLoader = ESMLoader;
-    }
     return ESMLoader;
   })();
   loaderResolve(loaderPromise);
diff --git a/lib/vm.js b/lib/vm.js
index 464724071a..8b1df9df1d 100644
--- a/lib/vm.js
+++ b/lib/vm.js
@@ -402,8 +402,3 @@ module.exports = {
   isContext,
   compileFunction,
 };
-
-if (require('internal/options').getOptionValue('--experimental-vm-modules')) {
-  const { SourceTextModule } = require('internal/vm/source_text_module');
-  module.exports.SourceTextModule = SourceTextModule;
-}
diff --git a/node.gyp b/node.gyp
index 91a6304049..27ad6e1cdc 100644
--- a/node.gyp
+++ b/node.gyp
@@ -133,7 +133,6 @@
       'lib/internal/modules/cjs/helpers.js',
       'lib/internal/modules/cjs/loader.js',
       'lib/internal/modules/esm/loader.js',
-      'lib/internal/modules/esm/create_dynamic_module.js',
       'lib/internal/modules/esm/default_resolve.js',
       'lib/internal/modules/esm/module_job.js',
       'lib/internal/modules/esm/module_map.js',
diff --git a/src/env.h b/src/env.h
index 711d07963a..a6e3426411 100644
--- a/src/env.h
+++ b/src/env.h
@@ -73,14 +73,23 @@ namespace loader {
 class ModuleWrap;
 
 struct PackageConfig {
-  enum class Exists { Yes, No };
-  enum class IsValid { Yes, No };
-  enum class HasMain { Yes, No };
-
-  Exists exists;
-  IsValid is_valid;
-  HasMain has_main;
-  std::string main;
+  struct Exists {
+    enum Bool { No, Yes };
+  };
+  struct IsValid {
+    enum Bool { No, Yes };
+  };
+  struct HasMain {
+    enum Bool { No, Yes };
+  };
+  struct IsESM {
+    enum Bool { No, Yes };
+  };
+  const Exists::Bool exists;
+  const IsValid::Bool is_valid;
+  const HasMain::Bool has_main;
+  const std::string main;
+  const IsESM::Bool esm;
 };
 }  // namespace loader
 
@@ -168,6 +177,7 @@ constexpr size_t kFsStatsBufferLength = kFsStatsFieldsNumber * 2;
   V(env_var_settings_string, "envVarSettings")                                 \
   V(errno_string, "errno")                                                     \
   V(error_string, "error")                                                     \
+  V(esm_string, "esm")                                                         \
   V(exchange_string, "exchange")                                               \
   V(exit_code_string, "exitCode")                                              \
   V(expire_string, "expire")                                                   \
@@ -206,6 +216,7 @@ constexpr size_t kFsStatsBufferLength = kFsStatsFieldsNumber * 2;
   V(kill_signal_string, "killSignal")                                          \
   V(kind_string, "kind")                                                       \
   V(library_string, "library")                                                 \
+  V(legacy_string, "legacy")                                                   \
   V(mac_string, "mac")                                                         \
   V(main_string, "main")                                                       \
   V(max_buffer_string, "maxBuffer")                                            \
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index 8599029fea..45a2381cc3 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -20,6 +20,7 @@ using node::url::URL;
 using node::url::URL_FLAGS_FAILED;
 using v8::Array;
 using v8::Context;
+using v8::DynamicModule;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -27,7 +28,6 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::IntegrityLevel;
 using v8::Isolate;
-using v8::JSON;
 using v8::Just;
 using v8::Local;
 using v8::Maybe;
@@ -44,8 +44,6 @@ using v8::String;
 using v8::Undefined;
 using v8::Value;
 
-static const char* const EXTENSIONS[] = {".mjs", ".js", ".json", ".node"};
-
 ModuleWrap::ModuleWrap(Environment* env,
                        Local<Object> object,
                        Local<Module> module,
@@ -104,11 +102,9 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
 
   CHECK(args[1]->IsString());
   Local<String> url = args[1].As<String>();
-
   Local<Context> context;
   Local<Integer> line_offset;
   Local<Integer> column_offset;
-
   if (argc == 5) {
     // new ModuleWrap(source, url, context?, lineOffset, columnOffset)
     if (args[2]->IsUndefined()) {
@@ -233,7 +229,6 @@ void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
 
     promises->Set(mod_context, i, resolve_promise).FromJust();
   }
-
   args.GetReturnValue().Set(promises);
 }
 
@@ -421,6 +416,96 @@ MaybeLocal<Module> ModuleWrap::ResolveCallback(Local<Context> context,
   return module->module_.Get(isolate);
 }
 
+DynamicModuleWrap::DynamicModuleWrap(Environment* env,
+                       Local<Object> object,
+                       Local<Module> module,
+                       Local<String> url,
+                       Local<Function> dynamic_exec_callback) :
+  ModuleWrap(env, object, module, url) {
+  dynamic_exec_callback_.Reset(env->isolate(), dynamic_exec_callback);
+  linked_ = true;
+}
+
+DynamicModuleWrap::~DynamicModuleWrap() {
+  dynamic_exec_callback_.Reset();
+}
+
+void DynamicModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+
+  CHECK(args.IsConstructCall());
+  Local<Object> that = args.This();
+
+  const int argc = args.Length();
+  CHECK_EQ(argc, 2);
+
+  // Dynamic Module
+  // new ModuleWrap(url, (module) => {...})
+  CHECK(args[0]->IsString());
+  Local<String> url = args[0].As<String>();
+
+  CHECK(args[1]->IsFunction());
+  Local<Function> dynamic_exec_callback = args[1].As<Function>();
+
+  if (!that->Set(env->context(), env->url_string(), url).FromMaybe(false)) {
+    return;
+  }
+
+  Local<DynamicModule> module = ScriptCompiler::CreateDynamicModule(isolate).ToLocalChecked();
+
+  DynamicModuleWrap* obj = new DynamicModuleWrap(
+      env, that, module, url, dynamic_exec_callback);
+  obj->context_.Reset(isolate, env->context());
+
+  env->hash_to_module_map.emplace(module->GetIdentityHash(), obj);
+
+  args.GetReturnValue().Set(that);
+}
+
+void DynamicModuleWrap::SetExport(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+
+  DynamicModuleWrap* obj;
+  ASSIGN_OR_RETURN_UNWRAP(&obj, args.This());
+
+  CHECK_EQ(args.Length(), 2);
+  CHECK(args[0]->IsString());
+  Local<String> name = args[0].As<String>();
+
+  Local<Value> value = args[1];
+
+  Local<Module> m = obj->module_.Get(isolate);
+  Local<DynamicModule> m_dyn = m.As<DynamicModule>();
+  m_dyn->SetExport(isolate, name, value);
+}
+
+void DynamicModuleWrap::HostExecuteDynamicModuleCallback(
+    Local<Context> context, Local<DynamicModule> module) {
+  Environment* env = Environment::GetCurrent(context);
+  Isolate* isolate = env->isolate();
+
+  DynamicModuleWrap* m = static_cast<DynamicModuleWrap*>(
+      env->hash_to_module_map.find(module->GetIdentityHash())->second);
+
+  Local<Object> object = m->object();
+  Local<Value> args[] = { object };
+  Local<Function> dynamic_exec_callback =
+      m->dynamic_exec_callback_.Get(isolate);
+  
+  TryCatchScope try_catch(env);
+  bool failed = 
+    dynamic_exec_callback->Call(context, Undefined(env->isolate()), 1, args)
+    .IsEmpty();
+  if (failed) {
+    CHECK(try_catch.HasCaught());
+    try_catch.ReThrow();
+    return;
+  }
+  CHECK(!try_catch.HasCaught());
+}
+
 namespace {
 
 // Tests whether a path starts with /, ./ or ../
@@ -467,226 +552,375 @@ std::string ReadFile(uv_file file) {
   return contents;
 }
 
-enum CheckFileOptions {
-  LEAVE_OPEN_AFTER_CHECK,
-  CLOSE_AFTER_CHECK
+enum DescriptorType {
+  FILE,
+  DIRECTORY,
+  NONE
 };
 
-Maybe<uv_file> CheckFile(const std::string& path,
-                         CheckFileOptions opt = CLOSE_AFTER_CHECK) {
+// When DescriptorType cache is added, this can also return
+// Nothing for the "null" cache entries.
+inline Maybe<uv_file> OpenDescriptor(const std::string& path) {
   uv_fs_t fs_req;
-  if (path.empty()) {
-    return Nothing<uv_file>();
-  }
-
   uv_file fd = uv_fs_open(nullptr, &fs_req, path.c_str(), O_RDONLY, 0, nullptr);
   uv_fs_req_cleanup(&fs_req);
+  if (fd < 0) return Nothing<uv_file>();
+  return Just(fd);
+}
 
-  if (fd < 0) {
-    return Nothing<uv_file>();
-  }
-
-  uv_fs_fstat(nullptr, &fs_req, fd, nullptr);
-  uint64_t is_directory = fs_req.statbuf.st_mode & S_IFDIR;
+inline void CloseDescriptor(uv_file fd) {
+  uv_fs_t fs_req;
+  uv_fs_close(nullptr, &fs_req, fd, nullptr);
   uv_fs_req_cleanup(&fs_req);
+}
 
-  if (is_directory) {
-    CHECK_EQ(0, uv_fs_close(nullptr, &fs_req, fd, nullptr));
+inline DescriptorType CheckDescriptorAtFile(uv_file fd) {
+  uv_fs_t fs_req;
+  int rc = uv_fs_fstat(nullptr, &fs_req, fd, nullptr);
+  if (rc == 0) {
+    uint64_t is_directory = fs_req.statbuf.st_mode & S_IFDIR;
     uv_fs_req_cleanup(&fs_req);
-    return Nothing<uv_file>();
+    return is_directory ? DIRECTORY : FILE;
   }
+  uv_fs_req_cleanup(&fs_req);
+  return NONE;
+}
 
-  if (opt == CLOSE_AFTER_CHECK) {
-    CHECK_EQ(0, uv_fs_close(nullptr, &fs_req, fd, nullptr));
-    uv_fs_req_cleanup(&fs_req);
-  }
+// TODO(@guybedford): Add a DescriptorType cache layer here.
+// Should be directory based -> if path/to/dir doesn't exist
+// then the cache should early-fail any path/to/dir/file check.
+DescriptorType CheckDescriptorAtPath(const std::string& path) {
+  Maybe<uv_file> fd = OpenDescriptor(path);
+  if (fd.IsNothing()) return NONE;
+  DescriptorType type = CheckDescriptorAtFile(fd.FromJust());
+  CloseDescriptor(fd.FromJust());
+  return type;
+}
 
-  return Just(fd);
+Maybe<std::string> ReadIfFile(const std::string& path) {
+  Maybe<uv_file> fd = OpenDescriptor(path);
+  if (fd.IsNothing()) return Nothing<std::string>();
+  DescriptorType type = CheckDescriptorAtFile(fd.FromJust());
+  if (type != FILE) return Nothing<std::string>();
+  std::string source = ReadFile(fd.FromJust());
+  CloseDescriptor(fd.FromJust());
+  return Just(source);
 }
 
 using Exists = PackageConfig::Exists;
 using IsValid = PackageConfig::IsValid;
 using HasMain = PackageConfig::HasMain;
+using IsESM = PackageConfig::IsESM;
 
-const PackageConfig& GetPackageConfig(Environment* env,
-                                      const std::string& path) {
+Maybe<const PackageConfig*> GetPackageConfig(Environment* env,
+                                             const std::string& path,
+                                             const URL& base) {
   auto existing = env->package_json_cache.find(path);
   if (existing != env->package_json_cache.end()) {
-    return existing->second;
+    return Just(&existing->second);
   }
-  Maybe<uv_file> check = CheckFile(path, LEAVE_OPEN_AFTER_CHECK);
-  if (check.IsNothing()) {
+
+  Maybe<std::string> source = ReadIfFile(path);
+
+  if (source.IsNothing()) {
     auto entry = env->package_json_cache.emplace(path,
-        PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "" });
-    return entry.first->second;
+        PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "",
+                        IsESM::No });
+    return Just(&entry.first->second);
   }
 
+  std::string pkg_src = source.FromJust();
+
   Isolate* isolate = env->isolate();
   v8::HandleScope handle_scope(isolate);
 
-  std::string pkg_src = ReadFile(check.FromJust());
-  uv_fs_t fs_req;
-  CHECK_EQ(0, uv_fs_close(nullptr, &fs_req, check.FromJust(), nullptr));
-  uv_fs_req_cleanup(&fs_req);
-
-  Local<String> src;
-  if (!String::NewFromUtf8(isolate,
-                           pkg_src.c_str(),
-                           v8::NewStringType::kNormal,
-                           pkg_src.length()).ToLocal(&src)) {
-    auto entry = env->package_json_cache.emplace(path,
-        PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "" });
-    return entry.first->second;
-  }
-
-  Local<Value> pkg_json_v;
+  bool parsed = false;
   Local<Object> pkg_json;
+  {
+    Local<String> src;
+    Local<Value> pkg_json_v;
+    if (String::NewFromUtf8(isolate,
+                            pkg_src.c_str(),
+                            v8::NewStringType::kNormal,
+                            pkg_src.length()).ToLocal(&src) &&
+        v8::JSON::Parse(env->context(), src).ToLocal(&pkg_json_v) &&
+        pkg_json_v->ToObject(env->context()).ToLocal(&pkg_json)) {
+      parsed = true;
+    }
+  }
 
-  if (!JSON::Parse(env->context(), src).ToLocal(&pkg_json_v) ||
-      !pkg_json_v->ToObject(env->context()).ToLocal(&pkg_json)) {
-    auto entry = env->package_json_cache.emplace(path,
-        PackageConfig { Exists::Yes, IsValid::No, HasMain::No, "" });
-    return entry.first->second;
+  if (!parsed) {
+    (void)env->package_json_cache.emplace(path,
+        PackageConfig { Exists::Yes, IsValid::No, HasMain::No, "",
+                        IsESM::No });
+    std::string msg = "Invalid JSON in '" + path +
+        "' imported from " + base.ToFilePath();
+    node::THROW_ERR_INVALID_PACKAGE_CONFIG(env, msg.c_str());
+    return Nothing<const PackageConfig*>();
   }
 
   Local<Value> pkg_main;
-  HasMain has_main = HasMain::No;
+  HasMain::Bool has_main = HasMain::No;
   std::string main_std;
   if (pkg_json->Get(env->context(), env->main_string()).ToLocal(&pkg_main)) {
-    has_main = HasMain::Yes;
+    if (pkg_main->IsString()) {
+      has_main = HasMain::Yes;
+    }
     Utf8Value main_utf8(isolate, pkg_main);
     main_std.assign(std::string(*main_utf8, main_utf8.length()));
   }
 
+  IsESM::Bool esm = IsESM::No;
+  Local<Value> type_v;
+  if (pkg_json->Get(env->context(), env->type_string()).ToLocal(&type_v)) {
+    if (type_v->StrictEquals(env->esm_string())) {
+      esm = IsESM::Yes;
+    }
+  }
+
+  Local<Value> exports_v;
+  if (pkg_json->Get(env->context(),
+      env->exports_string()).ToLocal(&exports_v) &&
+      (exports_v->IsObject() || exports_v->IsString() ||
+      exports_v->IsBoolean())) {
+    Persistent<Value> exports;
+    // esm = IsESM::Yes;
+    exports.Reset(env->isolate(), exports_v);
+
+    auto entry = env->package_json_cache.emplace(path,
+        PackageConfig { Exists::Yes, IsValid::Yes, has_main, main_std,
+                        esm });
+    return Just(&entry.first->second);
+  }
+
   auto entry = env->package_json_cache.emplace(path,
-      PackageConfig { Exists::Yes, IsValid::Yes, has_main, main_std });
-  return entry.first->second;
+      PackageConfig { Exists::Yes, IsValid::Yes, has_main, main_std,
+                      esm });
+  return Just(&entry.first->second);
 }
 
-enum ResolveExtensionsOptions {
-  TRY_EXACT_NAME,
-  ONLY_VIA_EXTENSIONS
-};
-
-template <ResolveExtensionsOptions options>
-Maybe<URL> ResolveExtensions(const URL& search) {
-  if (options == TRY_EXACT_NAME) {
-    std::string filePath = search.ToFilePath();
-    Maybe<uv_file> check = CheckFile(filePath);
-    if (!check.IsNothing()) {
-      return Just(search);
+Maybe<const PackageConfig*> GetPackageBoundaryConfig(Environment* env,
+                                                     const URL& search,
+                                                     const URL& base) {
+  URL pjson_url("package.json", &search);
+  while (true) {
+    Maybe<const PackageConfig*> pkg_cfg =
+        GetPackageConfig(env, pjson_url.ToFilePath(), base);
+    if (pkg_cfg.IsNothing()) return pkg_cfg;
+    if (pkg_cfg.FromJust()->exists == Exists::Yes) return pkg_cfg;
+
+    URL last_pjson_url = pjson_url;
+    pjson_url = URL("../package.json", pjson_url);
+
+    // Terminates at root where ../package.json equals ../../package.json
+    // (can't just check "/package.json" for Windows support).
+    if (pjson_url.path() == last_pjson_url.path()) {
+      auto entry = env->package_json_cache.emplace(pjson_url.ToFilePath(),
+          PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "",
+                          IsESM::No });
+      return Just(&entry.first->second);
     }
   }
+}
 
-  for (const char* extension : EXTENSIONS) {
-    URL guess(search.path() + extension, &search);
-    Maybe<uv_file> check = CheckFile(guess.ToFilePath());
-    if (!check.IsNothing()) {
+/*
+ * Legacy CommonJS main resolution:
+ * 1. let M = pkg_url + (json main field)
+ * 2. TRY(M, M.js, M.json, M.node)
+ * 3. TRY(M/index.js, M/index.json, M/index.node)
+ * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
+ * 5. NOT_FOUND
+ */
+inline bool FileExists(const URL& url) {
+  return CheckDescriptorAtPath(url.ToFilePath()) == FILE;
+}
+Maybe<URL> LegacyMainResolve(const URL& pjson_url,
+                             const PackageConfig& pcfg) {
+  URL guess;
+  if (pcfg.has_main == HasMain::Yes) {
+    // Note: fs check redundances will be handled by Descriptor cache here.
+    if (FileExists(guess = URL("./" + pcfg.main, pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + ".js", pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + ".json", pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + ".node", pjson_url))) {
       return Just(guess);
     }
+    if (FileExists(guess = URL("./" + pcfg.main + "/index.js", pjson_url))) {
+      return Just(guess);
+    }
+    // Such stat.
+    if (FileExists(guess = URL("./" + pcfg.main + "/index.json", pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + "/index.node", pjson_url))) {
+      return Just(guess);
+    }
+    // Fallthrough.
   }
-
+  if (FileExists(guess = URL("./index.js", pjson_url))) {
+    return Just(guess);
+  }
+  // So fs.
+  if (FileExists(guess = URL("./index.json", pjson_url))) {
+    return Just(guess);
+  }
+  if (FileExists(guess = URL("./index.node", pjson_url))) {
+    return Just(guess);
+  }
+  // Not found.
   return Nothing<URL>();
 }
 
-inline Maybe<URL> ResolveIndex(const URL& search) {
-  return ResolveExtensions<ONLY_VIA_EXTENSIONS>(URL("index", search));
-}
+Maybe<ModuleResolution> FinalizeResolution(Environment* env,
+                                           const URL& resolved,
+                                           const URL& base,
+                                           bool check_exists,
+                                           bool is_main) {
+  const std::string& path = resolved.ToFilePath();
+
+  if (check_exists && CheckDescriptorAtPath(path) != FILE) {
+    std::string msg = "Cannot find module '" + path +
+        "' imported from " + base.ToFilePath();
+    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
+    return Nothing<ModuleResolution>();
+  }
 
-Maybe<URL> ResolveMain(Environment* env, const URL& search) {
-  URL pkg("package.json", &search);
+  Maybe<const PackageConfig*> pcfg =
+      GetPackageBoundaryConfig(env, resolved, base);
+  if (pcfg.IsNothing()) return Nothing<ModuleResolution>();
+
+  if (pcfg.FromJust()->exists == Exists::No) {
+    return Just(ModuleResolution { resolved, true });
+  }
 
-  const PackageConfig& pjson =
-      GetPackageConfig(env, pkg.ToFilePath());
-  // Note invalid package.json should throw in resolver
-  // currently we silently ignore which is incorrect
-  if (pjson.exists == Exists::No ||
-      pjson.is_valid == IsValid::No ||
-      pjson.has_main == HasMain::No) {
-    return Nothing<URL>();
+  return Just(ModuleResolution {
+      resolved, pcfg.FromJust()->esm == IsESM::No });
+}
+
+Maybe<ModuleResolution> PackageMainResolve(Environment* env,
+                                           const URL& pjson_url,
+                                           const PackageConfig& pcfg,
+                                           const URL& base) {
+  if (pcfg.exists == Exists::No || (
+      pcfg.esm == IsESM::Yes && pcfg.has_main == HasMain::No)) {
+    std::string msg = "Cannot find main entry point for '" +
+        URL(".", pjson_url).ToFilePath() + "' imported from " +
+        base.ToFilePath();
+    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
+    return Nothing<ModuleResolution>();
+  }
+  if (pcfg.has_main == HasMain::Yes &&
+      pcfg.main.substr(pcfg.main.length() - 4, 4) == ".mjs") {
+    return FinalizeResolution(env, URL(pcfg.main, pjson_url), base, true,
+                              true);
+  }
+  if (pcfg.esm == IsESM::Yes &&
+      pcfg.main.substr(pcfg.main.length() - 3, 3) == ".js") {
+    return FinalizeResolution(env, URL(pcfg.main, pjson_url), base, true,
+                              true);
   }
-  if (!ShouldBeTreatedAsRelativeOrAbsolutePath(pjson.main)) {
-    return Resolve(env, "./" + pjson.main, search, IgnoreMain);
+
+  Maybe<URL> resolved = LegacyMainResolve(pjson_url, pcfg);
+  // Legacy main resolution error
+  if (resolved.IsNothing()) {
+    return Nothing<ModuleResolution>();
   }
-  return Resolve(env, pjson.main, search, IgnoreMain);
+  return FinalizeResolution(env, resolved.FromJust(), base, false, true);
 }
 
-Maybe<URL> ResolveModule(Environment* env,
-                         const std::string& specifier,
-                         const URL& base) {
-  URL parent(".", base);
-  URL dir("");
+Maybe<ModuleResolution> PackageResolve(Environment* env,
+                          const std::string& specifier,
+                          const URL& base) {
+  size_t sep_index = specifier.find('/');
+  if (specifier[0] == '@' && (sep_index == std::string::npos ||
+      specifier.length() == 0)) {
+    std::string msg = "Invalid package name '" + specifier +
+      "' imported from " + base.ToFilePath();
+    node::THROW_ERR_INVALID_MODULE_SPECIFIER(env, msg.c_str());
+    return Nothing<ModuleResolution>();
+  }
+  bool scope = false;
+  if (specifier[0] == '@') {
+    scope = true;
+    sep_index = specifier.find('/', sep_index + 1);
+  }
+  std::string pkg_name = specifier.substr(0,
+      sep_index == std::string::npos ? std::string::npos : sep_index);
+  std::string pkg_subpath;
+  if ((sep_index == std::string::npos ||
+      sep_index == specifier.length() - 1)) {
+    pkg_subpath = "";
+  } else {
+    pkg_subpath = "." + specifier.substr(sep_index);
+  }
+  URL pjson_url("./node_modules/" + pkg_name + "/package.json", &base);
+  std::string pjson_path = pjson_url.ToFilePath();
+  std::string last_path;
   do {
-    dir = parent;
-    Maybe<URL> check =
-        Resolve(env, "./node_modules/" + specifier, dir, CheckMain);
-    if (!check.IsNothing()) {
-      const size_t limit = specifier.find('/');
-      const size_t spec_len =
-          limit == std::string::npos ? specifier.length() :
-                                       limit + 1;
-      std::string chroot =
-          dir.path() + "node_modules/" + specifier.substr(0, spec_len);
-      if (check.FromJust().path().substr(0, chroot.length()) != chroot) {
-        return Nothing<URL>();
-      }
-      return check;
-    } else {
-      // TODO(bmeck) PREVENT FALLTHROUGH
+    DescriptorType check =
+        CheckDescriptorAtPath(pjson_path.substr(0, pjson_path.length() - 13));
+    if (check != DIRECTORY) {
+      last_path = pjson_path;
+      pjson_url = URL((scope ?
+          "../../../../node_modules/" : "../../../node_modules/") +
+          pkg_name + "/package.json", &pjson_url);
+      pjson_path = pjson_url.ToFilePath();
+      continue;
     }
-    parent = URL("..", &dir);
-  } while (parent.path() != dir.path());
-  return Nothing<URL>();
-}
 
-Maybe<URL> ResolveDirectory(Environment* env,
-                            const URL& search,
-                            PackageMainCheck check_pjson_main) {
-  if (check_pjson_main) {
-    Maybe<URL> main = ResolveMain(env, search);
-    if (!main.IsNothing())
-      return main;
-  }
-  return ResolveIndex(search);
+    // Package match.
+    Maybe<const PackageConfig*> pcfg = GetPackageConfig(env, pjson_path, base);
+    // Invalid package configuration error.
+    if (pcfg.IsNothing()) return Nothing<ModuleResolution>();
+    if (!pkg_subpath.length()) {
+      return PackageMainResolve(env, pjson_url, *pcfg.FromJust(), base);
+    } else {
+      return FinalizeResolution(env, URL(pkg_subpath, pjson_url),
+                                base, true, false);
+    }
+    CHECK(false);
+    // Cross-platform root check.
+  } while (pjson_url.path().length() != last_path.length());
+
+  std::string msg = "Cannot find package '" + pkg_name +
+      "' imported from " + base.ToFilePath();
+  node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
+  return Nothing<ModuleResolution>();
 }
 
 }  // anonymous namespace
 
-Maybe<URL> Resolve(Environment* env,
-                   const std::string& specifier,
-                   const URL& base,
-                   PackageMainCheck check_pjson_main) {
-  URL pure_url(specifier);
-  if (!(pure_url.flags() & URL_FLAGS_FAILED)) {
-    // just check existence, without altering
-    Maybe<uv_file> check = CheckFile(pure_url.ToFilePath());
-    if (check.IsNothing()) {
-      return Nothing<URL>();
-    }
-    return Just(pure_url);
-  }
-  if (specifier.length() == 0) {
-    return Nothing<URL>();
-  }
+Maybe<ModuleResolution> Resolve(Environment* env,
+                                const std::string& specifier,
+                                const URL& base,
+                                bool is_main) {
+  // Order swapped from spec for minor perf gain.
+  // Ok since relative URLs cannot parse as URLs.
+  URL resolved;
   if (ShouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-    URL resolved(specifier, base);
-    Maybe<URL> file = ResolveExtensions<TRY_EXACT_NAME>(resolved);
-    if (!file.IsNothing())
-      return file;
-    if (specifier.back() != '/') {
-      resolved = URL(specifier + "/", base);
-    }
-    return ResolveDirectory(env, resolved, check_pjson_main);
+    resolved = URL(specifier, base);
   } else {
-    return ResolveModule(env, specifier, base);
+    URL pure_url(specifier);
+    if (!(pure_url.flags() & URL_FLAGS_FAILED)) {
+      resolved = pure_url;
+    } else {
+      return PackageResolve(env, specifier, base);
+    }
   }
+  return FinalizeResolution(env, resolved, base, true, is_main);
 }
 
 void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
-  // module.resolve(specifier, url)
-  CHECK_EQ(args.Length(), 2);
+  // module.resolve(specifier, url, is_main)
+  CHECK_EQ(args.Length(), 3);
 
   CHECK(args[0]->IsString());
   Utf8Value specifier_utf8(env->isolate(), args[0]);
@@ -696,20 +930,41 @@ void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
   Utf8Value url_utf8(env->isolate(), args[1]);
   URL url(*url_utf8, url_utf8.length());
 
+  CHECK(args[2]->IsBoolean());
+
   if (url.flags() & URL_FLAGS_FAILED) {
     return node::THROW_ERR_INVALID_ARG_TYPE(
         env, "second argument is not a URL string");
   }
 
-  Maybe<URL> result = node::loader::Resolve(env, specifier_std, url);
-  if (result.IsNothing() || (result.FromJust().flags() & URL_FLAGS_FAILED)) {
-    std::string msg = "Cannot find module " + specifier_std;
-    return node::THROW_ERR_MISSING_MODULE(env, msg.c_str());
+  TryCatchScope try_catch(env);
+  Maybe<ModuleResolution> result =
+      node::loader::Resolve(env, specifier_std, url, args[2]->IsTrue());
+  if (result.IsNothing()) {
+    CHECK(try_catch.HasCaught());
+    try_catch.ReThrow();
+    return;
   }
+  CHECK(!try_catch.HasCaught());
+
+  ModuleResolution resolution = result.FromJust();
+  CHECK(!(resolution.url.flags() & URL_FLAGS_FAILED));
+
+  Local<Object> resolved = Object::New(env->isolate());
+
+  resolved->DefineOwnProperty(
+      env->context(),
+      env->url_string(),
+      resolution.url.ToObject(env).ToLocalChecked(),
+      v8::ReadOnly).FromJust();
+
+  resolved->DefineOwnProperty(
+      env->context(),
+      env->legacy_string(),
+      v8::Boolean::New(env->isolate(), resolution.legacy),
+      v8::ReadOnly).FromJust();
 
-  MaybeLocal<Value> obj = result.FromJust().ToObject(env);
-  if (!obj.IsEmpty())
-    args.GetReturnValue().Set(obj.ToLocalChecked());
+    args.GetReturnValue().Set(resolved);
 }
 
 static MaybeLocal<Promise> ImportModuleDynamically(
@@ -849,6 +1104,29 @@ void ModuleWrap::Initialize(Local<Object> target,
   env->SetMethod(target,
                  "setInitializeImportMetaObjectCallback",
                  SetInitializeImportMetaObjectCallback);
+  
+  Local<FunctionTemplate> dynTpl =
+      env->NewFunctionTemplate(DynamicModuleWrap::New);
+  dynTpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "DynamicModuleWrap"));
+  dynTpl->InstanceTemplate()->SetInternalFieldCount(1);
+  env->SetProtoMethod(dynTpl, "link", Link);
+  env->SetProtoMethod(dynTpl, "instantiate", Instantiate);
+  env->SetProtoMethod(dynTpl, "evaluate", Evaluate);
+  env->SetProtoMethod(dynTpl, "setExport", DynamicModuleWrap::SetExport);
+  env->SetProtoMethodNoSideEffect(dynTpl, "namespace",
+      Namespace);
+  env->SetProtoMethodNoSideEffect(dynTpl, "getStatus",
+      GetStatus);
+  env->SetProtoMethodNoSideEffect(dynTpl, "getError",
+      GetError);
+  env->SetProtoMethodNoSideEffect(dynTpl, "getStaticDependencySpecifiers",
+      GetStaticDependencySpecifiers);
+  target->Set(env->context(),
+      FIXED_ONE_BYTE_STRING(isolate, "DynamicModuleWrap"),
+      dynTpl->GetFunction(context).ToLocalChecked()).FromJust();
+
+  isolate->SetHostExecuteDynamicModuleCallback(
+      DynamicModuleWrap::HostExecuteDynamicModuleCallback);
 
 #define V(name)                                                                \
     target->Set(context,                                                       \
diff --git a/src/module_wrap.h b/src/module_wrap.h
index 6d231631d6..5cfc8e65cf 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -12,11 +12,6 @@
 namespace node {
 namespace loader {
 
-enum PackageMainCheck : bool {
-    CheckMain = true,
-    IgnoreMain = false
-};
-
 enum ScriptType : int {
   kScript,
   kModule,
@@ -28,14 +23,17 @@ enum HostDefinedOptions : int {
   kLength = 10,
 };
 
-v8::Maybe<url::URL> Resolve(Environment* env,
-                            const std::string& specifier,
-                            const url::URL& base,
-                            PackageMainCheck read_pkg_json = CheckMain);
+struct ModuleResolution {
+  url::URL url;
+  bool legacy;
+};
+
+v8::Maybe<ModuleResolution> Resolve(Environment* env,
+                                    const std::string& specifier,
+                                    const url::URL& base);
 
 class ModuleWrap : public BaseObject {
  public:
-  static const std::string EXTENSIONS[];
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context,
@@ -51,18 +49,23 @@ class ModuleWrap : public BaseObject {
   }
 
   inline uint32_t id() { return id_; }
+  
   static ModuleWrap* GetFromID(node::Environment*, uint32_t id);
 
   SET_MEMORY_INFO_NAME(ModuleWrap)
   SET_SELF_SIZE(ModuleWrap)
 
- private:
-  ModuleWrap(Environment* env,
+ protected:
+   ModuleWrap(Environment* env,
              v8::Local<v8::Object> object,
              v8::Local<v8::Module> module,
              v8::Local<v8::String> url);
   ~ModuleWrap();
+  Persistent<v8::Context> context_;
+  Persistent<v8::Module> module_;
+  bool linked_ = false;
 
+ private:
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Link(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Instantiate(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -84,14 +87,31 @@ class ModuleWrap : public BaseObject {
       v8::Local<v8::Module> referrer);
   static ModuleWrap* GetFromModule(node::Environment*, v8::Local<v8::Module>);
 
-  Persistent<v8::Module> module_;
   Persistent<v8::String> url_;
-  bool linked_ = false;
   std::unordered_map<std::string, Persistent<v8::Promise>> resolve_cache_;
-  Persistent<v8::Context> context_;
   uint32_t id_;
 };
 
+class DynamicModuleWrap : public ModuleWrap {
+ public:
+  static void SetExport(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  DynamicModuleWrap(Environment* env,
+                    v8::Local<v8::Object> object,
+                    v8::Local<v8::Module> module,
+                    v8::Local<v8::String> url,
+                    v8::Local<v8::Function> dynamic_exec_callback);
+  ~DynamicModuleWrap();
+  
+  static void HostExecuteDynamicModuleCallback(
+      v8::Local<v8::Context> context, v8::Local<v8::DynamicModule> module);
+
+ private:
+  Persistent<v8::Function> dynamic_exec_callback_;
+};
+
+
 }  // namespace loader
 }  // namespace node
 
diff --git a/src/node_errors.h b/src/node_errors.h
index cea7c108c1..3b849abed4 100644
--- a/src/node_errors.h
+++ b/src/node_errors.h
@@ -59,12 +59,14 @@ void FatalException(const v8::FunctionCallbackInfo<v8::Value>& args);
   V(ERR_CONSTRUCT_CALL_REQUIRED, Error)                                      \
   V(ERR_INVALID_ARG_VALUE, TypeError)                                        \
   V(ERR_INVALID_ARG_TYPE, TypeError)                                         \
+  V(ERR_INVALID_MODULE_SPECIFIER, TypeError)                                 \
+  V(ERR_INVALID_PACKAGE_CONFIG, SyntaxError)                                 \
   V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                  \
   V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                     \
   V(ERR_MISSING_ARGS, TypeError)                                             \
   V(ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST, TypeError)                    \
-  V(ERR_MISSING_MODULE, Error)                                               \
   V(ERR_MISSING_PLATFORM_FOR_WORKER, Error)                                  \
+  V(ERR_MODULE_NOT_FOUND, Error)                                             \
   V(ERR_OUT_OF_RANGE, RangeError)                                            \
   V(ERR_SCRIPT_EXECUTION_INTERRUPTED, Error)                                 \
   V(ERR_SCRIPT_EXECUTION_TIMEOUT, Error)                                     \
diff --git a/src/node_options.cc b/src/node_options.cc
index 6d141f52aa..77efccf152 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -79,10 +79,6 @@ void PerIsolateOptions::CheckOptions(std::vector<std::string>* errors) {
 }
 
 void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors) {
-  if (!userland_loader.empty() && !experimental_modules) {
-    errors->push_back("--loader requires --experimental-modules be enabled");
-  }
-
   if (syntax_check_only && has_eval_string) {
     errors->push_back("either --check or --eval can be used, not both");
   }
@@ -156,10 +152,6 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "experimental await keyword support in REPL",
             &EnvironmentOptions::experimental_repl_await,
             kAllowedInEnvironment);
-  AddOption("--experimental-vm-modules",
-            "experimental ES Module support in vm module",
-            &EnvironmentOptions::experimental_vm_modules,
-            kAllowedInEnvironment);
   AddOption("--experimental-worker", "", NoOp{}, kAllowedInEnvironment);
 #ifdef NODE_REPORT
   AddOption("--experimental-report",
@@ -173,11 +165,6 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "(default: llhttp).",
             &EnvironmentOptions::http_parser,
             kAllowedInEnvironment);
-  AddOption("--loader",
-            "(with --experimental-modules) use the specified file as a "
-            "custom loader",
-            &EnvironmentOptions::userland_loader,
-            kAllowedInEnvironment);
   AddOption("--no-deprecation",
             "silence deprecation warnings",
             &EnvironmentOptions::no_deprecation,
diff --git a/src/node_options.h b/src/node_options.h
index d77c4fb808..963efffbb4 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -112,7 +112,6 @@ class EnvironmentOptions : public Options {
   bool trace_deprecation = false;
   bool trace_sync_io = false;
   bool trace_warnings = false;
-  std::string userland_loader;
 
   bool syntax_check_only = false;
   bool has_eval_string = false;
diff --git a/test/addons/hello-world-esm/binding.cc b/test/addons/hello-world-esm/binding.cc
deleted file mode 100644
index 02eecec099..0000000000
--- a/test/addons/hello-world-esm/binding.cc
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <node.h>
-#include <v8.h>
-
-void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Isolate* isolate = args.GetIsolate();
-  args.GetReturnValue().Set(v8::String::NewFromUtf8(
-        isolate, "world", v8::NewStringType::kNormal).ToLocalChecked());
-}
-
-void init(v8::Local<v8::Object> exports) {
-  NODE_SET_METHOD(exports, "hello", Method);
-}
-
-NODE_MODULE(NODE_GYP_MODULE_NAME, init)
diff --git a/test/addons/hello-world-esm/binding.gyp b/test/addons/hello-world-esm/binding.gyp
deleted file mode 100644
index 7ede63d94a..0000000000
--- a/test/addons/hello-world-esm/binding.gyp
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  'targets': [
-    {
-      'target_name': 'binding',
-      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
-      'sources': [ 'binding.cc' ]
-    }
-  ]
-}
diff --git a/test/addons/hello-world-esm/test.js b/test/addons/hello-world-esm/test.js
deleted file mode 100644
index d0faf65540..0000000000
--- a/test/addons/hello-world-esm/test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-'use strict';
-const common = require('../../common');
-
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const { copyFileSync } = require('fs');
-const { join } = require('path');
-
-const buildDir = join(__dirname, 'build');
-
-copyFileSync(join(buildDir, common.buildType, 'binding.node'),
-             join(buildDir, 'binding.node'));
-
-const result = spawnSync(process.execPath,
-                         ['--experimental-modules', `${__dirname}/test.mjs`]);
-
-assert.ifError(result.error);
-// TODO: Uncomment this once ESM is no longer experimental.
-// assert.strictEqual(result.stderr.toString().trim(), '');
-assert.strictEqual(result.stdout.toString().trim(), 'binding.hello() = world');
diff --git a/test/addons/hello-world-esm/test.mjs b/test/addons/hello-world-esm/test.mjs
deleted file mode 100644
index d98de5bf87..0000000000
--- a/test/addons/hello-world-esm/test.mjs
+++ /dev/null
@@ -1,6 +0,0 @@
-/* eslint-disable node-core/required-modules */
-
-import assert from 'assert';
-import binding from './build/binding.node';
-assert.strictEqual(binding.hello(), 'world');
-console.log('binding.hello() =', binding.hello());
diff --git a/test/common/index.mjs b/test/common/index.mjs
index de9119f37e..41592098eb 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -1,6 +1,15 @@
 // Flags: --experimental-modules
 /* eslint-disable node-core/required-modules */
-import common from './index.js';
+
+import { createRequireFromPath } from 'module';
+import { fileURLToPath as toPath } from 'url';
+
+function createRequire(metaUrl) {
+  return createRequireFromPath(toPath(metaUrl));
+}
+
+const require = createRequire(import.meta.url);
+const common = require('./index.js');
 
 const {
   isMainThread,
@@ -91,5 +100,6 @@ export {
   getBufferSources,
   disableCrashOnUnhandledRejection,
   getTTYfd,
-  runWithInvalidFD
+  runWithInvalidFD,
+  createRequire
 };
diff --git a/test/es-module/test-esm-basic-imports.mjs b/test/es-module/test-esm-basic-imports.mjs
index 78a4106f94..d9bb22be0a 100644
--- a/test/es-module/test-esm-basic-imports.mjs
+++ b/test/es-module/test-esm-basic-imports.mjs
@@ -1,5 +1,6 @@
 // Flags: --experimental-modules
-import '../common';
+/* eslint-disable node-core/required-modules */
+import '../common/index.mjs';
 import assert from 'assert';
 import ok from '../fixtures/es-modules/test-esm-ok.mjs';
 import okShebang from './test-esm-shebang.mjs';
diff --git a/test/es-module/test-esm-cyclic-dynamic-import.mjs b/test/es-module/test-esm-cyclic-dynamic-import.mjs
index c8dfff919c..a207efc73e 100644
--- a/test/es-module/test-esm-cyclic-dynamic-import.mjs
+++ b/test/es-module/test-esm-cyclic-dynamic-import.mjs
@@ -1,3 +1,4 @@
 // Flags: --experimental-modules
-import '../common';
-import('./test-esm-cyclic-dynamic-import');
+/* eslint-disable node-core/required-modules */
+import '../common/index.mjs';
+import('./test-esm-cyclic-dynamic-import.mjs');
diff --git a/test/es-module/test-esm-double-encoding.mjs b/test/es-module/test-esm-double-encoding.mjs
index c81d0530d3..9366d4bd6b 100644
--- a/test/es-module/test-esm-double-encoding.mjs
+++ b/test/es-module/test-esm-double-encoding.mjs
@@ -1,6 +1,7 @@
 // Flags: --experimental-modules
-import '../common';
+/* eslint-disable node-core/required-modules */
+import '../common/index.mjs';
 
 // Assert we can import files with `%` in their pathname.
 
-import '../fixtures/es-modules/test-esm-double-encoding-native%2520.js';
+import '../fixtures/es-modules/test-esm-double-encoding-native%2520.mjs';
diff --git a/test/es-module/test-esm-dynamic-import.js b/test/es-module/test-esm-dynamic-import.js
index 8873399776..325011b50f 100644
--- a/test/es-module/test-esm-dynamic-import.js
+++ b/test/es-module/test-esm-dynamic-import.js
@@ -1,4 +1,5 @@
 // Flags: --experimental-modules
+
 'use strict';
 const common = require('../common');
 const assert = require('assert');
@@ -17,7 +18,7 @@ function expectErrorProperty(result, propertyKey, value) {
 }
 
 function expectMissingModuleError(result) {
-  expectErrorProperty(result, 'code', 'MODULE_NOT_FOUND');
+  expectErrorProperty(result, 'code', 'ERR_MODULE_NOT_FOUND');
 }
 
 function expectOkNamespace(result) {
diff --git a/test/es-module/test-esm-encoded-path.mjs b/test/es-module/test-esm-encoded-path.mjs
index 365a425afa..2cabfdacff 100644
--- a/test/es-module/test-esm-encoded-path.mjs
+++ b/test/es-module/test-esm-encoded-path.mjs
@@ -1,5 +1,6 @@
 // Flags: --experimental-modules
-import '../common';
+/* eslint-disable node-core/required-modules */
+import '../common/index.mjs';
 import assert from 'assert';
 // ./test-esm-ok.mjs
 import ok from '../fixtures/es-modules/test-%65%73%6d-ok.mjs';
diff --git a/test/es-module/test-esm-error-cache.js b/test/es-module/test-esm-error-cache.js
index 98244615ef..79f76357ec 100644
--- a/test/es-module/test-esm-error-cache.js
+++ b/test/es-module/test-esm-error-cache.js
@@ -1,11 +1,11 @@
-'use strict';
-
 // Flags: --experimental-modules
 
+'use strict';
+
 require('../common');
 const assert = require('assert');
 
-const file = '../fixtures/syntax/bad_syntax.js';
+const file = '../fixtures/syntax/bad_syntax.mjs';
 
 let error;
 (async () => {
diff --git a/test/es-module/test-esm-example-loader.js b/test/es-module/test-esm-example-loader.js
deleted file mode 100644
index 0b0001acea..0000000000
--- a/test/es-module/test-esm-example-loader.js
+++ /dev/null
@@ -1,6 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/example-loader.mjs
-/* eslint-disable node-core/required-modules */
-import assert from 'assert';
-import ok from '../fixtures/es-modules/test-esm-ok.mjs';
-
-assert(ok);
diff --git a/test/es-module/test-esm-forbidden-globals.mjs b/test/es-module/test-esm-forbidden-globals.mjs
index 4e777412a3..cf110ff290 100644
--- a/test/es-module/test-esm-forbidden-globals.mjs
+++ b/test/es-module/test-esm-forbidden-globals.mjs
@@ -1,5 +1,6 @@
 // Flags: --experimental-modules
-import '../common';
+/* eslint-disable node-core/required-modules */
+import '../common/index.mjs';
 
 // eslint-disable-next-line no-undef
 if (typeof arguments !== 'undefined') {
diff --git a/test/es-module/test-esm-import-meta.mjs b/test/es-module/test-esm-import-meta.mjs
index c17e0e20d4..4c34b337fb 100644
--- a/test/es-module/test-esm-import-meta.mjs
+++ b/test/es-module/test-esm-import-meta.mjs
@@ -1,6 +1,7 @@
 // Flags: --experimental-modules
+/* eslint-disable node-core/required-modules */
 
-import '../common';
+import '../common/index.mjs';
 import assert from 'assert';
 
 assert.strictEqual(Object.getPrototypeOf(import.meta), null);
diff --git a/test/es-module/test-esm-json.mjs b/test/es-module/test-esm-json.mjs
deleted file mode 100644
index a7146d19a9..0000000000
--- a/test/es-module/test-esm-json.mjs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Flags: --experimental-modules
-import '../common';
-import assert from 'assert';
-import ok from '../fixtures/es-modules/test-esm-ok.mjs';
-import json from '../fixtures/es-modules/json.json';
-
-assert(ok);
-assert.strictEqual(json.val, 42);
diff --git a/test/es-module/test-esm-live-binding.mjs b/test/es-module/test-esm-live-binding.mjs
index d151e004df..880a6c389b 100644
--- a/test/es-module/test-esm-live-binding.mjs
+++ b/test/es-module/test-esm-live-binding.mjs
@@ -1,6 +1,7 @@
 // Flags: --experimental-modules
+/* eslint-disable node-core/required-modules */
 
-import '../common';
+import '../common/index.mjs';
 import assert from 'assert';
 
 import fs, { readFile, readFileSync } from 'fs';
diff --git a/test/es-module/test-esm-loader-dependency.mjs b/test/es-module/test-esm-loader-dependency.mjs
deleted file mode 100644
index 1ed8685a6f..0000000000
--- a/test/es-module/test-esm-loader-dependency.mjs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/loader-with-dep.mjs
-/* eslint-disable node-core/required-modules */
-import '../fixtures/es-modules/test-esm-ok.mjs';
-
-// We just test that this module doesn't fail loading
diff --git a/test/es-module/test-esm-loader-invalid-format.mjs b/test/es-module/test-esm-loader-invalid-format.mjs
deleted file mode 100644
index f8714d4aa1..0000000000
--- a/test/es-module/test-esm-loader-invalid-format.mjs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/loader-invalid-format.mjs
-import { expectsError, mustCall } from '../common';
-import assert from 'assert';
-
-import('../fixtures/es-modules/test-esm-ok.mjs')
-.then(assert.fail, expectsError({
-  code: 'ERR_INVALID_RETURN_PROPERTY_VALUE',
-  message: 'Expected string to be returned for the "format" from the ' +
-           '"loader resolve" function but got type undefined.'
-}))
-.then(mustCall());
diff --git a/test/es-module/test-esm-loader-invalid-url.mjs b/test/es-module/test-esm-loader-invalid-url.mjs
deleted file mode 100644
index 43971a2e6e..0000000000
--- a/test/es-module/test-esm-loader-invalid-url.mjs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/loader-invalid-url.mjs
-import { expectsError, mustCall } from '../common';
-import assert from 'assert';
-
-import('../fixtures/es-modules/test-esm-ok.mjs')
-.then(assert.fail, expectsError({
-  code: 'ERR_INVALID_RETURN_PROPERTY',
-  message: 'Expected a valid url to be returned for the "url" from the ' +
-           '"loader resolve" function but got ' +
-           '../fixtures/es-modules/test-esm-ok.mjs.'
-}))
-.then(mustCall());
diff --git a/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs b/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs
deleted file mode 100644
index f2b37f7e8a..0000000000
--- a/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs
-
-import { expectsError } from '../common';
-
-import('test').catch(expectsError({
-  code: 'ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK',
-  message: 'The ES Module loader may not return a format of \'dynamic\' ' +
-    'when no dynamicInstantiate function was provided'
-}));
diff --git a/test/es-module/test-esm-loader-search.js b/test/es-module/test-esm-loader-search.js
deleted file mode 100644
index 0ca8990cb7..0000000000
--- a/test/es-module/test-esm-loader-search.js
+++ /dev/null
@@ -1,17 +0,0 @@
-'use strict';
-// Flags: --expose-internals
-
-// This test ensures that search throws errors appropriately
-
-const common = require('../common');
-
-const { search } = require('internal/modules/esm/default_resolve');
-
-common.expectsError(
-  () => search('target', undefined),
-  {
-    code: 'ERR_MISSING_MODULE',
-    type: Error,
-    message: 'Cannot find module target'
-  }
-);
diff --git a/test/es-module/test-esm-main-lookup.mjs b/test/es-module/test-esm-main-lookup.mjs
index ca313a1d26..19c025beab 100644
--- a/test/es-module/test-esm-main-lookup.mjs
+++ b/test/es-module/test-esm-main-lookup.mjs
@@ -1,6 +1,26 @@
 // Flags: --experimental-modules
-import '../common';
+/* eslint-disable node-core/required-modules */
+import '../common/index.mjs';
 import assert from 'assert';
-import main from '../fixtures/es-modules/pjson-main';
 
-assert.strictEqual(main, 'main');
+async function main() {
+  let mod;
+  try {
+    mod = await import('../fixtures/es-modules/pjson-main');
+  } catch (e) {
+    assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
+  }
+
+  assert.strictEqual(mod, undefined);
+
+  try {
+    mod = await import('../fixtures/es-modules/pjson-main/main.mjs');
+  } catch (e) {
+    console.log(e);
+    assert.fail();
+  }
+
+  assert.strictEqual(mod.main, 'main');
+}
+
+main();
diff --git a/test/es-module/test-esm-named-exports.mjs b/test/es-module/test-esm-named-exports.mjs
deleted file mode 100644
index 3aae9230de..0000000000
--- a/test/es-module/test-esm-named-exports.mjs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
-import '../common';
-import { readFile } from 'fs';
-import assert from 'assert';
-import ok from '../fixtures/es-modules/test-esm-ok.mjs';
-
-assert(ok);
-assert(readFile);
diff --git a/test/es-module/test-esm-namespace.mjs b/test/es-module/test-esm-namespace.mjs
index da1286d0f4..38b7ef12d5 100644
--- a/test/es-module/test-esm-namespace.mjs
+++ b/test/es-module/test-esm-namespace.mjs
@@ -1,5 +1,7 @@
 // Flags: --experimental-modules
-import '../common';
+/* eslint-disable node-core/required-modules */
+
+import '../common/index.mjs';
 import * as fs from 'fs';
 import assert from 'assert';
 import Module from 'module';
diff --git a/test/es-module/test-esm-preserve-symlinks-not-found-plain.mjs b/test/es-module/test-esm-preserve-symlinks-not-found-plain.mjs
deleted file mode 100644
index 2ca0f56581..0000000000
--- a/test/es-module/test-esm-preserve-symlinks-not-found-plain.mjs
+++ /dev/null
@@ -1,3 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/not-found-assert-loader.mjs
-/* eslint-disable node-core/required-modules */
-import './not-found.js';
diff --git a/test/es-module/test-esm-preserve-symlinks-not-found.mjs b/test/es-module/test-esm-preserve-symlinks-not-found.mjs
deleted file mode 100644
index 5119957bae..0000000000
--- a/test/es-module/test-esm-preserve-symlinks-not-found.mjs
+++ /dev/null
@@ -1,3 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/not-found-assert-loader.mjs
-/* eslint-disable node-core/required-modules */
-import './not-found';
diff --git a/test/es-module/test-esm-require-cache.mjs b/test/es-module/test-esm-require-cache.mjs
index ff32cde36f..09030e0578 100644
--- a/test/es-module/test-esm-require-cache.mjs
+++ b/test/es-module/test-esm-require-cache.mjs
@@ -1,7 +1,12 @@
 // Flags: --experimental-modules
-import '../common';
-import '../fixtures/es-module-require-cache/preload.js';
-import '../fixtures/es-module-require-cache/counter.js';
+/* eslint-disable node-core/required-modules */
+import { createRequire } from '../common/index.mjs';
 import assert from 'assert';
+//
+const require = createRequire(import.meta.url);
+
+require('../fixtures/es-module-require-cache/preload.js');
+require('../fixtures/es-module-require-cache/counter.js');
+
 assert.strictEqual(global.counter, 1);
 delete global.counter;
diff --git a/test/es-module/test-esm-resolve-hook.mjs b/test/es-module/test-esm-resolve-hook.mjs
deleted file mode 100644
index e326d20b6d..0000000000
--- a/test/es-module/test-esm-resolve-hook.mjs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/js-loader.mjs
-/* eslint-disable node-core/required-modules */
-import { namedExport } from '../fixtures/es-module-loaders/js-as-esm.js';
-import assert from 'assert';
-import ok from '../fixtures/es-modules/test-esm-ok.mjs';
-
-assert(ok);
-assert(namedExport);
diff --git a/test/es-module/test-esm-shared-loader-dep.mjs b/test/es-module/test-esm-shared-loader-dep.mjs
deleted file mode 100644
index 5c274d835c..0000000000
--- a/test/es-module/test-esm-shared-loader-dep.mjs
+++ /dev/null
@@ -1,7 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/loader-shared-dep.mjs
-import '../common';
-import assert from 'assert';
-import '../fixtures/es-modules/test-esm-ok.mjs';
-import dep from '../fixtures/es-module-loaders/loader-dep.js';
-
-assert.strictEqual(dep.format, 'esm');
diff --git a/test/es-module/test-esm-shebang.mjs b/test/es-module/test-esm-shebang.mjs
index d5faace479..486e04dade 100644
--- a/test/es-module/test-esm-shebang.mjs
+++ b/test/es-module/test-esm-shebang.mjs
@@ -1,6 +1,7 @@
 #! }]) // isn't js
 // Flags: --experimental-modules
-import '../common';
+/* eslint-disable node-core/required-modules */
+import '../common/index.mjs';
 
 const isJs = true;
 export default isJs;
diff --git a/test/es-module/test-esm-snapshot.mjs b/test/es-module/test-esm-snapshot.mjs
deleted file mode 100644
index 3d4b44bbdd..0000000000
--- a/test/es-module/test-esm-snapshot.mjs
+++ /dev/null
@@ -1,7 +0,0 @@
-// Flags: --experimental-modules
-import '../common';
-import '../fixtures/es-modules/esm-snapshot-mutator';
-import one from '../fixtures/es-modules/esm-snapshot';
-import assert from 'assert';
-
-assert.strictEqual(one, 1);
diff --git a/test/es-module/test-esm-symlink-main.js b/test/es-module/test-esm-symlink-main.js
index f7631ef2e5..871180f5cc 100644
--- a/test/es-module/test-esm-symlink-main.js
+++ b/test/es-module/test-esm-symlink-main.js
@@ -9,7 +9,7 @@ const fs = require('fs');
 tmpdir.refresh();
 
 const realPath = path.resolve(__dirname, '../fixtures/es-modules/symlink.mjs');
-const symlinkPath = path.resolve(tmpdir.path, 'symlink.js');
+const symlinkPath = path.resolve(tmpdir.path, 'symlink.mjs');
 
 try {
   fs.symlinkSync(realPath, symlinkPath);
diff --git a/test/es-module/test-esm-symlink.js b/test/es-module/test-esm-symlink.js
index 232925a52e..9b9eb98cd9 100644
--- a/test/es-module/test-esm-symlink.js
+++ b/test/es-module/test-esm-symlink.js
@@ -12,8 +12,8 @@ const tmpDir = tmpdir.path;
 
 const entry = path.join(tmpDir, 'entry.mjs');
 const real = path.join(tmpDir, 'index.mjs');
-const link_absolute_path = path.join(tmpDir, 'absolute');
-const link_relative_path = path.join(tmpDir, 'relative');
+const link_absolute_path = path.join(tmpDir, 'absolute.mjs');
+const link_relative_path = path.join(tmpDir, 'relative.mjs');
 const link_ignore_extension = path.join(tmpDir,
                                         'ignore_extension.json');
 const link_directory = path.join(tmpDir, 'directory');
@@ -22,15 +22,13 @@ fs.writeFileSync(real, 'export default [];');
 fs.writeFileSync(entry, `
 import assert from 'assert';
 import real from './index.mjs';
-import absolute from './absolute';
-import relative from './relative';
+import absolute from './absolute.mjs';
+import relative from './relative.mjs';
 import ignoreExtension from './ignore_extension.json';
-import directory from './directory';
 
 assert.strictEqual(absolute, real);
 assert.strictEqual(relative, real);
 assert.strictEqual(ignoreExtension, real);
-assert.strictEqual(directory, real);
 `);
 
 try {
diff --git a/test/es-module/test-esm-throw-undefined.mjs b/test/es-module/test-esm-throw-undefined.mjs
deleted file mode 100644
index 541127eee5..0000000000
--- a/test/es-module/test-esm-throw-undefined.mjs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Flags: --experimental-modules
-import '../common';
-import assert from 'assert';
-
-async function doTest() {
-  await assert.rejects(
-    async () => {
-      await import('../fixtures/es-module-loaders/throw-undefined');
-    },
-    (e) => e === undefined
-  );
-}
-
-doTest();
diff --git a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
deleted file mode 100644
index 28ccd6ecf2..0000000000
--- a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
+++ /dev/null
@@ -1,29 +0,0 @@
-import module from 'module';
-
-const builtins = new Set(
-  Object.keys(process.binding('natives')).filter(str =>
-    /^(?!(?:internal|node|v8)\/)/.test(str))
-);
-
-export function dynamicInstantiate(url) {
-  const builtinInstance = module._load(url.substr(5));
-  const builtinExports = ['default', ...Object.keys(builtinInstance)];
-  return {
-    exports: builtinExports,
-    execute: exports => {
-      for (let name of builtinExports)
-        exports[name].set(builtinInstance[name]);
-      exports.default.set(builtinInstance);
-    }
-  };
-}
-
-export function resolve(specifier, base, defaultResolver) {
-  if (builtins.has(specifier)) {
-    return {
-      url: `node:${specifier}`,
-      format: 'dynamic'
-    };
-  }
-  return defaultResolver(specifier, base);
-}
diff --git a/test/fixtures/es-module-loaders/example-loader.mjs b/test/fixtures/es-module-loaders/example-loader.mjs
deleted file mode 100644
index acb4486edc..0000000000
--- a/test/fixtures/es-module-loaders/example-loader.mjs
+++ /dev/null
@@ -1,37 +0,0 @@
-import url from 'url';
-import path from 'path';
-import process from 'process';
-
-const builtins = new Set(
-  Object.keys(process.binding('natives')).filter((str) =>
-    /^(?!(?:internal|node|v8)\/)/.test(str))
-);
-const JS_EXTENSIONS = new Set(['.js', '.mjs']);
-
-const baseURL = new url.URL('file://');
-baseURL.pathname = process.cwd() + '/';
-
-export function resolve(specifier, parentModuleURL = baseURL /*, defaultResolve */) {
-  if (builtins.has(specifier)) {
-    return {
-      url: specifier,
-      format: 'builtin'
-    };
-  }
-  if (/^\.{0,2}[/]/.test(specifier) !== true && !specifier.startsWith('file:')) {
-    // For node_modules support:
-    // return defaultResolve(specifier, parentModuleURL);
-    throw new Error(
-      `imports must begin with '/', './', or '../'; '${specifier}' does not`);
-  }
-  const resolved = new url.URL(specifier, parentModuleURL);
-  const ext = path.extname(resolved.pathname);
-  if (!JS_EXTENSIONS.has(ext)) {
-    throw new Error(
-      `Cannot load file with non-JavaScript file extension ${ext}.`);
-  }
-  return {
-    url: resolved.href,
-    format: 'esm'
-  };
-}
diff --git a/test/fixtures/es-module-loaders/js-as-esm.js b/test/fixtures/es-module-loaders/js-as-esm.js
deleted file mode 100644
index b4d2741b2f..0000000000
--- a/test/fixtures/es-module-loaders/js-as-esm.js
+++ /dev/null
@@ -1 +0,0 @@
-export const namedExport = 'named-export';
diff --git a/test/fixtures/es-module-loaders/js-loader.mjs b/test/fixtures/es-module-loaders/js-loader.mjs
deleted file mode 100644
index 9fa6b9eed4..0000000000
--- a/test/fixtures/es-module-loaders/js-loader.mjs
+++ /dev/null
@@ -1,24 +0,0 @@
-import { URL } from 'url';
-
-const builtins = new Set(
-  Object.keys(process.binding('natives')).filter(str =>
-    /^(?!(?:internal|node|v8)\/)/.test(str))
-)
-
-const baseURL = new URL('file://');
-baseURL.pathname = process.cwd() + '/';
-
-export function resolve (specifier, base = baseURL) {
-  if (builtins.has(specifier)) {
-    return {
-      url: specifier,
-      format: 'builtin'
-    };
-  }
-  // load all dependencies as esm, regardless of file extension
-  const url = new URL(specifier, base).href;
-  return {
-    url,
-    format: 'esm'
-  };
-}
diff --git a/test/fixtures/es-module-loaders/loader-dep.js b/test/fixtures/es-module-loaders/loader-dep.js
deleted file mode 100644
index cf821afec1..0000000000
--- a/test/fixtures/es-module-loaders/loader-dep.js
+++ /dev/null
@@ -1 +0,0 @@
-exports.format = 'esm';
diff --git a/test/fixtures/es-module-loaders/loader-invalid-format.mjs b/test/fixtures/es-module-loaders/loader-invalid-format.mjs
deleted file mode 100644
index 17a0dcd04d..0000000000
--- a/test/fixtures/es-module-loaders/loader-invalid-format.mjs
+++ /dev/null
@@ -1,8 +0,0 @@
-export async function resolve(specifier, parentModuleURL, defaultResolve) {
-  if (parentModuleURL && specifier === '../fixtures/es-modules/test-esm-ok.mjs') {
-    return {
-      url: 'file:///asdf'
-    };
-  }
-  return defaultResolve(specifier, parentModuleURL);
-}
diff --git a/test/fixtures/es-module-loaders/loader-invalid-url.mjs b/test/fixtures/es-module-loaders/loader-invalid-url.mjs
deleted file mode 100644
index 12efbb5021..0000000000
--- a/test/fixtures/es-module-loaders/loader-invalid-url.mjs
+++ /dev/null
@@ -1,9 +0,0 @@
-export async function resolve(specifier, parentModuleURL, defaultResolve) {
-  if (parentModuleURL && specifier === '../fixtures/es-modules/test-esm-ok.mjs') {
-    return {
-      url: specifier,
-      format: 'esm'
-    };
-  }
-  return defaultResolve(specifier, parentModuleURL);
-}
diff --git a/test/fixtures/es-module-loaders/loader-shared-dep.mjs b/test/fixtures/es-module-loaders/loader-shared-dep.mjs
deleted file mode 100644
index 1a19e4c892..0000000000
--- a/test/fixtures/es-module-loaders/loader-shared-dep.mjs
+++ /dev/null
@@ -1,7 +0,0 @@
-import dep from './loader-dep.js';
-import assert from 'assert';
-
-export function resolve(specifier, base, defaultResolve) {
-  assert.strictEqual(dep.format, 'esm');
-  return defaultResolve(specifier, base);
-}
diff --git a/test/fixtures/es-module-loaders/loader-unknown-builtin-module.mjs b/test/fixtures/es-module-loaders/loader-unknown-builtin-module.mjs
deleted file mode 100644
index e7c6c8ff34..0000000000
--- a/test/fixtures/es-module-loaders/loader-unknown-builtin-module.mjs
+++ /dev/null
@@ -1,6 +0,0 @@
-export async function resolve(specifier, parent, defaultResolve) {
-  if (specifier === 'unknown-builtin-module') {
-    return { url: 'unknown-builtin-module', format: 'builtin' };
-  }
-  return defaultResolve(specifier, parent);
-}
\ No newline at end of file
diff --git a/test/fixtures/es-module-loaders/loader-with-dep.mjs b/test/fixtures/es-module-loaders/loader-with-dep.mjs
deleted file mode 100644
index 944e6e438c..0000000000
--- a/test/fixtures/es-module-loaders/loader-with-dep.mjs
+++ /dev/null
@@ -1,7 +0,0 @@
-import dep from './loader-dep.js';
-export function resolve (specifier, base, defaultResolve) {
-  return {
-    url: defaultResolve(specifier, base).url,
-    format: dep.format
-  };
-}
diff --git a/test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs b/test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs
deleted file mode 100644
index 6993747fcc..0000000000
--- a/test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs
+++ /dev/null
@@ -1,6 +0,0 @@
-export function resolve(specifier, parentModule, defaultResolver) {
-  if (specifier !== 'test') {
-    return defaultResolver(specifier, parentModule);
-  }
-  return { url: 'file://', format: 'dynamic' };
-}
diff --git a/test/fixtures/es-module-loaders/module-named-exports.mjs b/test/fixtures/es-module-loaders/module-named-exports.mjs
deleted file mode 100644
index 04f7f43ebd..0000000000
--- a/test/fixtures/es-module-loaders/module-named-exports.mjs
+++ /dev/null
@@ -1,2 +0,0 @@
-export const foo = 'foo';
-export const bar = 'bar';
diff --git a/test/fixtures/es-module-loaders/not-found-assert-loader.mjs b/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
deleted file mode 100644
index d15f294fe6..0000000000
--- a/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
+++ /dev/null
@@ -1,22 +0,0 @@
-import assert from 'assert';
-
-// a loader that asserts that the defaultResolve will throw "not found"
-// (skipping the top-level main of course)
-let mainLoad = true;
-export async function resolve (specifier, base, defaultResolve) {
-  if (mainLoad) {
-    mainLoad = false;
-    return defaultResolve(specifier, base);
-  }
-  try {
-    await defaultResolve(specifier, base);
-  }
-  catch (e) {
-    assert.strictEqual(e.code, 'MODULE_NOT_FOUND');
-    return {
-      format: 'builtin',
-      url: 'fs'
-    };
-  }
-  assert.fail(`Module resolution for ${specifier} should be throw MODULE_NOT_FOUND`);
-}
diff --git a/test/fixtures/es-module-loaders/syntax-error-import.mjs b/test/fixtures/es-module-loaders/syntax-error-import.mjs
deleted file mode 100644
index 9cad68c7ce..0000000000
--- a/test/fixtures/es-module-loaders/syntax-error-import.mjs
+++ /dev/null
@@ -1 +0,0 @@
-import { foo, notfound } from './module-named-exports';
diff --git a/test/fixtures/es-module-loaders/syntax-error.mjs b/test/fixtures/es-module-loaders/syntax-error.mjs
deleted file mode 100644
index bda4a7e6eb..0000000000
--- a/test/fixtures/es-module-loaders/syntax-error.mjs
+++ /dev/null
@@ -1,2 +0,0 @@
-'use strict';
-await async () => 0;
diff --git a/test/fixtures/es-module-loaders/throw-undefined.mjs b/test/fixtures/es-module-loaders/throw-undefined.mjs
deleted file mode 100644
index f062276767..0000000000
--- a/test/fixtures/es-module-loaders/throw-undefined.mjs
+++ /dev/null
@@ -1,3 +0,0 @@
-'use strict';
-
-throw undefined;
diff --git a/test/fixtures/es-modules/esm-snapshot-mutator.js b/test/fixtures/es-modules/esm-snapshot-mutator.js
deleted file mode 100644
index ee52c270f6..0000000000
--- a/test/fixtures/es-modules/esm-snapshot-mutator.js
+++ /dev/null
@@ -1,4 +0,0 @@
-'use strict';
-const shouldSnapshotFilePath = require.resolve('./esm-snapshot.js');
-require('./esm-snapshot.js');
-require.cache[shouldSnapshotFilePath].exports++;
diff --git a/test/fixtures/es-modules/esm-snapshot.js b/test/fixtures/es-modules/esm-snapshot.js
deleted file mode 100644
index 329a0ca3f4..0000000000
--- a/test/fixtures/es-modules/esm-snapshot.js
+++ /dev/null
@@ -1,2 +0,0 @@
-'use strict';
-module.exports = 1;
diff --git a/test/fixtures/es-modules/json.json b/test/fixtures/es-modules/json.json
deleted file mode 100644
index 8288d42e2b..0000000000
--- a/test/fixtures/es-modules/json.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "val": 42
-}
diff --git a/test/fixtures/es-modules/loop.mjs b/test/fixtures/es-modules/loop.mjs
index 1b5cab10ed..3d2ddd2eb7 100644
--- a/test/fixtures/es-modules/loop.mjs
+++ b/test/fixtures/es-modules/loop.mjs
@@ -1,4 +1,4 @@
-import { message } from './message';
+import { message } from './message.mjs';
 
 var t = 1;
 var k = 1;
diff --git a/test/fixtures/es-modules/pjson-main/main.js b/test/fixtures/es-modules/pjson-main/main.js
deleted file mode 100644
index dfdd47b877..0000000000
--- a/test/fixtures/es-modules/pjson-main/main.js
+++ /dev/null
@@ -1 +0,0 @@
-module.exports = 'main';
diff --git a/test/fixtures/es-modules/pjson-main/main.mjs b/test/fixtures/es-modules/pjson-main/main.mjs
new file mode 100644
index 0000000000..9eb0aade18
--- /dev/null
+++ b/test/fixtures/es-modules/pjson-main/main.mjs
@@ -0,0 +1 @@
+export const main = 'main'
diff --git a/test/fixtures/es-modules/pjson-main/package.json b/test/fixtures/es-modules/pjson-main/package.json
index c13b8cf6ac..ea9b784692 100644
--- a/test/fixtures/es-modules/pjson-main/package.json
+++ b/test/fixtures/es-modules/pjson-main/package.json
@@ -1,3 +1,3 @@
 {
-  "main": "main.js"
+  "main": "main.mjs"
 }
diff --git a/test/fixtures/es-modules/test-esm-double-encoding-native%20.js b/test/fixtures/es-modules/test-esm-double-encoding-native%20.mjs
similarity index 86%
rename from test/fixtures/es-modules/test-esm-double-encoding-native%20.js
rename to test/fixtures/es-modules/test-esm-double-encoding-native%20.mjs
index ea1caa81be..a3bfe972e5 100644
--- a/test/fixtures/es-modules/test-esm-double-encoding-native%20.js
+++ b/test/fixtures/es-modules/test-esm-double-encoding-native%20.mjs
@@ -3,4 +3,4 @@
 // Trivial test to assert we can load files with `%` in their pathname.
 // Imported by `test-esm-double-encoding.mjs`.
 
-module.exports = 42;
+export default 42;
diff --git a/test/fixtures/syntax/bad_syntax.mjs b/test/fixtures/syntax/bad_syntax.mjs
new file mode 100644
index 0000000000..c2cd118b23
--- /dev/null
+++ b/test/fixtures/syntax/bad_syntax.mjs
@@ -0,0 +1 @@
+var foo bar;
diff --git a/test/message/esm_display_syntax_error.out b/test/message/esm_display_syntax_error.out
index ed2e928eb1..2700fd894c 100644
--- a/test/message/esm_display_syntax_error.out
+++ b/test/message/esm_display_syntax_error.out
@@ -3,4 +3,4 @@ file:///*/test/message/esm_display_syntax_error.mjs:3
 await async () => 0;
 ^^^^^
 SyntaxError: Unexpected reserved word
-    at translators.set (internal/modules/esm/translators.js:*:*)
+    at Loader.<anonymous> (internal/modules/esm/translators.js:*:*)
diff --git a/test/message/esm_display_syntax_error_import.mjs b/test/message/esm_display_syntax_error_import.mjs
deleted file mode 100644
index 87cedf1d4e..0000000000
--- a/test/message/esm_display_syntax_error_import.mjs
+++ /dev/null
@@ -1,7 +0,0 @@
-// Flags:  --experimental-modules
-/* eslint-disable no-unused-vars */
-import '../common';
-import {
-  foo,
-  notfound
-} from '../fixtures/es-module-loaders/module-named-exports';
diff --git a/test/message/esm_display_syntax_error_import.out b/test/message/esm_display_syntax_error_import.out
deleted file mode 100644
index 31ee2b6f4b..0000000000
--- a/test/message/esm_display_syntax_error_import.out
+++ /dev/null
@@ -1,6 +0,0 @@
-(node:*) ExperimentalWarning: The ESM module loader is experimental.
-file:///*/test/message/esm_display_syntax_error_import.mjs:6
-  notfound
-  ^^^^^^^^
-SyntaxError: The requested module '../fixtures/es-module-loaders/module-named-exports' does not provide an export named 'notfound'
-    at ModuleJob._instantiate (internal/modules/esm/module_job.js:*:*)
diff --git a/test/message/esm_display_syntax_error_import_module.mjs b/test/message/esm_display_syntax_error_import_module.mjs
deleted file mode 100644
index 32c0edb350..0000000000
--- a/test/message/esm_display_syntax_error_import_module.mjs
+++ /dev/null
@@ -1,3 +0,0 @@
-// Flags:  --experimental-modules
-import '../common';
-import '../fixtures/es-module-loaders/syntax-error-import';
diff --git a/test/message/esm_display_syntax_error_import_module.out b/test/message/esm_display_syntax_error_import_module.out
deleted file mode 100644
index b067a77942..0000000000
--- a/test/message/esm_display_syntax_error_import_module.out
+++ /dev/null
@@ -1,6 +0,0 @@
-(node:*) ExperimentalWarning: The ESM module loader is experimental.
-file:///*/test/fixtures/es-module-loaders/syntax-error-import.mjs:1
-import { foo, notfound } from './module-named-exports';
-              ^^^^^^^^
-SyntaxError: The requested module './module-named-exports' does not provide an export named 'notfound'
-    at ModuleJob._instantiate (internal/modules/esm/module_job.js:*:*)
diff --git a/test/message/esm_display_syntax_error_module.mjs b/test/message/esm_display_syntax_error_module.mjs
deleted file mode 100644
index e74b70bec8..0000000000
--- a/test/message/esm_display_syntax_error_module.mjs
+++ /dev/null
@@ -1,3 +0,0 @@
-// Flags:  --experimental-modules
-import '../common';
-import '../fixtures/es-module-loaders/syntax-error';
diff --git a/test/message/esm_display_syntax_error_module.out b/test/message/esm_display_syntax_error_module.out
deleted file mode 100644
index e636abad9e..0000000000
--- a/test/message/esm_display_syntax_error_module.out
+++ /dev/null
@@ -1,6 +0,0 @@
-(node:*) ExperimentalWarning: The ESM module loader is experimental.
-file:///*/test/fixtures/es-module-loaders/syntax-error.mjs:2
-await async () => 0;
-^^^^^
-SyntaxError: Unexpected reserved word
-    at translators.set (internal/modules/esm/translators.js:*:*)
diff --git a/test/parallel/test-loaders-unknown-builtin-module.mjs b/test/parallel/test-loaders-unknown-builtin-module.mjs
deleted file mode 100644
index db3cfa3582..0000000000
--- a/test/parallel/test-loaders-unknown-builtin-module.mjs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/loader-unknown-builtin-module.mjs
-import { expectsError, mustCall } from '../common';
-import assert from 'assert';
-
-const unknownBuiltinModule = 'unknown-builtin-module';
-
-import(unknownBuiltinModule)
-.then(assert.fail, expectsError({
-  code: 'ERR_UNKNOWN_BUILTIN_MODULE',
-  message: `No such built-in module: ${unknownBuiltinModule}`
-}))
-.then(mustCall());
diff --git a/test/parallel/test-module-main-extension-lookup.js b/test/parallel/test-module-main-extension-lookup.js
index 3d20316647..9e7eab295e 100644
--- a/test/parallel/test-module-main-extension-lookup.js
+++ b/test/parallel/test-module-main-extension-lookup.js
@@ -6,6 +6,6 @@ const { execFileSync } = require('child_process');
 const node = process.argv[0];
 
 execFileSync(node, ['--experimental-modules',
-                    fixtures.path('es-modules', 'test-esm-ok')]);
+                    fixtures.path('es-modules', 'test-esm-ok.mjs')]);
 execFileSync(node, ['--experimental-modules',
                     fixtures.path('es-modules', 'noext')]);
diff --git a/test/parallel/test-util-inspect-namespace.js b/test/parallel/test-util-inspect-namespace.js
deleted file mode 100644
index f2b6e57178..0000000000
--- a/test/parallel/test-util-inspect-namespace.js
+++ /dev/null
@@ -1,20 +0,0 @@
-'use strict';
-
-// Flags: --experimental-vm-modules
-
-require('../common');
-const assert = require('assert');
-
-const { SourceTextModule } = require('vm');
-const { inspect } = require('util');
-
-(async () => {
-  const m = new SourceTextModule('export const a = 1; export var b = 2');
-  await m.link(() => 0);
-  m.instantiate();
-  assert.strictEqual(
-    inspect(m.namespace),
-    '[Module] { a: <uninitialized>, b: undefined }');
-  await m.evaluate();
-  assert.strictEqual(inspect(m.namespace), '[Module] { a: 1, b: 2 }');
-})();
diff --git a/test/parallel/test-util-types.js b/test/parallel/test-util-types.js
deleted file mode 100644
index 69ebaaba12..0000000000
--- a/test/parallel/test-util-types.js
+++ /dev/null
@@ -1,287 +0,0 @@
-// Flags: --experimental-vm-modules --expose-internals
-'use strict';
-require('../common');
-const fixtures = require('../common/fixtures');
-const assert = require('assert');
-const { types, inspect } = require('util');
-const vm = require('vm');
-const { internalBinding } = require('internal/test/binding');
-const { JSStream } = internalBinding('js_stream');
-
-const external = (new JSStream())._externalStream;
-const wasmBuffer = fixtures.readSync('simple.wasm');
-
-for (const [ value, _method ] of [
-  [ external, 'isExternal' ],
-  [ new Date() ],
-  [ (function() { return arguments; })(), 'isArgumentsObject' ],
-  [ new Boolean(), 'isBooleanObject' ],
-  [ new Number(), 'isNumberObject' ],
-  [ new String(), 'isStringObject' ],
-  [ Object(Symbol()), 'isSymbolObject' ],
-  [ Object(BigInt(0)), 'isBigIntObject' ],
-  [ new Error(), 'isNativeError' ],
-  [ new RegExp() ],
-  [ async function() {}, 'isAsyncFunction' ],
-  [ function*() {}, 'isGeneratorFunction' ],
-  [ (function*() {})(), 'isGeneratorObject' ],
-  [ Promise.resolve() ],
-  [ new Map() ],
-  [ new Set() ],
-  [ (new Map())[Symbol.iterator](), 'isMapIterator' ],
-  [ (new Set())[Symbol.iterator](), 'isSetIterator' ],
-  [ new WeakMap() ],
-  [ new WeakSet() ],
-  [ new ArrayBuffer() ],
-  [ new Uint8Array() ],
-  [ new Uint8ClampedArray() ],
-  [ new Uint16Array() ],
-  [ new Uint32Array() ],
-  [ new Int8Array() ],
-  [ new Int16Array() ],
-  [ new Int32Array() ],
-  [ new Float32Array() ],
-  [ new Float64Array() ],
-  [ new BigInt64Array() ],
-  [ new BigUint64Array() ],
-  [ Object.defineProperty(new Uint8Array(),
-                          Symbol.toStringTag,
-                          { value: 'foo' }) ],
-  [ new DataView(new ArrayBuffer()) ],
-  [ new SharedArrayBuffer() ],
-  [ new Proxy({}, {}), 'isProxy' ],
-  [ new WebAssembly.Module(wasmBuffer), 'isWebAssemblyCompiledModule' ],
-]) {
-  const method = _method || `is${value.constructor.name}`;
-  assert(method in types, `Missing ${method} for ${inspect(value)}`);
-  assert(types[method](value), `Want ${inspect(value)} to match ${method}`);
-
-  for (const key of Object.keys(types)) {
-    if ((types.isArrayBufferView(value) ||
-         types.isAnyArrayBuffer(value)) && key.includes('Array') ||
-         key === 'isBoxedPrimitive') {
-      continue;
-    }
-
-    assert.strictEqual(types[key](value),
-                       key === method,
-                       `${inspect(value)}: ${key}, ` +
-                       `${method}, ${types[key](value)}`);
-  }
-}
-
-// Check boxed primitives.
-[
-  new Boolean(),
-  new Number(),
-  new String(),
-  Object(Symbol()),
-  Object(BigInt(0))
-].forEach((entry) => assert(types.isBoxedPrimitive(entry)));
-
-{
-  assert(!types.isUint8Array({ [Symbol.toStringTag]: 'Uint8Array' }));
-  assert(types.isUint8Array(vm.runInNewContext('new Uint8Array')));
-
-  assert(!types.isUint8ClampedArray({
-    [Symbol.toStringTag]: 'Uint8ClampedArray'
-  }));
-  assert(types.isUint8ClampedArray(
-    vm.runInNewContext('new Uint8ClampedArray')
-  ));
-
-  assert(!types.isUint16Array({ [Symbol.toStringTag]: 'Uint16Array' }));
-  assert(types.isUint16Array(vm.runInNewContext('new Uint16Array')));
-
-  assert(!types.isUint32Array({ [Symbol.toStringTag]: 'Uint32Array' }));
-  assert(types.isUint32Array(vm.runInNewContext('new Uint32Array')));
-
-  assert(!types.isInt8Array({ [Symbol.toStringTag]: 'Int8Array' }));
-  assert(types.isInt8Array(vm.runInNewContext('new Int8Array')));
-
-  assert(!types.isInt16Array({ [Symbol.toStringTag]: 'Int16Array' }));
-  assert(types.isInt16Array(vm.runInNewContext('new Int16Array')));
-
-  assert(!types.isInt32Array({ [Symbol.toStringTag]: 'Int32Array' }));
-  assert(types.isInt32Array(vm.runInNewContext('new Int32Array')));
-
-  assert(!types.isFloat32Array({ [Symbol.toStringTag]: 'Float32Array' }));
-  assert(types.isFloat32Array(vm.runInNewContext('new Float32Array')));
-
-  assert(!types.isFloat64Array({ [Symbol.toStringTag]: 'Float64Array' }));
-  assert(types.isFloat64Array(vm.runInNewContext('new Float64Array')));
-
-  assert(!types.isBigInt64Array({ [Symbol.toStringTag]: 'BigInt64Array' }));
-  assert(types.isBigInt64Array(vm.runInNewContext('new BigInt64Array')));
-
-  assert(!types.isBigUint64Array({ [Symbol.toStringTag]: 'BigUint64Array' }));
-  assert(types.isBigUint64Array(vm.runInNewContext('new BigUint64Array')));
-}
-
-{
-  const primitive = true;
-  const arrayBuffer = new ArrayBuffer();
-  const buffer = Buffer.from(arrayBuffer);
-  const dataView = new DataView(arrayBuffer);
-  const uint8Array = new Uint8Array(arrayBuffer);
-  const uint8ClampedArray = new Uint8ClampedArray(arrayBuffer);
-  const uint16Array = new Uint16Array(arrayBuffer);
-  const uint32Array = new Uint32Array(arrayBuffer);
-  const int8Array = new Int8Array(arrayBuffer);
-  const int16Array = new Int16Array(arrayBuffer);
-  const int32Array = new Int32Array(arrayBuffer);
-  const float32Array = new Float32Array(arrayBuffer);
-  const float64Array = new Float64Array(arrayBuffer);
-  const bigInt64Array = new BigInt64Array(arrayBuffer);
-  const bigUint64Array = new BigUint64Array(arrayBuffer);
-
-  const fakeBuffer = Object.create(Buffer.prototype);
-  const fakeDataView = Object.create(DataView.prototype);
-  const fakeUint8Array = Object.create(Uint8Array.prototype);
-  const fakeUint8ClampedArray = Object.create(Uint8ClampedArray.prototype);
-  const fakeUint16Array = Object.create(Uint16Array.prototype);
-  const fakeUint32Array = Object.create(Uint32Array.prototype);
-  const fakeInt8Array = Object.create(Int8Array.prototype);
-  const fakeInt16Array = Object.create(Int16Array.prototype);
-  const fakeInt32Array = Object.create(Int32Array.prototype);
-  const fakeFloat32Array = Object.create(Float32Array.prototype);
-  const fakeFloat64Array = Object.create(Float64Array.prototype);
-  const fakeBigInt64Array = Object.create(BigInt64Array.prototype);
-  const fakeBigUint64Array = Object.create(BigUint64Array.prototype);
-
-  const stealthyDataView =
-    Object.setPrototypeOf(new DataView(arrayBuffer), Uint8Array.prototype);
-  const stealthyUint8Array =
-    Object.setPrototypeOf(new Uint8Array(arrayBuffer), ArrayBuffer.prototype);
-  const stealthyUint8ClampedArray =
-    Object.setPrototypeOf(
-      new Uint8ClampedArray(arrayBuffer), ArrayBuffer.prototype
-    );
-  const stealthyUint16Array =
-    Object.setPrototypeOf(new Uint16Array(arrayBuffer), Uint16Array.prototype);
-  const stealthyUint32Array =
-    Object.setPrototypeOf(new Uint32Array(arrayBuffer), Uint32Array.prototype);
-  const stealthyInt8Array =
-    Object.setPrototypeOf(new Int8Array(arrayBuffer), Int8Array.prototype);
-  const stealthyInt16Array =
-    Object.setPrototypeOf(new Int16Array(arrayBuffer), Int16Array.prototype);
-  const stealthyInt32Array =
-    Object.setPrototypeOf(new Int32Array(arrayBuffer), Int32Array.prototype);
-  const stealthyFloat32Array =
-    Object.setPrototypeOf(
-      new Float32Array(arrayBuffer), Float32Array.prototype
-    );
-  const stealthyFloat64Array =
-    Object.setPrototypeOf(
-      new Float64Array(arrayBuffer), Float64Array.prototype
-    );
-  const stealthyBigInt64Array =
-    Object.setPrototypeOf(
-      new BigInt64Array(arrayBuffer), BigInt64Array.prototype
-    );
-  const stealthyBigUint64Array =
-    Object.setPrototypeOf(
-      new BigUint64Array(arrayBuffer), BigUint64Array.prototype
-    );
-
-  const all = [
-    primitive, arrayBuffer, buffer, fakeBuffer,
-    dataView, fakeDataView, stealthyDataView,
-    uint8Array, fakeUint8Array, stealthyUint8Array,
-    uint8ClampedArray, fakeUint8ClampedArray, stealthyUint8ClampedArray,
-    uint16Array, fakeUint16Array, stealthyUint16Array,
-    uint32Array, fakeUint32Array, stealthyUint32Array,
-    int8Array, fakeInt8Array, stealthyInt8Array,
-    int16Array, fakeInt16Array, stealthyInt16Array,
-    int32Array, fakeInt32Array, stealthyInt32Array,
-    float32Array, fakeFloat32Array, stealthyFloat32Array,
-    float64Array, fakeFloat64Array, stealthyFloat64Array,
-    bigInt64Array, fakeBigInt64Array, stealthyBigInt64Array,
-    bigUint64Array, fakeBigUint64Array, stealthyBigUint64Array
-  ];
-
-  const expected = {
-    isArrayBufferView: [
-      buffer,
-      dataView, stealthyDataView,
-      uint8Array, stealthyUint8Array,
-      uint8ClampedArray, stealthyUint8ClampedArray,
-      uint16Array, stealthyUint16Array,
-      uint32Array, stealthyUint32Array,
-      int8Array, stealthyInt8Array,
-      int16Array, stealthyInt16Array,
-      int32Array, stealthyInt32Array,
-      float32Array, stealthyFloat32Array,
-      float64Array, stealthyFloat64Array,
-      bigInt64Array, stealthyBigInt64Array,
-      bigUint64Array, stealthyBigUint64Array
-    ],
-    isTypedArray: [
-      buffer,
-      uint8Array, stealthyUint8Array,
-      uint8ClampedArray, stealthyUint8ClampedArray,
-      uint16Array, stealthyUint16Array,
-      uint32Array, stealthyUint32Array,
-      int8Array, stealthyInt8Array,
-      int16Array, stealthyInt16Array,
-      int32Array, stealthyInt32Array,
-      float32Array, stealthyFloat32Array,
-      float64Array, stealthyFloat64Array,
-      bigInt64Array, stealthyBigInt64Array,
-      bigUint64Array, stealthyBigUint64Array
-    ],
-    isUint8Array: [
-      buffer, uint8Array, stealthyUint8Array
-    ],
-    isUint8ClampedArray: [
-      uint8ClampedArray, stealthyUint8ClampedArray
-    ],
-    isUint16Array: [
-      uint16Array, stealthyUint16Array
-    ],
-    isUint32Array: [
-      uint32Array, stealthyUint32Array
-    ],
-    isInt8Array: [
-      int8Array, stealthyInt8Array
-    ],
-    isInt16Array: [
-      int16Array, stealthyInt16Array
-    ],
-    isInt32Array: [
-      int32Array, stealthyInt32Array
-    ],
-    isFloat32Array: [
-      float32Array, stealthyFloat32Array
-    ],
-    isFloat64Array: [
-      float64Array, stealthyFloat64Array
-    ],
-    isBigInt64Array: [
-      bigInt64Array, stealthyBigInt64Array
-    ],
-    isBigUint64Array: [
-      bigUint64Array, stealthyBigUint64Array
-    ]
-  };
-
-  for (const testedFunc of Object.keys(expected)) {
-    const func = types[testedFunc];
-    const yup = [];
-    for (const value of all) {
-      if (func(value)) {
-        yup.push(value);
-      }
-    }
-    console.log('Testing', testedFunc);
-    assert.deepStrictEqual(yup, expected[testedFunc]);
-  }
-}
-
-(async () => {
-  const m = new vm.SourceTextModule('');
-  await m.link(() => 0);
-  m.instantiate();
-  await m.evaluate();
-  assert.ok(types.isModuleNamespaceObject(m.namespace));
-})();
diff --git a/test/parallel/test-vm-module-basic.js b/test/parallel/test-vm-module-basic.js
deleted file mode 100644
index 8cf687c2bb..0000000000
--- a/test/parallel/test-vm-module-basic.js
+++ /dev/null
@@ -1,65 +0,0 @@
-'use strict';
-
-// Flags: --experimental-vm-modules
-
-const common = require('../common');
-const assert = require('assert');
-const { SourceTextModule, createContext } = require('vm');
-
-(async function test1() {
-  const context = createContext({
-    foo: 'bar',
-    baz: undefined,
-    typeofProcess: undefined,
-  });
-  const m = new SourceTextModule(
-    'baz = foo; typeofProcess = typeof process; typeof Object;',
-    { context }
-  );
-  assert.strictEqual(m.status, 'uninstantiated');
-  await m.link(common.mustNotCall());
-  m.instantiate();
-  assert.strictEqual(m.status, 'instantiated');
-  const result = await m.evaluate();
-  assert.strictEqual(m.status, 'evaluated');
-  assert.strictEqual(Object.getPrototypeOf(result), null);
-  assert.deepStrictEqual(context, {
-    foo: 'bar',
-    baz: 'bar',
-    typeofProcess: 'undefined'
-  });
-  assert.strictEqual(result.result, 'function');
-}());
-
-(async () => {
-  const m = new SourceTextModule(
-    'global.vmResult = "foo"; Object.prototype.toString.call(process);'
-  );
-  await m.link(common.mustNotCall());
-  m.instantiate();
-  const { result } = await m.evaluate();
-  assert.strictEqual(global.vmResult, 'foo');
-  assert.strictEqual(result, '[object process]');
-  delete global.vmResult;
-})();
-
-(async () => {
-  const m = new SourceTextModule('while (true) {}');
-  await m.link(common.mustNotCall());
-  m.instantiate();
-  await m.evaluate({ timeout: 500 })
-    .then(() => assert(false), () => {});
-})();
-
-// Check the generated url for each module
-(async () => {
-  const context1 = createContext({ });
-  const context2 = createContext({ });
-
-  const m1 = new SourceTextModule('1', { context: context1 });
-  assert.strictEqual(m1.url, 'vm:module(0)');
-  const m2 = new SourceTextModule('2', { context: context1 });
-  assert.strictEqual(m2.url, 'vm:module(1)');
-  const m3 = new SourceTextModule('3', { context: context2 });
-  assert.strictEqual(m3.url, 'vm:module(0)');
-})();
diff --git a/test/parallel/test-vm-module-dynamic-import.js b/test/parallel/test-vm-module-dynamic-import.js
deleted file mode 100644
index 600f455e93..0000000000
--- a/test/parallel/test-vm-module-dynamic-import.js
+++ /dev/null
@@ -1,101 +0,0 @@
-'use strict';
-
-// Flags: --experimental-vm-modules --experimental-modules
-
-const common = require('../common');
-
-const assert = require('assert');
-const { Script, SourceTextModule, createContext } = require('vm');
-
-async function testNoCallback() {
-  const m = new SourceTextModule('import("foo")', { context: createContext() });
-  await m.link(common.mustNotCall());
-  m.instantiate();
-  const { result } = await m.evaluate();
-  let threw = false;
-  try {
-    await result;
-  } catch (err) {
-    threw = true;
-    assert.strictEqual(err.code, 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING');
-  }
-  assert(threw);
-}
-
-async function test() {
-  const foo = new SourceTextModule('export const a = 1;');
-  await foo.link(common.mustNotCall());
-  foo.instantiate();
-  await foo.evaluate();
-
-  {
-    const s = new Script('import("foo")', {
-      importModuleDynamically: common.mustCall((specifier, wrap) => {
-        assert.strictEqual(specifier, 'foo');
-        assert.strictEqual(wrap, s);
-        return foo;
-      }),
-    });
-
-    const result = s.runInThisContext();
-    assert.strictEqual(foo.namespace, await result);
-  }
-
-  {
-    const m = new SourceTextModule('import("foo")', {
-      importModuleDynamically: common.mustCall((specifier, wrap) => {
-        assert.strictEqual(specifier, 'foo');
-        assert.strictEqual(wrap, m);
-        return foo;
-      }),
-    });
-    await m.link(common.mustNotCall());
-    m.instantiate();
-    const { result } = await m.evaluate();
-    assert.strictEqual(foo.namespace, await result);
-  }
-}
-
-async function testInvalid() {
-  const m = new SourceTextModule('import("foo")', {
-    importModuleDynamically: common.mustCall((specifier, wrap) => {
-      return 5;
-    }),
-  });
-  await m.link(common.mustNotCall());
-  m.instantiate();
-  const { result } = await m.evaluate();
-  await result.catch(common.mustCall((e) => {
-    assert.strictEqual(e.code, 'ERR_VM_MODULE_NOT_MODULE');
-  }));
-
-  const s = new Script('import("foo")', {
-    importModuleDynamically: common.mustCall((specifier, wrap) => {
-      return undefined;
-    }),
-  });
-  let threw = false;
-  try {
-    await s.runInThisContext();
-  } catch (e) {
-    threw = true;
-    assert.strictEqual(e.code, 'ERR_VM_MODULE_NOT_MODULE');
-  }
-  assert(threw);
-}
-
-async function testInvalidimportModuleDynamically() {
-  assert.throws(
-    () => new Script(
-      'import("foo")',
-      { importModuleDynamically: false }),
-    { code: 'ERR_INVALID_ARG_TYPE' }
-  );
-}
-
-(async function() {
-  await testNoCallback();
-  await test();
-  await testInvalid();
-  await testInvalidimportModuleDynamically();
-}()).then(common.mustCall());
diff --git a/test/parallel/test-vm-module-errors.js b/test/parallel/test-vm-module-errors.js
deleted file mode 100644
index a343a542a1..0000000000
--- a/test/parallel/test-vm-module-errors.js
+++ /dev/null
@@ -1,284 +0,0 @@
-'use strict';
-
-// Flags: --experimental-vm-modules
-
-const common = require('../common');
-
-const assert = require('assert');
-
-const { SourceTextModule, createContext } = require('vm');
-
-async function expectsRejection(fn, settings) {
-  const validateError = common.expectsError(settings);
-  // Retain async context.
-  const storedError = new Error('Thrown from:');
-  try {
-    await fn();
-  } catch (err) {
-    try {
-      validateError(err);
-    } catch (validationError) {
-      console.error(validationError);
-      console.error('Original error:');
-      console.error(err);
-      throw storedError;
-    }
-    return;
-  }
-  assert.fail('Missing expected exception');
-}
-
-async function createEmptyLinkedModule() {
-  const m = new SourceTextModule('');
-  await m.link(common.mustNotCall());
-  return m;
-}
-
-async function checkArgType() {
-  common.expectsError(() => {
-    new SourceTextModule();
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  });
-
-  for (const invalidOptions of [
-    0, 1, null, true, 'str', () => {}, { url: 0 }, Symbol.iterator,
-    { context: null }, { context: 'hucairz' }, { context: {} }
-  ]) {
-    common.expectsError(() => {
-      new SourceTextModule('', invalidOptions);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
-  }
-
-  for (const invalidLinker of [
-    0, 1, undefined, null, true, 'str', {}, Symbol.iterator
-  ]) {
-    await expectsRejection(async () => {
-      const m = new SourceTextModule('');
-      await m.link(invalidLinker);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
-  }
-}
-
-// Check methods/properties can only be used under a specific state.
-async function checkModuleState() {
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    await m.link(common.mustNotCall());
-    assert.strictEqual(m.linkingStatus, 'linked');
-    await m.link(common.mustNotCall());
-  }, {
-    code: 'ERR_VM_MODULE_ALREADY_LINKED'
-  });
-
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    m.link(common.mustNotCall());
-    assert.strictEqual(m.linkingStatus, 'linking');
-    await m.link(common.mustNotCall());
-  }, {
-    code: 'ERR_VM_MODULE_ALREADY_LINKED'
-  });
-
-  common.expectsError(() => {
-    const m = new SourceTextModule('');
-    m.instantiate();
-  }, {
-    code: 'ERR_VM_MODULE_NOT_LINKED'
-  });
-
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('import "foo";');
-    try {
-      await m.link(common.mustCall(() => ({})));
-    } catch {
-      assert.strictEqual(m.linkingStatus, 'errored');
-      m.instantiate();
-    }
-    assert.fail('Unreachable');
-  }, {
-    code: 'ERR_VM_MODULE_NOT_LINKED'
-  });
-
-  {
-    const m = new SourceTextModule('import "foo";');
-    await m.link(common.mustCall(async (specifier, module) => {
-      assert.strictEqual(module, m);
-      assert.strictEqual(specifier, 'foo');
-      assert.strictEqual(m.linkingStatus, 'linking');
-      common.expectsError(() => {
-        m.instantiate();
-      }, {
-        code: 'ERR_VM_MODULE_NOT_LINKED'
-      });
-      return new SourceTextModule('');
-    }));
-    m.instantiate();
-    await m.evaluate();
-  }
-
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    await m.evaluate();
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be one of instantiated, evaluated, and errored'
-  });
-
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    await m.evaluate(false);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "options" argument must be of type Object. ' +
-             'Received type boolean'
-  });
-
-  await expectsRejection(async () => {
-    const m = await createEmptyLinkedModule();
-    await m.evaluate();
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be one of instantiated, evaluated, and errored'
-  });
-
-  common.expectsError(() => {
-    const m = new SourceTextModule('');
-    m.error;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be errored'
-  });
-
-  await expectsRejection(async () => {
-    const m = await createEmptyLinkedModule();
-    m.instantiate();
-    await m.evaluate();
-    m.error;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be errored'
-  });
-
-  common.expectsError(() => {
-    const m = new SourceTextModule('');
-    m.namespace;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must not be uninstantiated or instantiating'
-  });
-
-  await expectsRejection(async () => {
-    const m = await createEmptyLinkedModule();
-    m.namespace;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must not be uninstantiated or instantiating'
-  });
-}
-
-// Check link() fails when the returned module is not valid.
-async function checkLinking() {
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('import "foo";');
-    try {
-      await m.link(common.mustCall(() => ({})));
-    } catch (err) {
-      assert.strictEqual(m.linkingStatus, 'errored');
-      throw err;
-    }
-    assert.fail('Unreachable');
-  }, {
-    code: 'ERR_VM_MODULE_NOT_MODULE'
-  });
-
-  await expectsRejection(async () => {
-    const c = createContext({ a: 1 });
-    const foo = new SourceTextModule('', { context: c });
-    await foo.link(common.mustNotCall());
-    const bar = new SourceTextModule('import "foo";');
-    try {
-      await bar.link(common.mustCall(() => foo));
-    } catch (err) {
-      assert.strictEqual(bar.linkingStatus, 'errored');
-      throw err;
-    }
-    assert.fail('Unreachable');
-  }, {
-    code: 'ERR_VM_MODULE_DIFFERENT_CONTEXT'
-  });
-
-  await expectsRejection(async () => {
-    const erroredModule = new SourceTextModule('import "foo";');
-    try {
-      await erroredModule.link(common.mustCall(() => ({})));
-    } catch {
-      // ignored
-    } finally {
-      assert.strictEqual(erroredModule.linkingStatus, 'errored');
-    }
-
-    const rootModule = new SourceTextModule('import "errored";');
-    await rootModule.link(common.mustCall(() => erroredModule));
-  }, {
-    code: 'ERR_VM_MODULE_LINKING_ERRORED'
-  });
-}
-
-common.expectsError(() => {
-  new SourceTextModule('', {
-    importModuleDynamically: 'hucairz'
-  });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "options.importModuleDynamically"' +
-    ' property must be of type function. Received type string'
-});
-
-// Check the JavaScript engine deals with exceptions correctly
-async function checkExecution() {
-  await (async () => {
-    const m = new SourceTextModule('import { nonexistent } from "module";');
-    await m.link(common.mustCall(() => new SourceTextModule('')));
-
-    // There is no code for this exception since it is thrown by the JavaScript
-    // engine.
-    assert.throws(() => {
-      m.instantiate();
-    }, SyntaxError);
-  })();
-
-  await (async () => {
-    const m = new SourceTextModule('throw new Error();');
-    await m.link(common.mustNotCall());
-    m.instantiate();
-    const evaluatePromise = m.evaluate();
-    await evaluatePromise.catch(() => {});
-    assert.strictEqual(m.status, 'errored');
-    try {
-      await evaluatePromise;
-    } catch (err) {
-      assert.strictEqual(m.error, err);
-      return;
-    }
-    assert.fail('Missing expected exception');
-  })();
-}
-
-const finished = common.mustCall();
-
-(async function main() {
-  await checkArgType();
-  await checkModuleState();
-  await checkLinking();
-  await checkExecution();
-  finished();
-})();
diff --git a/test/parallel/test-vm-module-import-meta.js b/test/parallel/test-vm-module-import-meta.js
deleted file mode 100644
index 4886464f34..0000000000
--- a/test/parallel/test-vm-module-import-meta.js
+++ /dev/null
@@ -1,43 +0,0 @@
-'use strict';
-
-// Flags: --experimental-vm-modules
-
-const common = require('../common');
-const assert = require('assert');
-const { SourceTextModule } = require('vm');
-
-async function testBasic() {
-  const m = new SourceTextModule('import.meta;', {
-    initializeImportMeta: common.mustCall((meta, module) => {
-      assert.strictEqual(module, m);
-      meta.prop = 42;
-    })
-  });
-  await m.link(common.mustNotCall());
-  m.instantiate();
-  const { result } = await m.evaluate();
-  assert.strictEqual(typeof result, 'object');
-  assert.strictEqual(Object.getPrototypeOf(result), null);
-  assert.strictEqual(result.prop, 42);
-  assert.deepStrictEqual(Reflect.ownKeys(result), ['prop']);
-}
-
-async function testInvalid() {
-  for (const invalidValue of [
-    null, {}, 0, Symbol.iterator, [], 'string', false
-  ]) {
-    common.expectsError(() => {
-      new SourceTextModule('', {
-        initializeImportMeta: invalidValue
-      });
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
-  }
-}
-
-(async () => {
-  await testBasic();
-  await testInvalid();
-})();
diff --git a/test/parallel/test-vm-module-link.js b/test/parallel/test-vm-module-link.js
deleted file mode 100644
index 20518c4054..0000000000
--- a/test/parallel/test-vm-module-link.js
+++ /dev/null
@@ -1,136 +0,0 @@
-'use strict';
-
-// Flags: --experimental-vm-modules
-
-const common = require('../common');
-
-const assert = require('assert');
-const { URL } = require('url');
-
-const { SourceTextModule } = require('vm');
-
-async function simple() {
-  const foo = new SourceTextModule('export default 5;');
-  await foo.link(common.mustNotCall());
-
-  const bar = new SourceTextModule('import five from "foo"; five');
-
-  assert.deepStrictEqual(bar.dependencySpecifiers, ['foo']);
-
-  await bar.link(common.mustCall((specifier, module) => {
-    assert.strictEqual(module, bar);
-    assert.strictEqual(specifier, 'foo');
-    return foo;
-  }));
-
-  bar.instantiate();
-
-  assert.strictEqual((await bar.evaluate()).result, 5);
-}
-
-async function depth() {
-  const foo = new SourceTextModule('export default 5');
-  await foo.link(common.mustNotCall());
-
-  async function getProxy(parentName, parentModule) {
-    const mod = new SourceTextModule(`
-      import ${parentName} from '${parentName}';
-      export default ${parentName};
-    `);
-    await mod.link(common.mustCall((specifier, module) => {
-      assert.strictEqual(module, mod);
-      assert.strictEqual(specifier, parentName);
-      return parentModule;
-    }));
-    return mod;
-  }
-
-  const bar = await getProxy('foo', foo);
-  const baz = await getProxy('bar', bar);
-  const barz = await getProxy('baz', baz);
-
-  barz.instantiate();
-  await barz.evaluate();
-
-  assert.strictEqual(barz.namespace.default, 5);
-}
-
-async function circular() {
-  const foo = new SourceTextModule(`
-    import getFoo from 'bar';
-    export let foo = 42;
-    export default getFoo();
-  `);
-  const bar = new SourceTextModule(`
-    import { foo } from 'foo';
-    export default function getFoo() {
-      return foo;
-    }
-  `);
-  await foo.link(common.mustCall(async (fooSpecifier, fooModule) => {
-    assert.strictEqual(fooModule, foo);
-    assert.strictEqual(fooSpecifier, 'bar');
-    await bar.link(common.mustCall((barSpecifier, barModule) => {
-      assert.strictEqual(barModule, bar);
-      assert.strictEqual(barSpecifier, 'foo');
-      assert.strictEqual(foo.linkingStatus, 'linking');
-      return foo;
-    }));
-    assert.strictEqual(bar.linkingStatus, 'linked');
-    return bar;
-  }));
-
-  foo.instantiate();
-  await foo.evaluate();
-  assert.strictEqual(foo.namespace.default, 42);
-}
-
-async function circular2() {
-  const sourceMap = {
-    'root': `
-      import * as a from './a.mjs';
-      import * as b from './b.mjs';
-      if (!('fromA' in a))
-        throw new Error();
-      if (!('fromB' in a))
-        throw new Error();
-      if (!('fromA' in b))
-        throw new Error();
-      if (!('fromB' in b))
-        throw new Error();
-    `,
-    './a.mjs': `
-      export * from './b.mjs';
-      export var fromA;
-    `,
-    './b.mjs': `
-      export * from './a.mjs';
-      export var fromB;
-    `
-  };
-  const moduleMap = new Map();
-  const rootModule = new SourceTextModule(sourceMap.root, { url: 'vm:root' });
-  async function link(specifier, referencingModule) {
-    if (moduleMap.has(specifier)) {
-      return moduleMap.get(specifier);
-    }
-    const mod = new SourceTextModule(sourceMap[specifier], {
-      url: new URL(specifier, 'file:///').href,
-    });
-    moduleMap.set(specifier, mod);
-    return mod;
-  }
-  await rootModule.link(link);
-  rootModule.instantiate();
-  await rootModule.evaluate();
-}
-
-const finished = common.mustCall();
-
-(async function main() {
-  await simple();
-  await depth();
-  await circular();
-  await circular2();
-  finished();
-})();
diff --git a/test/parallel/test-vm-module-reevaluate.js b/test/parallel/test-vm-module-reevaluate.js
deleted file mode 100644
index c3914f362f..0000000000
--- a/test/parallel/test-vm-module-reevaluate.js
+++ /dev/null
@@ -1,48 +0,0 @@
-'use strict';
-
-// Flags: --experimental-vm-modules
-
-const common = require('../common');
-
-const assert = require('assert');
-
-const { SourceTextModule } = require('vm');
-
-const finished = common.mustCall();
-
-(async function main() {
-  {
-    const m = new SourceTextModule('1');
-    await m.link(common.mustNotCall());
-    m.instantiate();
-    assert.strictEqual((await m.evaluate()).result, 1);
-    assert.strictEqual((await m.evaluate()).result, undefined);
-    assert.strictEqual((await m.evaluate()).result, undefined);
-  }
-
-  {
-    const m = new SourceTextModule('throw new Error()');
-    await m.link(common.mustNotCall());
-    m.instantiate();
-
-    let threw = false;
-    try {
-      await m.evaluate();
-    } catch (err) {
-      assert(err instanceof Error);
-      threw = true;
-    }
-    assert(threw);
-
-    threw = false;
-    try {
-      await m.evaluate();
-    } catch (err) {
-      assert(err instanceof Error);
-      threw = true;
-    }
-    assert(threw);
-  }
-
-  finished();
-})();