fixup! src: add initial support for ESM in embedder API

joyeecheung · joyeecheung · commit 03fcd4d0075e · 2026-01-30T23:56:02.000+01:00
diff --git a/src/api/environment.cc b/src/api/environment.cc
@@ -573,24 +573,22 @@ NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
 
 MaybeLocal<Value> LoadEnvironment(Environment* env,
                                   StartExecutionCallbackWithModule cb,
-                                  EmbedderPreloadCallback preload,
-                                  void* callback_data) {
+                                  EmbedderPreloadCallback preload) {
   env->InitializeLibuv();
   env->InitializeDiagnostics();
   if (preload) {
     env->set_embedder_preload(std::move(preload));
   }
   env->InitializeCompileCache();
 
-  return StartExecution(env, cb, callback_data);
+  return StartExecution(env, cb);
 }
 
 struct StartExecutionCallbackInfoWithModule::Impl {
   Environment* env = nullptr;
   Local<Object> process_object;
   Local<Function> native_require;
   Local<Function> run_module;
-  void* data = nullptr;
 };
 
 StartExecutionCallbackInfoWithModule::StartExecutionCallbackInfoWithModule()
@@ -606,6 +604,22 @@ StartExecutionCallbackInfoWithModule&
 StartExecutionCallbackInfoWithModule::operator=(
     StartExecutionCallbackInfoWithModule&&) = default;
 
+Environment* StartExecutionCallbackInfoWithModule::env() const {
+  return impl_->env;
+}
+
+Local<Object> StartExecutionCallbackInfoWithModule::process_object() const {
+  return impl_->process_object;
+}
+
+Local<Function> StartExecutionCallbackInfoWithModule::native_require() const {
+  return impl_->native_require;
+}
+
+Local<Function> StartExecutionCallbackInfoWithModule::run_module() const {
+  return impl_->run_module;
+}
+
 void StartExecutionCallbackInfoWithModule::set_env(Environment* env) {
   impl_->env = env;
 }
@@ -625,30 +639,6 @@ void StartExecutionCallbackInfoWithModule::set_run_module(
   impl_->run_module = run_module;
 }
 
