@@ -75,5 +75,5 @@ async function checkSyntax(source, filename) {
 return;
 }
 
-wrapSafe(filename, source);
+wrapSafe(filename, source, undefined, 'commonjs');
 }

@@ -1,15 +1,116 @@
 'use strict';
+
+// This main script is currently only run when LoadEnvironment()
+// is run with a non-null StartExecutionCallback or a UTF8
+// main script. Effectively there are two cases where this happens:
+// 1. It's a single-executable application *loading* a main script
+// bundled into the executable. This is currently done from
+// NodeMainInstance::Run().
+// 2. It's an embedder application and LoadEnvironment() is invoked
+// as described above.
+
 const {
 prepareMainThreadExecution,
 } = require('internal/process/pre_execution');
-const { isExperimentalSeaWarningNeeded } = internalBinding('sea');
+const { isExperimentalSeaWarningNeeded, isSea } = internalBinding('sea');
 const { emitExperimentalWarning } = require('internal/util');
-const { embedderRequire, embedderRunCjs } = require('internal/util/embedding');
+const { emitWarningSync } = require('internal/process/warning');
+const { BuiltinModule: { normalizeRequirableId } } = require('internal/bootstrap/realm');
+const { Module } = require('internal/modules/cjs/loader');
+const { compileFunctionForCJSLoader } = internalBinding('contextify');
+const { maybeCacheSourceMap } = require('internal/source_map/source_map_cache');
+
+const { codes: {
+ERR_UNKNOWN_BUILTIN_MODULE,
+} } = require('internal/errors');
 
+// Don't expand process.argv[1] because in a single-executable application or an
+// embedder application, the user main script isn't necessarily provided via the
+// command line (e.g. it could be provided via an API or bundled into the executable).
 prepareMainThreadExecution(false, true);
 
+const isLoadingSea = isSea();
 if (isExperimentalSeaWarningNeeded()) {
 emitExperimentalWarning('Single executable application');
 }
 
+// This is roughly the same as:
+//
+// const mod = new Module(filename);
+// mod._compile(content, 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.
+function embedderRunCjs(content) {
+// The filename of the module (used for CJS module lookup)
+// is always the same as the location of the executable itself
+// at the time of the loading (which means it changes depending
+// on where the executable is in the file system).
+const filename = process.execPath;
+const customModule = new Module(filename, null);
+
+const {
+function: compiledWrapper,
+cachedDataRejected,
+sourceMapURL,
+} = compileFunctionForCJSLoader(
+content,
+filename,
+isLoadingSea, // is_sea_main
+false, // should_detect_module, ESM should be supported differently for embedded code
+);
+// Cache the source map for the module if present.
+if (sourceMapURL) {
+maybeCacheSourceMap(
+filename,
+content,
+customModule,
+false, // isGeneratedSource
+undefined, // sourceURL, TODO(joyeecheung): should be extracted by V8
+sourceMapURL,
+);
+}
+
+// cachedDataRejected is only set if cache from SEA is used.
+if (cachedDataRejected !== false && isLoadingSea) {
+emitWarningSync('Code cache data rejected.');
+}
+
+// the module to make it look almost like a regular CJS module
+// instance.
+customModule.filename = process.execPath;
+customModule.paths = Module._nodeModulePaths(process.execPath);
+embedderRequire.main = customModule;
+
+return compiledWrapper(
+customModule.exports, // exports
+embedderRequire, // require
+customModule, // module
+process.execPath, // __filename
+customModule.path, // __dirname
+);
+}
+
+let warnedAboutBuiltins = false;
+
+function embedderRequire(id) {
+const normalizedId = normalizeRequirableId(id);
+if (!normalizedId) {
+if (isLoadingSea && !warnedAboutBuiltins) {
+emitWarningSync(
+'Currently the require() provided to the main script embedded into ' +
+'single-executable applications only supports loading built-in modules.\n' +
+'To load a module from disk after the single executable application is ' +
+'launched, use require("module").createRequire().\n' +
+'Support for bundled module loading or virtual file systems are under ' +
+'discussions in https://.com/nodejs/single-executable');
+warnedAboutBuiltins = true;
+}
+throw new ERR_UNKNOWN_BUILTIN_MODULE(id);
+}
+return require(normalizedId);
+}
+
 return [process, embedderRequire, embedderRunCjs];

