src: share common code paths for SEA and embedder script

Since SEA is very similar in principle to embedding functionality,
it makes sense to share code paths where possible. This commit does
so and addresses a `TODO` while doing so.
It also adds a utility to directly run CJS code to the embedder
startup callback, which comes in handy for this purpose.
Finally, this commit is breaking because it aligns the behavior
of `require()`ing internal modules; previously, embedders could
use the `require` function that they received to do so.
(If this is not considered breaking because accessing internals
is not covered by the API, then this would need ABI compatibility
patches for becoming fully non-breaking.)
PR-URL: #46825
Reviewed-By: Darshan Sen <raisinten@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Minwoo Jung <nodecorelab@gmail.com>

Author: addaleax

lib/internal/main/embedding.js

@@ -0,0 +1,18 @@
+'use strict';
+const{
+ prepareMainThreadExecution,
+ markBootstrapComplete,
+}=require('internal/process/pre_execution');
+const{ isSea }=internalBinding('sea');
+const{ emitExperimentalWarning }=require('internal/util');
+const{ embedderRequire, embedderRunCjs }=require('internal/util/embedding');
+const{ getEmbedderEntryFunction }=internalBinding('mksnapshot');
+
+prepareMainThreadExecution(false,true);
+markBootstrapComplete();
+
+if(isSea()){
+emitExperimentalWarning('Single executable application');
+}
+
+returngetEmbedderEntryFunction()(embedderRequire,embedderRunCjs);

lib/internal/main/environment.js