-void StartExecutionCallbackInfoWithModule::set_data(void* data) {
-  impl_->data = data;
-}
-
-Environment* StartExecutionCallbackInfoWithModule::env() const {
-  return impl_->env;
-}
-
-Local<Object> StartExecutionCallbackInfoWithModule::process_object() const {
-  return impl_->process_object;
-}
-
-Local<Function> StartExecutionCallbackInfoWithModule::native_require() const {
-  return impl_->native_require;
-}
-
-Local<Function> StartExecutionCallbackInfoWithModule::run_module() const {
-  return impl_->run_module;
-}
-
-void* StartExecutionCallbackInfoWithModule::data() const {
-  return impl_->data;
-}
-
 struct ModuleData::Impl {
   std::string_view source;
   ModuleFormat format = ModuleFormat::kCommonJS;
@@ -687,46 +677,23 @@ std::string_view ModuleData::resource_name() const {
   return impl_->resource_name;
 }
 
-struct LegacyModuleData {
-  StartExecutionCallback cb;
-  void* callback_data;
-};
-
 MaybeLocal<Value> LoadEnvironment(Environment* env,
                                   StartExecutionCallback cb,
                                   EmbedderPreloadCallback preload) {
-  if (cb == nullptr) {
+  if (!cb) {
     return LoadEnvironment(
         env, StartExecutionCallbackWithModule{}, std::move(preload));
   }
 
   return LoadEnvironment(
       env,
-      [](const StartExecutionCallbackInfoWithModule& info)
+      [cb = std::move(cb)](const StartExecutionCallbackInfoWithModule& info)
           -> MaybeLocal<Value> {
-        const StartExecutionCallback* cb =
-            static_cast<const StartExecutionCallback*>(info.data());
         StartExecutionCallbackInfo legacy_info{
             info.process_object(), info.native_require(), info.run_module()};
-        return (*cb)(legacy_info);
+        return cb(legacy_info);
       },
-      nullptr,
-      &cb);
-}
-
-MaybeLocal<Value> RunModule(const StartExecutionCallbackInfoWithModule& info) {
-  const ModuleData* data = static_cast<const ModuleData*>(info.data());
-  Environment* env = info.env();
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
-  Local<Value> main_script =
-      ToV8Value(context, data->source()).ToLocalChecked();
-  Local<Value> format =
-      v8::Integer::New(isolate, static_cast<int>(data->format()));
-  Local<Value> resource_name =
-      ToV8Value(context, data->resource_name()).ToLocalChecked();
-  Local<Value> args[] = {main_script, format, resource_name};
-  return info.run_module()->Call(context, Null(isolate), arraysize(args), args);
+      std::move(preload));
 }
 
 MaybeLocal<Value> LoadEnvironment(Environment* env,
@@ -745,7 +712,23 @@ MaybeLocal<Value> LoadEnvironment(Environment* env,
   // It could be empty when it's used by SEA to load an empty script.
   CHECK_IMPLIES(data->source().size() > 0, data->source().data());
   return LoadEnvironment(
-      env, RunModule, std::move(preload), const_cast<ModuleData*>(data));
+      env,
+      [data](const StartExecutionCallbackInfoWithModule& info)
+          -> MaybeLocal<Value> {
+        Environment* env = info.env();
+        Local<Context> context = env->context();
+        Isolate* isolate = env->isolate();
+        Local<Value> main_script =
+            ToV8Value(context, data->source()).ToLocalChecked();
+        Local<Value> format =
+            v8::Integer::New(isolate, static_cast<int>(data->format()));
+        Local<Value> resource_name =
+            ToV8Value(context, data->resource_name()).ToLocalChecked();
+        Local<Value> args[] = {main_script, format, resource_name};
+        return info.run_module()->Call(
+            context, Null(isolate), arraysize(args), args);
+      },
+      std::move(preload));
 }
 
 Environment* GetCurrentEnvironment(Local<Context> context) {
diff --git a/src/node.cc b/src/node.cc
@@ -258,7 +258,7 @@ MaybeLocal<Value> StartExecution(Environment* env, const char* main_script_id) {
 // StartExecutionCallbackInfoWithModule. Currently the result is an array
 // containing [process, requireFunction, runModule].
 std::optional<StartExecutionCallbackInfoWithModule> CallbackInfoFromArray(
-    Environment* env, Local<Value> result, void* callback_data) {
+    Environment* env, Local<Value> result) {
   CHECK(result->IsArray());
   Local<Array> args = result.As<Array>();
   CHECK_EQ(args->Length(), 3);
@@ -277,13 +277,11 @@ std::optional<StartExecutionCallbackInfoWithModule> CallbackInfoFromArray(
   info.set_process_object(process_obj.As<Object>());
   info.set_native_require(require_fn.As<Function>());
   info.set_run_module(run_module.As<Function>());
-  info.set_data(callback_data);
   return info;
 }
 
 MaybeLocal<Value> StartExecution(Environment* env,
-                                 StartExecutionCallbackWithModule cb,
-                                 void* callback_data) {
+                                 StartExecutionCallbackWithModule cb) {
   InternalCallbackScope callback_scope(
       env,
       Object::New(env->isolate()),
@@ -292,7 +290,7 @@ MaybeLocal<Value> StartExecution(Environment* env,
 
   // Only snapshot builder or embedder applications set the
   // callback.
-  if (cb != nullptr) {
+  if (cb) {
     EscapableHandleScope scope(env->isolate());
 
     Local<Value> result;
@@ -306,9 +304,9 @@ MaybeLocal<Value> StartExecution(Environment* env,
       }
     }
 
-    auto info = CallbackInfoFromArray(env, result, callback_data);
+    auto info = CallbackInfoFromArray(env, result);
     if (!info.has_value()) {
-      MaybeLocal<Value>();
+      return MaybeLocal<Value>();
     }
 #if HAVE_INSPECTOR
     if (env->options()->debug_options().break_first_line) {
diff --git a/src/node.h b/src/node.h
@@ -736,14 +736,9 @@ enum class ModuleFormat : uint8_t {
 // The layout is opaque to allow future additions without breaking ABI.
 class NODE_EXTERN StartExecutionCallbackInfoWithModule {
  public:
+  StartExecutionCallbackInfoWithModule();
   ~StartExecutionCallbackInfoWithModule();
 
-  Environment* env() const;
-  v8::Local<v8::Object> process_object() const;
-  v8::Local<v8::Function> native_require() const;
-  v8::Local<v8::Function> run_module() const;
-  void* data() const;
-
   StartExecutionCallbackInfoWithModule(
       const StartExecutionCallbackInfoWithModule&) = delete;
   StartExecutionCallbackInfoWithModule& operator=(
@@ -752,12 +747,15 @@ class NODE_EXTERN StartExecutionCallbackInfoWithModule {
   StartExecutionCallbackInfoWithModule& operator=(
       StartExecutionCallbackInfoWithModule&&);
 
-  StartExecutionCallbackInfoWithModule();
+  Environment* env() const;
+  v8::Local<v8::Object> process_object() const;
+  v8::Local<v8::Function> native_require() const;
+  v8::Local<v8::Function> run_module() const;
+
   void set_env(Environment* env);
   void set_process_object(v8::Local<v8::Object> process_object);
   void set_native_require(v8::Local<v8::Function> native_require);
   void set_run_module(v8::Local<v8::Function> run_module);
-  void set_data(void* data);
 
  private:
   struct Impl;
@@ -796,8 +794,7 @@ NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment(
 NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment(
     Environment* env,
     StartExecutionCallbackWithModule cb,
-    EmbedderPreloadCallback preload = nullptr,
-    void* callback_data = nullptr);
+    EmbedderPreloadCallback preload = nullptr);
 
 NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment(
     Environment* env,
@@ -812,6 +809,11 @@ class NODE_EXTERN ModuleData {
   ModuleData();
   ~ModuleData();
 
+  ModuleData(const ModuleData&) = delete;
+  ModuleData& operator=(const ModuleData&) = delete;
+  ModuleData(ModuleData&&);
+  ModuleData& operator=(ModuleData&&);
+
   void set_source(std::string_view source);
   void set_format(ModuleFormat format);
   void set_resource_name(std::string_view name);
@@ -820,11 +822,6 @@ class NODE_EXTERN ModuleData {
   ModuleFormat format() const;
   std::string_view resource_name() const;
 
-  ModuleData(const ModuleData&) = delete;
-  ModuleData& operator=(const ModuleData&) = delete;
-  ModuleData(ModuleData&&);
-  ModuleData& operator=(ModuleData&&);
-
  private:
   struct Impl;
   std::unique_ptr<Impl> impl_;
diff --git a/src/node_internals.h b/src/node_internals.h
@@ -364,9 +364,7 @@ v8::Isolate* NewIsolate(v8::Isolate::CreateParams* params,
 // This overload automatically picks the right 'main_script_id' if no callback
 // was provided by the embedder.
 v8::MaybeLocal<v8::Value> StartExecution(
-    Environment* env,
-    StartExecutionCallbackWithModule cb = nullptr,
-    void* callback_data = nullptr);
+    Environment* env, StartExecutionCallbackWithModule cb = nullptr);
 v8::MaybeLocal<v8::Object> GetPerContextExports(
     v8::Local<v8::Context> context, IsolateData* isolate_data = nullptr);
 void MarkBootstrapComplete(const v8::FunctionCallbackInfo<v8::Value>& args);