@@ -1350,11 +1350,10 @@ function loadESMFromCJS(mod, filename) {
 * Wraps the given content in a script and runs it in a new context.
 * @param {string} filename The name of the file being loaded
 * @param {string} content The content of the file being loaded
-* @param {Module} cjsModuleInstance The CommonJS loader instance
-* @param {object} codeCache The SEA code cache
+* @param {Module|undefined} cjsModuleInstance The CommonJS loader instance
 * @param {'commonjs'|undefined} format Intended format of the module.
 */
-function wrapSafe(filename, content, cjsModuleInstance, codeCache, format) {
+function wrapSafe(filename, content, cjsModuleInstance, format) {
 assert(format !== 'module'); // ESM should be handled in loadESMFromCJS().
 const hostDefinedOptionId = vm_dynamic_import_default_internal;
 const importModuleDynamically = vm_dynamic_import_default_internal;
@@ -1385,16 +1384,8 @@ function wrapSafe(filename, content, cjsModuleInstance, codeCache, format) {
 };
 }
 
-const isMain = !!(cjsModuleInstance && cjsModuleInstance[kIsMainSymbol]);
 const shouldDetectModule = (format !== 'commonjs' && getOptionValue('--experimental-detect-module'));
-const result = compileFunctionForCJSLoader(content, filename, isMain, shouldDetectModule);
-
-// cachedDataRejected is only set for cache coming from SEA.
-if (codeCache &&
-result.cachedDataRejected !== false &&
-internalBinding('sea').isSea()) {
-process.emitWarning('Code cache data rejected.');
-}
+const result = compileFunctionForCJSLoader(content, filename, false /* is_sea_main */, shouldDetectModule);
 
 // Cache the source map for the module if present.
 if (result.sourceMapURL) {
@@ -1423,7 +1414,7 @@ Module.._compile = function(content, filename, format) {
 
 let compiledWrapper;
 if (format !== 'module') {
-const result = wrapSafe(filename, content, this, undefined, format);
+const result = wrapSafe(filename, content, this, format);
 compiledWrapper = result.function;
 if (result.canParseAsESM) {
 format = 'module';

@@ -176,7 +176,7 @@ translators.set('module', function moduleStrategy(url, source, isMain) {
 * @param {boolean} isMain - Whether the module is the entrypoint
 */
 function loadCJSModule(module, source, url, filename, isMain) {
-const compileResult = compileFunctionForCJSLoader(source, filename, isMain, false);
+const compileResult = compileFunctionForCJSLoader(source, filename, false /* is_sea_main */, false);
 
 const { function: compiledWrapper, sourceMapURL } = compileResult;
 // Cache the source map for the cjs module if present.

@@ -308,6 +308,14 @@ std::optional<StartExecutionCallbackInfo> CallbackInfoFromArray(
 CHECK(process_obj->IsObject());
 CHECK(require_fn->IsFunction());
 CHECK(runcjs_fn->IsFunction());
+// TODO(joyeecheung): some support for running ESM as an entrypoint
+// is needed. The simplest API would be to add a run_esm to
+// StartExecutionCallbackInfo which compiles, links (to builtins)
+// and evaluates a SourceTextModule.
+// TODO(joyeecheung): the env pointer should be part of
+// StartExecutionCallbackInfo, otherwise embedders are forced to use
+// lambdas to pass it into the callback, which can make the code
+// difficult to read.
 node::StartExecutionCallbackInfo info{process_obj.As<Object>(),
 require_fn.As<Function>(),
 runcjs_fn.As<Function>()};

@@ -1441,12 +1441,17 @@ static std::vector<std::string_view> throws_only_in_cjs_error_messages = {
 "await is only valid in async functions and "
 "the top level bodies of modules"};
 
-static MaybeLocal<Function> CompileFunctionForCJSLoader(Environment* env,
-Local<Context> context,
-Local<String> code,
-Local<String> filename,
-bool* cache_rejected,
-bool is_cjs_scope) {
+// If cached_data is provided, it would be used for the compilation and
+// the on-disk compilation cache from NODE_COMPILE_CACHE (if configured)
+// would be ignored.
+static MaybeLocal<Function> CompileFunctionForCJSLoader(
+Environment* env,
+Local<Context> context,
+Local<String> code,
+Local<String> filename,
+bool* cache_rejected,
+bool is_cjs_scope,
+ScriptCompiler::CachedData* cached_data) {
 Isolate* isolate = context->GetIsolate();
 EscapableHandleScope scope(isolate);
 
@@ -1464,20 +1469,7 @@ static MaybeLocal<Function> CompileFunctionForCJSLoader(Environment* env,
 false, // is WASM
 false, // is ES Module
 hdo);
-ScriptCompiler::CachedData* cached_data = nullptr;
 
-#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
-if (sea::IsSingleExecutable()) {
-sea::SeaResource sea = sea::FindSingleExecutableResource();
-if (sea.use_code_cache()) {
-std::string_view data = sea.code_cache.value();
-cached_data = new ScriptCompiler::CachedData(
-reinterpret_cast<const uint8_t*>(data.data()),
-static_cast<int>(data.size()),
-v8::ScriptCompiler::CachedData::BufferNotOwned);
-}
-}
-#endif
 ScriptCompiler::Source source(code, origin, cached_data);
 ScriptCompiler::CompileOptions options;
 if (cached_data == nullptr) {
@@ -1532,6 +1524,7 @@ static void CompileFunctionForCJSLoader(
 CHECK(args[3]->IsBoolean());
 Local<String> code = args[0].As<String>();
 Local<String> filename = args[1].As<String>();
+bool is_sea_main = args[2].As<Boolean>()->Value();
 bool should_detect_module = args[3].As<Boolean>()->Value();
 
 Isolate* isolate = args.GetIsolate();
@@ -1544,11 +1537,31 @@ static void CompileFunctionForCJSLoader(
 Local<Value> cjs_exception;
 Local<Message> cjs_message;
 
+ScriptCompiler::CachedData* cached_data = nullptr;
+#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
+if (is_sea_main) {
+sea::SeaResource sea = sea::FindSingleExecutableResource();
+// Use the "main" field in SEA config for the filename.
+Local<Value> filename_from_sea;
+if (!ToV8Value(context, sea.code_path).ToLocal(&filename_from_sea)) {
+return;
+}
+filename = filename_from_sea.As<String>();
+if (sea.use_code_cache()) {
+std::string_view data = sea.code_cache.value();
+cached_data = new ScriptCompiler::CachedData(
+reinterpret_cast<const uint8_t*>(data.data()),
+static_cast<int>(data.size()),
+v8::ScriptCompiler::CachedData::BufferNotOwned);
+}
+}
+#endif
+
 {
 ShouldNotAbortOnUncaughtScope no_abort_scope(realm->env());
 TryCatchScope try_catch(env);
 if (!CompileFunctionForCJSLoader(
-env, context, code, filename, &cache_rejected, true)
+env, context, code, filename, &cache_rejected, true, cached_data)
 .ToLocal(&fn)) {
 CHECK(try_catch.HasCaught());
 CHECK(!try_catch.HasTerminated());
@@ -1703,7 +1716,7 @@ static void ContainsModuleSyntax(const FunctionCallbackInfo<Value>& args) {
 TryCatchScope try_catch(env);
 ShouldNotAbortOnUncaughtScope no_abort_scope(env);
 if (CompileFunctionForCJSLoader(
-env, context, code, filename, &cache_rejected, cjs_var)
+env, context, code, filename, &cache_rejected, cjs_var, nullptr)
 .ToLocal(&fn)) {
 args.GetReturnValue().Set(false);
 return;

@@ -103,20 +103,7 @@ ExitCode NodeMainInstance::Run() {
 
 void NodeMainInstance::Run(ExitCode* exit_code, Environment* env) {
 if (*exit_code == ExitCode::kNoFailure) {
-bool runs_sea_code = false;
-#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
-if (sea::IsSingleExecutable()) {
-sea::SeaResource sea = sea::FindSingleExecutableResource();
-if (!sea.use_snapshot()) {
-runs_sea_code = true;
-std::string_view code = sea.main_code_or_snapshot;
-LoadEnvironment(env, code);
-}
-}
-#endif
-// Either there is already a snapshot main function from SEA, or it's not
-// a SEA at all.
-if (!runs_sea_code) {
+if (!sea::MaybeLoadSingleExecutableApplication(env)) {
 LoadEnvironment(env, StartExecutionCallback{});
 }