module: bootstrap module loaders in shadow realm

lib/internal/bootstrap/realm.js

@@ -215,8 +215,8 @@ const internalBuiltinIds = builtinIds
   .filter((id) => StringPrototypeStartsWith(id, 'internal/') && id !== selfId);
 
 // When --expose-internals is on we'll add the internal builtin ids to these.
-const canBeRequiredByUsersList = new SafeSet(publicBuiltinIds);
-const canBeRequiredByUsersWithoutSchemeList =
+let canBeRequiredByUsersList = new SafeSet(publicBuiltinIds);
+let canBeRequiredByUsersWithoutSchemeList =
   new SafeSet(publicBuiltinIds.filter((id) => !schemelessBlockList.has(id)));
 
 /**
@@ -269,6 +269,12 @@ class BuiltinModule {
     }
   }
 
+  static setRealmAllowRequireByUsers(ids) {
+    canBeRequiredByUsersList = new SafeSet(ids.filter((id) => publicBuiltinIds.includes(id)));
+    canBeRequiredByUsersWithoutSchemeList =
+      new SafeSet(ids.filter((id) => !schemelessBlockList.has(id)));
+  }
+
   // To be called during pre-execution when --expose-internals is on.
   // Enables the user-land module loader to access internal modules.
   static exposeInternals() {

lib/internal/bootstrap/shadow_realm.js

@@ -0,0 +1,47 @@
+'use strict';
+
+// In ShadowRealm.
+
+const {
+  prepareShadowRealmExecution,
+} = require('internal/process/pre_execution');
+const {
+  BuiltinModule,
+} = require('internal/bootstrap/realm');
+const { setDefaultImportModuleDynamically } = require('internal/modules/esm/utils');
+
+BuiltinModule.setRealmAllowRequireByUsers([
+  'assert',
+  'assert/strict',
+  'buffer',
+  'console',
+  'constants',
+  'cypto',
+  'diagnostics_channel',
+  'events',
+  'module',
+  'path',
+  'path/posix',
+  'path/win32',
+  'readline',
+  'readline/promises',
+  'repl',
+  'stream',
+  'stream/consumers',
+  'stream/promises',
+  'stream/web',
+  'string_decoder',
+  'url',
+  'util',
+  'util/types',
+  'zlib',
+]);
+
+prepareShadowRealmExecution();
+
+// The handler for `ShadowRealm.prototype.importValue`.
+setDefaultImportModuleDynamically((specifier, assertions) => {
+  const { esmLoader } = require('internal/process/esm_loader');
+  // `parentUrl` is not set in the case of a ShadowRealm top-level import.
+  return esmLoader.import(specifier, undefined, assertions);
+});

lib/internal/main/worker_thread.js

@@ -136,7 +136,10 @@ port.on('message', (message) => {
     const isLoaderWorker =
       doEval === 'internal' &&
       filename === require('internal/modules/esm/utils').loaderWorkerId;
-    setupUserModules(isLoaderWorker);
+    setupUserModules({
+      __proto__: null,
+      isLoaderWorker,
+    });
 
     if (!hasStdin)
       process.stdin.push(null);

lib/internal/modules/esm/utils.js

@@ -26,6 +26,11 @@ const {
 } = internalBinding('module_wrap');
 const assert = require('internal/assert');
 
+let defaultImportModuleDynamically;
+function setDefaultImportModuleDynamically(importModuleDynamically) {
+  defaultImportModuleDynamically = importModuleDynamically;
+}
+
 let defaultConditions;
 function getDefaultConditions() {
   assert(defaultConditions !== undefined);
@@ -139,6 +144,9 @@ async function importModuleDynamicallyCallback(symbol, specifier, assertions) {
       return importModuleDynamically(specifier, callbackReferrer, assertions);
     }
   }
+  if (defaultImportModuleDynamically) {
+    return defaultImportModuleDynamically(specifier, assertions);
+  }
   throw new ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING();
 }
 
@@ -220,6 +228,7 @@ async function initializeHooks() {
 
 module.exports = {
   registerModule,
+  setDefaultImportModuleDynamically,
   initializeESM,
   initializeHooks,
   getDefaultConditions,

lib/internal/process/pre_execution.js

@@ -25,6 +25,7 @@ const {
   exposeLazyInterfaces,
   defineReplaceableLazyAttribute,
   setupCoverageHooks,
+  kEmptyObject,
 } = require('internal/util');
 
 const {
@@ -57,6 +58,18 @@ function prepareWorkerThreadExecution() {
   });
 }
 
+function prepareShadowRealmExecution() {
+  // Patch the process object with legacy properties and normalizations
+  // Do not expand argv1 as it is not available in ShadowRealm
+  patchProcessObject(false);
+  setupDebugEnv();
+
+  setupUserModules({
+    __proto__: null,
+    noPreloadModules: true,
+  });
+}
+
 function prepareExecution(options) {
   const { expandArgv1, initializeModules, isMainThread } = options;
 
@@ -132,12 +145,15 @@ function setupSymbolDisposePolyfill() {
   Symbol.asyncDispose ??= SymbolAsyncDispose;
 }
 
-function setupUserModules(isLoaderWorker = false) {
+function setupUserModules(options = kEmptyObject) {
+  const { isLoaderWorker = false, noPreloadModules = false } = options;
   initializeCJSLoader();
   initializeESMLoader(isLoaderWorker);
   const CJSLoader = require('internal/modules/cjs/loader');
   assert(!CJSLoader.hasLoadedAnyUserCJSModule);
-  loadPreloadModules();
+  if (!noPreloadModules) {
+    loadPreloadModules();
+  }
   // Need to be done after --require setup.
   initializeFrozenIntrinsics();
 }
@@ -666,5 +682,6 @@ module.exports = {
   setupUserModules,
   prepareMainThreadExecution,
   prepareWorkerThreadExecution,
+  prepareShadowRealmExecution,
   markBootstrapComplete,
 };

src/async_wrap.cc

@@ -373,6 +373,7 @@ void AsyncWrap::CreatePerContextProperties(Local<Object> target,
                                            Local<Context> context,
                                            void* priv) {
   Environment* env = Environment::GetCurrent(context);
+  Realm* realm = Realm::GetCurrent(context);
   Isolate* isolate = env->isolate();
   HandleScope scope(isolate);
 
@@ -446,13 +447,13 @@ void AsyncWrap::CreatePerContextProperties(Local<Object> target,
 
 #undef FORCE_SET_TARGET_FIELD
 
-  env->set_async_hooks_init_function(Local<Function>());
-  env->set_async_hooks_before_function(Local<Function>());
-  env->set_async_hooks_after_function(Local<Function>());
-  env->set_async_hooks_destroy_function(Local<Function>());
-  env->set_async_hooks_promise_resolve_function(Local<Function>());
-  env->set_async_hooks_callback_trampoline(Local<Function>());
-  env->set_async_hooks_binding(target);
+  realm->set_async_hooks_init_function(Local<Function>());
+  realm->set_async_hooks_before_function(Local<Function>());
+  realm->set_async_hooks_after_function(Local<Function>());
+  realm->set_async_hooks_destroy_function(Local<Function>());
+  realm->set_async_hooks_promise_resolve_function(Local<Function>());
+  realm->set_async_hooks_callback_trampoline(Local<Function>());
+  realm->set_async_hooks_binding(target);
 }
 
 void AsyncWrap::RegisterExternalReferences(

src/env-inl.h

@@ -99,6 +99,8 @@ inline AliasedFloat64Array& AsyncHooks::async_ids_stack() {
 }
 
 v8::Local<v8::Array> AsyncHooks::js_execution_async_resources() {
+  DCHECK_EQ(env()->isolate()->GetCurrentContext(),
+            env()->principal_realm()->context());
   if (UNLIKELY(js_execution_async_resources_.IsEmpty())) {
     js_execution_async_resources_.Reset(
         env()->isolate(), v8::Array::New(env()->isolate()));

src/env.cc

@@ -497,6 +497,7 @@ void IsolateData::CreateProperties() {
   binding::CreateInternalBindingTemplates(this);
 
   contextify::ContextifyContext::InitializeGlobalTemplates(this);
+  CreateEnvProxyTemplate(this);
 }
 
 IsolateData::IsolateData(Isolate* isolate,
@@ -1587,10 +1588,13 @@ void AsyncHooks::MemoryInfo(MemoryTracker* tracker) const {
 void AsyncHooks::grow_async_ids_stack() {
   async_ids_stack_.reserve(async_ids_stack_.Length() * 3);
 
-  env()->async_hooks_binding()->Set(
-      env()->context(),
-      env()->async_ids_stack_string(),
-      async_ids_stack_.GetJSArray()).Check();
+  env()
+      ->principal_realm()
+      ->async_hooks_binding()
+      ->Set(env()->context(),
+            env()->async_ids_stack_string(),
+            async_ids_stack_.GetJSArray())
+      .Check();
 }
 
 void AsyncHooks::FailWithCorruptedAsyncStack(double expected_async_id) {