@@ -119,16 +119,25 @@ function main() {
 const{
  prepareMainThreadExecution
 }=require('internal/process/pre_execution');
+constpath=require('path');
 
 letserializeMainFunction=getEmbedderEntryFunction();
 constserializeMainArgs=[requireForUserSnapshot];
 
 if(serializeMainFunction){// embedded case
 prepareMainThreadExecution(false,false);
+// TODO(addaleax): Make this `embedderRunCjs` once require('module')
+// is supported in snapshots.
+constfilename=process.execPath;
+constdirname=path.dirname(filename);
+functionminimalRunCjs(source){
+constfn=compileSerializeMain(filename,source);
+returnfn(requireForUserSnapshot,filename,dirname);
+}
+serializeMainArgs.push(minimalRunCjs);
 }else{
 prepareMainThreadExecution(true,false);
 constfile=process.argv[1];
-constpath=require('path');
 constfilename=path.resolve(file);
 constdirname=path.dirname(filename);
 constsource=readFileSync(file,'utf-8');

lib/internal/main/mksnapshot.js

@@ -0,0 +1,47 @@
+'use strict';
+const{codes: {ERR_UNKNOWN_BUILTIN_MODULE}}=require('internal/errors');
+const{ Module, wrapSafe }=require('internal/modules/cjs/loader');
+
+// This is roughly the same as:
+//
+// const mod = new Module(filename);
+// mod._compile(contents, filename);
+//
+// but the code has been duplicated because currently there is no way to set the
+// value of require.main to module.
+//
+// TODO(RaisinTen): Find a way to deduplicate this.
+
+functionembedderRunCjs(contents){
+constfilename=process.execPath;
+constcompiledWrapper=wrapSafe(filename,contents);
+
+constcustomModule=newModule(filename,null);
+customModule.filename=filename;
+customModule.paths=Module._nodeModulePaths(customModule.path);
+
+constcustomExports=customModule.exports;
+
+embedderRequire.main=customModule;
+
+constcustomFilename=customModule.filename;
+
+constcustomDirname=customModule.path;
+
+returncompiledWrapper(
+customExports,
+embedderRequire,
+customModule,
+customFilename,
+customDirname);
+}
+
+functionembedderRequire(path){
+if(!Module.isBuiltin(path)){
+thrownewERR_UNKNOWN_BUILTIN_MODULE(path);
+}
+
+returnrequire(path);
+}
+
+module.exports={ embedderRequire, embedderRunCjs };

lib/internal/main/single_executable_application.js

@@ -528,17 +528,15 @@ MaybeLocal<Value> LoadEnvironment(
 returnStartExecution(env, cb);
 }
 
-MaybeLocal<Value> LoadEnvironment(
- Environment* env,
-constchar* main_script_source_utf8) {
-CHECK_NOT_NULL(main_script_source_utf8);
+MaybeLocal<Value> LoadEnvironment(Environment* env,
+ std::string_view main_script_source_utf8) {
+CHECK_NOT_NULL(main_script_source_utf8.data());
 returnLoadEnvironment(
  env, [&](const StartExecutionCallbackInfo& info) -> MaybeLocal<Value> {
- std::string name = "embedder_main_" + std::to_string(env->thread_id());
- env->builtin_loader()->Add(name.c_str(), main_script_source_utf8);
- Realm* realm = env->principal_realm();
-
-return realm->ExecuteBootstrapper(name.c_str());
+ Local<Value> main_script =
+ToV8Value(env->context(), main_script_source_utf8).ToLocalChecked();
+return info.run_cjs->Call(
+ env->context(), Null(env->isolate()), 1, &main_script);
  });
 }
 

lib/internal/util/embedding.js

@@ -406,14 +406,12 @@ inline builtins::BuiltinLoader* Environment::builtin_loader() {
 return &builtin_loader_;
 }
 
-inlineconst StartExecutionCallback&
-Environment::embedder_mksnapshot_entry_point() const {
-return embedder_mksnapshot_entry_point_;
+inlineconst StartExecutionCallback& Environment::embedder_entry_point() const {
+return embedder_entry_point_;
 }
 
-inlinevoidEnvironment::set_embedder_mksnapshot_entry_point(
- StartExecutionCallback&& fn) {
- embedder_mksnapshot_entry_point_ = std::move(fn);
+inlinevoidEnvironment::set_embedder_entry_point(StartExecutionCallback&& fn) {
+ embedder_entry_point_ = std::move(fn);
 }
 
 inlinedoubleEnvironment::new_async_id() {

src/api/environment.cc

@@ -948,8 +948,8 @@ class Environment : public MemoryRetainer {
 
 #endif// HAVE_INSPECTOR
 
-inlineconst StartExecutionCallback& embedder_mksnapshot_entry_point() const;
-inlinevoidset_embedder_mksnapshot_entry_point(StartExecutionCallback&& fn);
+inlineconst StartExecutionCallback& embedder_entry_point() const;
+inlinevoidset_embedder_entry_point(StartExecutionCallback&& fn);
 
 inlinevoidset_process_exit_handler(
  std::function<void(Environment*, ExitCode)>&& handler);
@@ -1133,7 +1133,7 @@ class Environment : public MemoryRetainer {
  std::unique_ptr<Realm> principal_realm_ = nullptr;
 
  builtins::BuiltinLoader builtin_loader_;
- StartExecutionCallback embedder_mksnapshot_entry_point_;
+ StartExecutionCallback embedder_entry_point_;
 
 // Used by allocate_managed_buffer() and release_managed_buffer() to keep
 // track of the BackingStore for a given pointer.

src/env-inl.h

@@ -277,22 +277,17 @@ MaybeLocal<Value> StartExecution(Environment* env, StartExecutionCallback cb) {
 
 if (cb != nullptr) {
  EscapableHandleScope scope(env->isolate());
+// TODO(addaleax): pass the callback to the main script more directly,
+// e.g. by making StartExecution(env, builtin) parametrizable
+ env->set_embedder_entry_point(std::move(cb));
+auto reset_entry_point =
+OnScopeLeave([&]() { env->set_embedder_entry_point({}); });
 
-if (env->isolate_data()->options()->build_snapshot) {
-// TODO(addaleax): pass the callback to the main script more directly,
-// e.g. by making StartExecution(env, builtin) parametrizable
- env->set_embedder_mksnapshot_entry_point(std::move(cb));
-auto reset_entry_point =
-OnScopeLeave([&]() { env->set_embedder_mksnapshot_entry_point({}); });
+constchar* entry = env->isolate_data()->options()->build_snapshot
+ ? "internal/main/mksnapshot"
+ : "internal/main/embedding";
 
-returnStartExecution(env, "internal/main/mksnapshot");
- }
-
-if (StartExecution(env, "internal/main/environment").IsEmpty()) return {};
-return scope.EscapeMaybe(cb({
- env->process_object(),
- env->builtin_module_require(),
- }));
+return scope.EscapeMaybe(StartExecution(env, entry));
  }
 
 // TODO(joyeecheung): move these conditions into JS land and let the
@@ -312,18 +307,6 @@ MaybeLocal<Value> StartExecution(Environment* env, StartExecutionCallback cb) {
  first_argv = env->argv()[1];
  }
 
-#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
-if (sea::IsSingleExecutable()) {
-// TODO(addaleax): Find a way to reuse:
-//
-// LoadEnvironment(Environment*, const char*)
-//
-// instead and not add yet another main entry point here because this
-// already duplicates existing code.
-returnStartExecution(env, "internal/main/single_executable_application");
- }
-#endif
-
 if (first_argv == "inspect") {
 returnStartExecution(env, "internal/main/inspect");
  }

src/env.h

@@ -682,6 +682,7 @@ NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
 structStartExecutionCallbackInfo {
  v8::Local<v8::Object> process_object;
  v8::Local<v8::Function> native_require;
+ v8::Local<v8::Function> run_cjs;
 };
 
 using StartExecutionCallback =
@@ -691,8 +692,7 @@ NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment(
  Environment* env,
  StartExecutionCallback cb);
 NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment(
- Environment* env,
-constchar* main_script_source_utf8);
+ Environment* env, std::string_view main_script_source_utf8);
 NODE_EXTERNvoidFreeEnvironment(Environment* env);
 
 // Set a callback that is called when process.exit() is called from JS,