bootstrap: include vm and contextify binding into the snapshot

lib/internal/bootstrap/node.js

@@ -361,6 +361,7 @@ process.emitWarning = emitWarning;
 // Preload modules so that they are included in the builtin snapshot.
 require('fs');
 require('v8');
+require('vm');
 
 function setupPrepareStackTrace() {
   const {

lib/internal/bootstrap/pre_execution.js

@@ -434,6 +434,16 @@ function initializeESMLoader() {
   // track of for different ESM modules.
   setInitializeImportMetaObjectCallback(esm.initializeImportMetaObject);
   setImportModuleDynamicallyCallback(esm.importModuleDynamicallyCallback);
+
+  if (getOptionValue('--experimental-vm-modules')) {
+    const {
+      Module, SourceTextModule, SyntheticModule,
+    } = require('internal/vm/module');
+    const vm = require('vm');
+    vm.Module = Module;
+    vm.SourceTextModule = SourceTextModule;
+    vm.SyntheticModule = SyntheticModule;
+  }
 }
 
 function initializeFrozenIntrinsics() {

lib/vm.js

@@ -426,12 +426,3 @@ module.exports = {
   compileFunction,
   measureMemory,
 };
-
-if (require('internal/options').getOptionValue('--experimental-vm-modules')) {
-  const {
-    Module, SourceTextModule, SyntheticModule,
-  } = require('internal/vm/module');
-  module.exports.Module = Module;
-  module.exports.SourceTextModule = SourceTextModule;
-  module.exports.SyntheticModule = SyntheticModule;
-}

src/node_contextify.cc

@@ -21,13 +21,14 @@
 
 #include "node_contextify.h"
 
-#include "memory_tracker-inl.h"
-#include "node_internals.h"
-#include "node_watchdog.h"
 #include "base_object-inl.h"
+#include "memory_tracker-inl.h"
+#include "module_wrap.h"
 #include "node_context_data.h"
 #include "node_errors.h"
-#include "module_wrap.h"
+#include "node_external_reference.h"
+#include "node_internals.h"
+#include "node_watchdog.h"
 #include "util-inl.h"
 
 namespace node {
@@ -255,6 +256,12 @@ void ContextifyContext::Init(Environment* env, Local<Object> target) {
   env->SetMethod(target, "compileFunction", CompileFunction);
 }
 
+void ContextifyContext::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(MakeContext);
+  registry->Register(IsContext);
+  registry->Register(CompileFunction);
+}
 
 // makeContext(sandbox, name, origin, strings, wasm);
 void ContextifyContext::MakeContext(const FunctionCallbackInfo<Value>& args) {
@@ -665,6 +672,14 @@ void ContextifyScript::Init(Environment* env, Local<Object> target) {
   env->set_script_context_constructor_template(script_tmpl);
 }
 
+void ContextifyScript::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(CreateCachedData);
+  registry->Register(RunInContext);
+  registry->Register(RunInThisContext);
+}
+
 void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
@@ -1293,6 +1308,10 @@ void MicrotaskQueueWrap::Init(Environment* env, Local<Object> target) {
   env->SetConstructorFunction(target, "MicrotaskQueue", tmpl);
 }
 
+void MicrotaskQueueWrap::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+}
 
 void Initialize(Local<Object> target,
                 Local<Value> unused,
@@ -1347,7 +1366,19 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "measureMemory", MeasureMemory);
 }
 
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  ContextifyContext::RegisterExternalReferences(registry);
+  ContextifyScript::RegisterExternalReferences(registry);
+  MicrotaskQueueWrap::RegisterExternalReferences(registry);
+
+  registry->Register(StartSigintWatchdog);
+  registry->Register(StopSigintWatchdog);
+  registry->Register(WatchdogHasPendingSigint);
+  registry->Register(MeasureMemory);
+}
 }  // namespace contextify
 }  // namespace node
 
 NODE_MODULE_CONTEXT_AWARE_INTERNAL(contextify, node::contextify::Initialize)
+NODE_MODULE_EXTERNAL_REFERENCE(contextify,
+                               node::contextify::RegisterExternalReferences)

src/node_contextify.h

@@ -8,6 +8,8 @@
 #include "node_errors.h"
 
 namespace node {
+class ExternalReferenceRegistry;
+
 namespace contextify {
 
 class MicrotaskQueueWrap : public BaseObject {
@@ -17,6 +19,7 @@ class MicrotaskQueueWrap : public BaseObject {
   const std::shared_ptr<v8::MicrotaskQueue>& microtask_queue() const;
 
   static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // This could have methods for running the microtask queue, if we ever decide
@@ -52,6 +55,7 @@ class ContextifyContext {
                                               v8::Local<v8::Object> sandbox_obj,
                                               const ContextOptions& options);
   static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   static ContextifyContext* ContextFromContextifiedSandbox(
       Environment* env,
@@ -141,6 +145,7 @@ class ContextifyScript : public BaseObject {
   ~ContextifyScript() override;
 
   static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static bool InstanceOf(Environment* env, const v8::Local<v8::Value>& args);
   static void CreateCachedData(

src/node_external_reference.h

@@ -50,6 +50,7 @@ class ExternalReferenceRegistry {
   V(async_wrap)                                                                \
   V(binding)                                                                   \
   V(buffer)                                                                    \
+  V(contextify)                                                                \
   V(credentials)                                                               \
   V(env_var)                                                                   \
   V(errors)                                                                    \