diff --git a/deps/v8/include/v8-message.h b/deps/v8/include/v8-message.h
index 09f9a0a97ddb64..a680ea5d1dfd79 100644
--- a/deps/v8/include/v8-message.h
+++ b/deps/v8/include/v8-message.h
@@ -61,6 +61,7 @@ class ScriptOriginOptions {
  */
 class V8_EXPORT ScriptOrigin {
  public:
+  V8_DEPRECATE_SOON("Use constructor without the isolate.")
   V8_INLINE ScriptOrigin(Isolate* isolate, Local<Value> resource_name,
                          int resource_line_offset = 0,
                          int resource_column_offset = 0,
@@ -70,17 +71,30 @@ class V8_EXPORT ScriptOrigin {
                          bool resource_is_opaque = false, bool is_wasm = false,
                          bool is_module = false,
                          Local<Data> host_defined_options = Local<Data>())
-      : v8_isolate_(isolate),
-        resource_name_(resource_name),
+      : resource_name_(resource_name),
         resource_line_offset_(resource_line_offset),
         resource_column_offset_(resource_column_offset),
         options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
                  is_module),
         script_id_(script_id),
         source_map_url_(source_map_url),
-        host_defined_options_(host_defined_options) {
-    VerifyHostDefinedOptions();
-  }
+        host_defined_options_(host_defined_options) {}
+
+  V8_INLINE explicit ScriptOrigin(
+      Local<Value> resource_name, int resource_line_offset = 0,
+      int resource_column_offset = 0,
+      bool resource_is_shared_cross_origin = false, int script_id = -1,
+      Local<Value> source_map_url = Local<Value>(),
+      bool resource_is_opaque = false, bool is_wasm = false,
+      bool is_module = false, Local<Data> host_defined_options = Local<Data>())
+      : resource_name_(resource_name),
+        resource_line_offset_(resource_line_offset),
+        resource_column_offset_(resource_column_offset),
+        options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
+                 is_module),
+        script_id_(script_id),
+        source_map_url_(source_map_url),
+        host_defined_options_(host_defined_options) {}
 
   V8_INLINE Local<Value> ResourceName() const;
   V8_INLINE int LineOffset() const;
@@ -91,8 +105,6 @@ class V8_EXPORT ScriptOrigin {
   V8_INLINE ScriptOriginOptions Options() const { return options_; }
 
  private:
-  void VerifyHostDefinedOptions() const;
-  Isolate* v8_isolate_;
   Local<Value> resource_name_;
   int resource_line_offset_;
   int resource_column_offset_;
diff --git a/deps/v8/samples/shell.cc b/deps/v8/samples/shell.cc
index 046ed1e4eb53b7..fce0d459c3d955 100644
--- a/deps/v8/samples/shell.cc
+++ b/deps/v8/samples/shell.cc
@@ -313,7 +313,7 @@ bool ExecuteString(v8::Isolate* isolate, v8::Local<v8::String> source,
                    bool report_exceptions) {
   v8::HandleScope handle_scope(isolate);
   v8::TryCatch try_catch(isolate);
-  v8::ScriptOrigin origin(isolate, name);
+  v8::ScriptOrigin origin(name);
   v8::Local<v8::Context> context(isolate->GetCurrentContext());
   v8::Local<v8::Script> script;
   if (!v8::Script::Compile(context, source, &origin).ToLocal(&script)) {
diff --git a/deps/v8/src/api/api.cc b/deps/v8/src/api/api.cc
index a4a4381614e1fd..b6d3e9f24140c9 100644
--- a/deps/v8/src/api/api.cc
+++ b/deps/v8/src/api/api.cc
@@ -179,17 +179,15 @@ static ScriptOrigin GetScriptOriginForScript(i::Isolate* i_isolate,
                                              i::Handle<i::Script> script) {
   i::Handle<i::Object> scriptName(script->GetNameOrSourceURL(), i_isolate);
   i::Handle<i::Object> source_map_url(script->source_mapping_url(), i_isolate);
-  i::Handle<i::Object> host_defined_options(script->host_defined_options(),
-                                            i_isolate);
+  i::Handle<i::Object> host_defined_options;
   ScriptOriginOptions options(script->origin_options());
   bool is_wasm = false;
 #if V8_ENABLE_WEBASSEMBLY
   is_wasm = script->type() == i::Script::TYPE_WASM;
 #endif  // V8_ENABLE_WEBASSEMBLY
   v8::ScriptOrigin origin(
-      reinterpret_cast<v8::Isolate*>(i_isolate), Utils::ToLocal(scriptName),
-      script->line_offset(), script->column_offset(),
-      options.IsSharedCrossOrigin(), script->id(),
+      Utils::ToLocal(scriptName), script->line_offset(),
+      script->column_offset(), options.IsSharedCrossOrigin(), script->id(),
       Utils::ToLocal(source_map_url), options.IsOpaque(), is_wasm,
       options.IsModule(), Utils::ToLocal(host_defined_options));
   return origin;
@@ -2142,11 +2140,10 @@ MaybeLocal<Value> Script::Run(Local<Context> context,
   }
 
   i::Handle<i::Object> receiver = i_isolate->global_proxy();
-  // TODO(cbruni, chromium:1244145): Remove once migrated to the context.
-  i::Handle<i::Object> options(
-      i::Script::cast(fun->shared().script()).host_defined_options(),
-      i_isolate);
   Local<Value> result;
+  i::Handle<i::Object> options = host_defined_options.IsEmpty()
+                                     ? i_isolate->factory()->empty_fixed_array()
+                                     : Utils::OpenHandle(*host_defined_options);
   has_pending_exception = !ToLocal<Value>(
       i::Execution::CallScript(i_isolate, fun, receiver, options), &result);
 
@@ -2500,18 +2497,16 @@ Module::GetStalledTopLevelAwaitMessage(Isolate* isolate) {
 
 namespace {
 
-i::ScriptDetails GetScriptDetails(
-    i::Isolate* i_isolate, Local<Value> resource_name, int resource_line_offset,
-    int resource_column_offset, Local<Value> source_map_url,
-    Local<Data> host_defined_options, ScriptOriginOptions origin_options) {
+i::ScriptDetails GetScriptDetails(i::Isolate* i_isolate,
+                                  Local<Value> resource_name,
+                                  int resource_line_offset,
+                                  int resource_column_offset,
+                                  Local<Value> source_map_url,
+                                  ScriptOriginOptions origin_options) {
   i::ScriptDetails script_details(Utils::OpenHandle(*(resource_name), true),
                                   origin_options);
   script_details.line_offset = resource_line_offset;
   script_details.column_offset = resource_column_offset;
-  script_details.host_defined_options =
-      host_defined_options.IsEmpty()
-          ? i_isolate->factory()->empty_fixed_array()
-          : Utils::OpenHandle(*(host_defined_options));
   if (!source_map_url.IsEmpty()) {
     script_details.source_map_url = Utils::OpenHandle(*(source_map_url));
   }
@@ -2536,7 +2531,7 @@ MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundInternal(
   i::ScriptDetails script_details = GetScriptDetails(
       i_isolate, source->resource_name, source->resource_line_offset,
       source->resource_column_offset, source->source_map_url,
-      source->host_defined_options, source->resource_options);
+      source->resource_options);
 
   i::MaybeHandle<i::SharedFunctionInfo> maybe_function_info;
   if (options == kConsumeCodeCache) {
@@ -2615,7 +2610,12 @@ MaybeLocal<Module> ScriptCompiler::CompileModule(
   if (!maybe.ToLocal(&unbound)) return MaybeLocal<Module>();
   i::Handle<i::SharedFunctionInfo> shared = Utils::OpenHandle(*unbound);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
-  return ToApiHandle<Module>(i_isolate->factory()->NewSourceTextModule(shared));
+  i::Handle<i::Object> host_defined_options =
+      source->host_defined_options.IsEmpty()
+          ? i_isolate->factory()->empty_fixed_array()
+          : Utils::OpenHandle(*source->host_defined_options);
+  return ToApiHandle<Module>(
+      i_isolate->factory()->NewSourceTextModule(shared, host_defined_options));
 }
 
 // static
@@ -2690,7 +2690,7 @@ MaybeLocal<Function> ScriptCompiler::CompileFunctionInternal(
     i::ScriptDetails script_details = GetScriptDetails(
         i_isolate, source->resource_name, source->resource_line_offset,
         source->resource_column_offset, source->source_map_url,
-        source->host_defined_options, source->resource_options);
+        source->resource_options);
 
     std::unique_ptr<i::AlignedCachedData> cached_data;
     if (options == kConsumeCodeCache) {
@@ -2714,16 +2714,19 @@ MaybeLocal<Function> ScriptCompiler::CompileFunctionInternal(
   }
   // TODO(cbruni): remove script_or_module_out paramater
   if (script_or_module_out != nullptr) {
-    i::Handle<i::JSFunction> function =
-        i::Handle<i::JSFunction>::cast(Utils::OpenHandle(*result));
+    auto function = i::Handle<i::JSFunction>::cast(Utils::OpenHandle(*result));
     i::Isolate* i_isolate = function->GetIsolate();
     i::Handle<i::SharedFunctionInfo> shared(function->shared(), i_isolate);
     i::Handle<i::Script> script(i::Script::cast(shared->script()), i_isolate);
+    i::Handle<i::Object> host_defined_options =
+        source->host_defined_options.IsEmpty()
+            ? i_isolate->factory()->empty_fixed_array()
+            : Utils::OpenHandle(*source->host_defined_options);
     // TODO(cbruni, v8:12302): Avoid creating tempory ScriptOrModule objects.
     auto script_or_module = i::Handle<i::ScriptOrModule>::cast(
         i_isolate->factory()->NewStruct(i::SCRIPT_OR_MODULE_TYPE));
     script_or_module->set_resource_name(script->name());
-    script_or_module->set_host_defined_options(script->host_defined_options());
+    script_or_module->set_host_defined_options(*host_defined_options);
 #ifdef V8_SCRIPTORMODULE_LEGACY_LIFETIME
     i::Handle<i::ArrayList> list =
         i::handle(script->script_or_modules(), i_isolate);
@@ -2767,10 +2770,9 @@ void ScriptCompiler::ConsumeCodeCacheTask::SourceTextAvailable(
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   DCHECK_NO_SCRIPT_NO_EXCEPTION(i_isolate);
   i::Handle<i::String> str = Utils::OpenHandle(*(source_text));
-  i::ScriptDetails script_details =
-      GetScriptDetails(i_isolate, origin.ResourceName(), origin.LineOffset(),
-                       origin.ColumnOffset(), origin.SourceMapUrl(),
-                       origin.GetHostDefinedOptions(), origin.Options());
+  i::ScriptDetails script_details = GetScriptDetails(
+      i_isolate, origin.ResourceName(), origin.LineOffset(),
+      origin.ColumnOffset(), origin.SourceMapUrl(), origin.Options());
   impl_->SourceTextAvailable(i_isolate, str, script_details);
 }
 
@@ -2804,10 +2806,9 @@ i::MaybeHandle<i::SharedFunctionInfo> CompileStreamedSource(
     i::Isolate* i_isolate, ScriptCompiler::StreamedSource* v8_source,
     Local<String> full_source_string, const ScriptOrigin& origin) {
   i::Handle<i::String> str = Utils::OpenHandle(*(full_source_string));
-  i::ScriptDetails script_details =
-      GetScriptDetails(i_isolate, origin.ResourceName(), origin.LineOffset(),
-                       origin.ColumnOffset(), origin.SourceMapUrl(),
-                       origin.GetHostDefinedOptions(), origin.Options());
+  i::ScriptDetails script_details = GetScriptDetails(
+      i_isolate, origin.ResourceName(), origin.LineOffset(),
+      origin.ColumnOffset(), origin.SourceMapUrl(), origin.Options());
   i::ScriptStreamingData* data = v8_source->impl();
   return i::Compiler::GetSharedFunctionInfoForStreamedScript(
       i_isolate, str, script_details, data);
@@ -2849,8 +2850,13 @@ MaybeLocal<Module> ScriptCompiler::CompileModule(
   has_pending_exception = !maybe_sfi.ToHandle(&sfi);
   if (has_pending_exception) i_isolate->ReportPendingMessages();
   RETURN_ON_FAILED_EXECUTION(Module);
-  RETURN_ESCAPED(
-      ToApiHandle<Module>(i_isolate->factory()->NewSourceTextModule(sfi)));
+  // TODO(cleanup)
+  i::Handle<i::Object> options =
+      origin.GetHostDefinedOptions().IsEmpty()
+          ? i_isolate->factory()->empty_fixed_array()
+          : Utils::OpenHandle(*origin.GetHostDefinedOptions());
+  RETURN_ESCAPED(ToApiHandle<Module>(
+      i_isolate->factory()->NewSourceTextModule(sfi, options)));
 }
 
 uint32_t ScriptCompiler::CachedDataVersionTag() {
@@ -3061,21 +3067,6 @@ ScriptOrigin Message::GetScriptOrigin() const {
   return GetScriptOriginForScript(i_isolate, script);
 }
 
-void ScriptOrigin::VerifyHostDefinedOptions() const {
-  // TODO(cbruni, chromium:1244145): Remove checks once we allow arbitrary
-  // host-defined options.
-  USE(v8_isolate_);
-  if (host_defined_options_.IsEmpty()) return;
-  Utils::ApiCheck(host_defined_options_->IsFixedArray(), "ScriptOrigin()",
-                  "Host-defined options has to be a PrimitiveArray");
-  i::Handle<i::FixedArray> options =
-      Utils::OpenHandle(*host_defined_options_.As<FixedArray>());
-  for (int i = 0; i < options->length(); i++) {
-    Utils::ApiCheck(options->get(i).IsPrimitive(), "ScriptOrigin()",
-                    "PrimitiveArray can only contain primtive values");
-  }
-}
-
 v8::Local<Value> Message::GetScriptResourceName() const {
   DCHECK_NO_SCRIPT_NO_EXCEPTION(Utils::OpenHandle(this)->GetIsolate());
   return GetScriptOrigin().ResourceName();
@@ -5372,15 +5363,14 @@ Local<Value> Function::GetDebugName() const {
 
 ScriptOrigin Function::GetScriptOrigin() const {
   auto self = Utils::OpenHandle(this);
-  auto i_isolate = reinterpret_cast<v8::Isolate*>(self->GetIsolate());
-  if (!self->IsJSFunction()) return v8::ScriptOrigin(i_isolate, Local<Value>());
+  if (!self->IsJSFunction()) return v8::ScriptOrigin(Local<Value>());
   auto func = i::Handle<i::JSFunction>::cast(self);
   if (func->shared().script().IsScript()) {
     i::Handle<i::Script> script(i::Script::cast(func->shared().script()),
                                 func->GetIsolate());
     return GetScriptOriginForScript(func->GetIsolate(), script);
   }
-  return v8::ScriptOrigin(i_isolate, Local<Value>());
+  return v8::ScriptOrigin(Local<Value>());
 }
 
 const int Function::kLineOffsetNotFound = -1;
diff --git a/deps/v8/src/ast/scopes.cc b/deps/v8/src/ast/scopes.cc
index 8d52d0792bcfc1..df00187a0fd4d7 100644
--- a/deps/v8/src/ast/scopes.cc
+++ b/deps/v8/src/ast/scopes.cc
@@ -244,7 +244,6 @@ Scope::Scope(Zone* zone, ScopeType scope_type,
   already_resolved_ = true;
 #endif
   set_language_mode(scope_info->language_mode());
-  DCHECK_EQ(ContextHeaderLength(), num_heap_slots_);
   private_name_lookup_skips_outer_class_ =
       scope_info->PrivateNameLookupSkipsOuterClass();
   // We don't really need to use the preparsed scope data; this is just to
@@ -276,6 +275,8 @@ DeclarationScope::DeclarationScope(Zone* zone, ScopeType scope_type,
   if (scope_info->SloppyEvalCanExtendVars()) {
     DCHECK(!is_eval_scope());
     sloppy_eval_can_extend_vars_ = true;
+    has_context_extension_slot_ = HasContextExtensionSlot();
+    num_heap_slots_ = ContextHeaderLength();
   }
   if (scope_info->ClassScopeHasPrivateBrand()) {
     DCHECK(IsClassConstructor(function_kind()));
@@ -358,8 +359,11 @@ void Scope::SetDefaults() {
   is_debug_evaluate_scope_ = false;
 
   inner_scope_calls_eval_ = false;
+  inner_scope_calls_dynamic_import_ = false;
   force_context_allocation_for_parameters_ = false;
 
+  has_context_extension_slot_ = HasContextExtensionSlot();
+
   is_declaration_scope_ = false;
 
   private_name_lookup_skips_outer_class_ = false;
@@ -860,6 +864,9 @@ Scope* Scope::FinalizeBlockScope() {
   }
 
   if (inner_scope_calls_eval_) outer_scope()->inner_scope_calls_eval_ = true;
+  if (inner_scope_calls_dynamic_import_) {
+    outer_scope()->set_inner_scope_calls_dynamic_import();
+  }
 
   // No need to propagate sloppy_eval_can_extend_vars_, since if it was relevant
   // to this scope we would have had to bail out at the top.
@@ -899,12 +906,18 @@ void Scope::Snapshot::Reparent(DeclarationScope* new_parent) {
       if (inner_scope->inner_scope_calls_eval_) {
         new_parent->inner_scope_calls_eval_ = true;
       }
+      if (inner_scope->inner_scope_calls_dynamic_import_) {
+        new_parent->set_inner_scope_calls_dynamic_import();
+      }
       DCHECK_NE(inner_scope, new_parent);
     }
     inner_scope->outer_scope_ = new_parent;
     if (inner_scope->inner_scope_calls_eval_) {
       new_parent->inner_scope_calls_eval_ = true;
     }
+    if (inner_scope->inner_scope_calls_dynamic_import_) {
+      new_parent->set_inner_scope_calls_dynamic_import();
+    }
     new_parent->inner_scope_ = new_parent->sibling_;
     inner_scope->sibling_ = nullptr;
     // Reset the sibling rather than the inner_scope_ since we
@@ -1949,6 +1962,12 @@ void Scope::Print(int n) {
     Indent(n1, "// scope skips outer class for #-names\n");
   }
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
+  if (inner_scope_calls_dynamic_import_) {
+    Indent(n1, "// inner scope calls 'import'\n");
+  }
+  if (has_context_extension_slot_) {
+    Indent(n1, "// has context extension slot\n");
+  }
   if (is_declaration_scope()) {
     DeclarationScope* scope = AsDeclarationScope();
     if (scope->was_lazily_parsed()) Indent(n1, "// lazily parsed\n");
@@ -2596,6 +2615,7 @@ void Scope::AllocateVariablesRecursively() {
     // scope.
     bool must_have_context =
         scope->is_with_scope() || scope->is_module_scope() ||
+        scope->NeedsHostDefinedOptions() ||
 #if V8_ENABLE_WEBASSEMBLY
         scope->IsAsmModule() ||
 #endif  // V8_ENABLE_WEBASSEMBLY
@@ -2607,12 +2627,17 @@ void Scope::AllocateVariablesRecursively() {
 
     // If we didn't allocate any locals in the local context, then we only
     // need the minimal number of slots if we must have a context.
-    if (scope->num_heap_slots_ == scope->ContextHeaderLength() &&
-        !must_have_context) {
+    if (!must_have_context &&
+        scope->num_heap_slots() == scope->ContextHeaderLength()) {
       scope->num_heap_slots_ = 0;
     }
-
-    // Allocation done.
+    DCHECK_EQ(scope->has_context_extension_slot_,
+              scope->HasContextExtensionSlot());
+    DCHECK_IMPLIES(scope->has_context_extension_slot_, must_have_context);
+    DCHECK_IMPLIES(
+        scope->has_context_extension_slot_,
+        scope->num_heap_slots() >= Context::MIN_CONTEXT_EXTENDED_SLOTS);
+    DCHECK_IMPLIES(must_have_context, scope->num_heap_slots() > 0);
     DCHECK(scope->num_heap_slots_ == 0 ||
            scope->num_heap_slots_ >= scope->ContextHeaderLength());
     return Iteration::kDescend;
diff --git a/deps/v8/src/ast/scopes.h b/deps/v8/src/ast/scopes.h
index 32e16b80b261fb..31efe80f3bcc48 100644
--- a/deps/v8/src/ast/scopes.h
+++ b/deps/v8/src/ast/scopes.h
@@ -296,7 +296,9 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
   // eval call.
   inline void RecordEvalCall();
 
-  void RecordInnerScopeEvalCall() {
+  void RecordInnerScopeCallsEval() {
+    DisallowGarbageCollection no_gc;
+    if (inner_scope_calls_eval_) return;
     inner_scope_calls_eval_ = true;
     for (Scope* scope = outer_scope(); scope != nullptr;
          scope = scope->outer_scope()) {
@@ -305,6 +307,28 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
     }
   }
 
+  void RecordInnerScopeCallsDynamicImport() {
+    DisallowGarbageCollection no_gc;
+    if (inner_scope_calls_dynamic_import_) return;
+    set_inner_scope_calls_dynamic_import();
+    for (Scope* scope = outer_scope(); scope != nullptr;
+         scope = scope->outer_scope()) {
+      if (scope->inner_scope_calls_dynamic_import_) return;
+      scope->set_inner_scope_calls_dynamic_import();
+    }
+  }
+
+  void set_inner_scope_calls_dynamic_import() {
+    if (inner_scope_calls_dynamic_import_) return;
+    inner_scope_calls_dynamic_import_ = true;
+    if (!has_context_extension_slot_) {
+      has_context_extension_slot_ = HasContextExtensionSlot();
+      DCHECK_EQ(num_heap_slots_, Context::MIN_CONTEXT_SLOTS);
+      num_heap_slots_ = ContextHeaderLength();
+    }
+    DCHECK_GE(num_heap_slots_, ContextHeaderLength());
+  }
+
   // Set the language mode flag (unless disabled by a global flag).
   void SetLanguageMode(LanguageMode language_mode) {
     DCHECK(!is_module_scope() || is_strict(language_mode));
@@ -396,6 +420,9 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
   }
 
   bool inner_scope_calls_eval() const { return inner_scope_calls_eval_; }
+  bool inner_scope_calls_dynamic_import() const {
+    return inner_scope_calls_dynamic_import_;
+  }
   bool private_name_lookup_skips_outer_class() const {
     return private_name_lookup_skips_outer_class_;
   }
@@ -429,6 +456,9 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
     DCHECK_IMPLIES(is_catch_scope(), num_heap_slots() > 0);
     DCHECK_IMPLIES(is_with_scope(), num_heap_slots() > 0);
     DCHECK_IMPLIES(ForceContextForLanguageMode(), num_heap_slots() > 0);
+    DCHECK_IMPLIES(HasContextExtensionSlot(), has_context_extension_slot_);
+    DCHECK_IMPLIES(has_context_extension_slot_,
+                   num_heap_slots() >= Context::MIN_CONTEXT_EXTENDED_SLOTS);
     return num_heap_slots() > 0;
   }
 
@@ -502,21 +532,30 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
   int num_stack_slots() const { return num_stack_slots_; }
   int num_heap_slots() const { return num_heap_slots_; }
 
+  bool NeedsHostDefinedOptions() const {
+    // For dynamic imports we need to provide host-defined options.
+    return inner_scope_calls_dynamic_import_;
+  }
+
   bool HasContextExtensionSlot() const {
     switch (scope_type_) {
       case MODULE_SCOPE:
       case WITH_SCOPE:  // DebugEvaluateContext as well
         return true;
-      default:
-        DCHECK_IMPLIES(sloppy_eval_can_extend_vars_,
-                       scope_type_ == FUNCTION_SCOPE ||
-                           scope_type_ == EVAL_SCOPE ||
-                           scope_type_ == BLOCK_SCOPE);
+      case CATCH_SCOPE:
+      case CLASS_SCOPE:
+        return false;
+      case SCRIPT_SCOPE:
+        return NeedsHostDefinedOptions();
+      case FUNCTION_SCOPE:
+      case EVAL_SCOPE:
+      case BLOCK_SCOPE:
         DCHECK_IMPLIES(sloppy_eval_can_extend_vars_, is_declaration_scope());
         return sloppy_eval_can_extend_vars_;
     }
     UNREACHABLE();
   }
+
   int ContextHeaderLength() const {
     return HasContextExtensionSlot() ? Context::MIN_CONTEXT_EXTENDED_SLOTS
                                      : Context::MIN_CONTEXT_SLOTS;
@@ -832,6 +871,11 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
 
   // True if one of the inner scopes or the scope itself calls eval.
   bool inner_scope_calls_eval_ : 1;
+  // True if the scope or any inner scope calls dynamic import.
+  bool inner_scope_calls_dynamic_import_ : 1;
+
+  bool has_context_extension_slot_ : 1;
+
   bool force_context_allocation_for_parameters_ : 1;
 
   // True if it holds 'var' declarations.
@@ -926,7 +970,10 @@ class V8_EXPORT_PRIVATE DeclarationScope : public Scope {
       //      isn't extendable anyway, or
       //   3. This is a debug evaluate and all bets are off.
       DeclarationScope* outer_decl_scope = outer_scope()->GetDeclarationScope();
-      while (outer_decl_scope->is_eval_scope()) {
+      while (outer_decl_scope->is_eval_scope() &&
+             !outer_decl_scope->is_declaration_scope()) {
+        DeclarationScope* next = outer_decl_scope->GetDeclarationScope();
+        DCHECK_NE(outer_decl_scope, next);
         outer_decl_scope = outer_decl_scope->GetDeclarationScope();
       }
       if (outer_decl_scope->is_debug_evaluate_scope()) {
@@ -942,7 +989,9 @@ class V8_EXPORT_PRIVATE DeclarationScope : public Scope {
     }
 
     sloppy_eval_can_extend_vars_ = true;
+    has_context_extension_slot_ = true;
     num_heap_slots_ = Context::MIN_CONTEXT_EXTENDED_SLOTS;
+    DCHECK(HasContextExtensionSlot());
   }
 
   bool sloppy_eval_can_extend_vars() const {
@@ -1368,7 +1417,7 @@ class V8_EXPORT_PRIVATE DeclarationScope : public Scope {
 void Scope::RecordEvalCall() {
   calls_eval_ = true;
   GetDeclarationScope()->RecordDeclarationScopeEvalCall();
-  RecordInnerScopeEvalCall();
+  RecordInnerScopeCallsEval();
   // The eval contents might access "super" (if it's inside a function that
   // binds super).
   DeclarationScope* receiver_scope = GetReceiverScope();
@@ -1385,9 +1434,11 @@ Scope::Snapshot::Snapshot(Scope* scope)
       top_unresolved_(scope->unresolved_list_.end()),
       top_local_(scope->GetClosureScope()->locals_.end()) {
   // Reset in order to record eval calls during this Snapshot's lifetime.
-  outer_scope_and_calls_eval_.GetPointer()->calls_eval_ = false;
-  outer_scope_and_calls_eval_.GetPointer()->sloppy_eval_can_extend_vars_ =
-      false;
+  Scope* outer_scope = outer_scope_and_calls_eval_.GetPointer();
+  outer_scope->calls_eval_ = false;
+  outer_scope->sloppy_eval_can_extend_vars_ = false;
+  outer_scope->has_context_extension_slot_ =
+      outer_scope->HasContextExtensionSlot();
 }
 
 class ModuleScope final : public DeclarationScope {
diff --git a/deps/v8/src/codegen/compiler.cc b/deps/v8/src/codegen/compiler.cc
index 5431deb83e743d..3da190ac19f8ee 100644
--- a/deps/v8/src/codegen/compiler.cc
+++ b/deps/v8/src/codegen/compiler.cc
@@ -1643,13 +1643,6 @@ void SetScriptFieldsFromDetails(Isolate* isolate, Script script,
       script.source_mapping_url(isolate).IsUndefined(isolate)) {
     script.set_source_mapping_url(*source_map_url);
   }
-  Handle<Object> host_defined_options;
-  if (script_details.host_defined_options.ToHandle(&host_defined_options)) {
-    // TODO(cbruni, chromium:1244145): Remove once migrated to the context.
-    if (host_defined_options->IsFixedArray()) {
-      script.set_host_defined_options(FixedArray::cast(*host_defined_options));
-    }
-  }
 }
 
 #ifdef ENABLE_SLOW_DCHECKS
diff --git a/deps/v8/src/codegen/script-details.h b/deps/v8/src/codegen/script-details.h
index 5317ae989e1fb7..c55172af4614dc 100644
--- a/deps/v8/src/codegen/script-details.h
+++ b/deps/v8/src/codegen/script-details.h
@@ -29,7 +29,6 @@ struct ScriptDetails {
   int column_offset;
   MaybeHandle<Object> name_obj;
   MaybeHandle<Object> source_map_url;
-  MaybeHandle<Object> host_defined_options;
   REPLMode repl_mode;
   const ScriptOriginOptions origin_options;
 };
diff --git a/deps/v8/src/d8/d8.cc b/deps/v8/src/d8/d8.cc
index 37f7de888070ee..9efe0468ca92ad 100644
--- a/deps/v8/src/d8/d8.cc
+++ b/deps/v8/src/d8/d8.cc
@@ -762,8 +762,8 @@ ScriptOrigin CreateScriptOrigin(Isolate* isolate, Local<String> resource_name,
   options->Set(isolate, 0,
                v8::Uint32::New(isolate, kHostDefinedOptionsMagicConstant));
   options->Set(isolate, 1, resource_name);
-  return ScriptOrigin(isolate, resource_name, 0, 0, false, -1, Local<Value>(),
-                      false, false, type == v8::ScriptType::kModule, options);
+  return ScriptOrigin(resource_name, 0, 0, false, -1, Local<Value>(), false,
+                      false, type == v8::ScriptType::kModule, options);
 }
 
 bool IsValidHostDefinedOptions(Local<Context> context, Local<Data> options,
@@ -868,15 +868,7 @@ bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
       delete cached_data;
     }
     if (options.compile_only) return true;
-    if (options.compile_options == ScriptCompiler::kConsumeCodeCache) {
-      i::Handle<i::Script> i_script(
-          i::Script::cast(Utils::OpenHandle(*script)->shared().script()),
-          i_isolate);
-      // TODO(cbruni, chromium:1244145): remove once context-allocated.
-      i_script->set_host_defined_options(i::FixedArray::cast(
-          *Utils::OpenHandle(*(origin.GetHostDefinedOptions()))));
-    }
-    maybe_result = script->Run(realm);
+    maybe_result = script->Run(realm, origin.GetHostDefinedOptions());
     if (options.code_cache_options ==
         ShellOptions::CodeCacheOptions::kProduceCacheAfterExecute) {
       // Serialize and store it in memory for the next execution.
@@ -3161,7 +3153,7 @@ Local<String> Shell::Stringify(Isolate* isolate, Local<Value> value) {
     Local<String> source =
         String::NewFromUtf8(isolate, stringify_source_).ToLocalChecked();
     Local<String> name = String::NewFromUtf8Literal(isolate, "d8-stringify");
-    ScriptOrigin origin(isolate, name);
+    ScriptOrigin origin(name);
     Local<Script> script =
         Script::Compile(context, source, &origin).ToLocalChecked();
     stringify_function_.Reset(
diff --git a/deps/v8/src/debug/debug-evaluate.cc b/deps/v8/src/debug/debug-evaluate.cc
index 2813456b12636a..73d88f2796f2b2 100644
--- a/deps/v8/src/debug/debug-evaluate.cc
+++ b/deps/v8/src/debug/debug-evaluate.cc
@@ -75,9 +75,8 @@ MaybeHandle<Object> DebugEvaluate::Global(Isolate* isolate,
     isolate->debug()->StartSideEffectCheckMode();
   }
   // TODO(cbruni, 1244145): Use host-defined options from script context.
-  Handle<FixedArray> host_defined_options(
-      Script::cast(function->shared().script()).host_defined_options(),
-      isolate);
+  Handle<Object> host_defined_options(
+      function->context().host_defined_options(), isolate);
   MaybeHandle<Object> result = Execution::CallScript(
       isolate, function, Handle<JSObject>(context->global_proxy(), isolate),
       host_defined_options);
diff --git a/deps/v8/src/debug/debug-evaluate.cc.orig b/deps/v8/src/debug/debug-evaluate.cc.orig
new file mode 100644
index 00000000000000..2813456b12636a
--- /dev/null
+++ b/deps/v8/src/debug/debug-evaluate.cc.orig
@@ -0,0 +1,1285 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/debug/debug-evaluate.h"
+
+#include "src/builtins/accessors.h"
+#include "src/codegen/assembler-inl.h"
+#include "src/codegen/compiler.h"
+#include "src/codegen/reloc-info.h"
+#include "src/codegen/script-details.h"
+#include "src/common/globals.h"
+#include "src/debug/debug-frames.h"
+#include "src/debug/debug-scopes.h"
+#include "src/debug/debug.h"
+#include "src/execution/frames-inl.h"
+#include "src/execution/isolate-inl.h"
+#include "src/interpreter/bytecode-array-iterator.h"
+#include "src/interpreter/bytecodes.h"
+#include "src/objects/code-inl.h"
+#include "src/objects/contexts.h"
+#include "src/objects/string-set-inl.h"
+
+#if V8_ENABLE_WEBASSEMBLY
+#include "src/debug/debug-wasm-objects.h"
+#endif  // V8_ENABLE_WEBASSEMBLY
+
+namespace v8 {
+namespace internal {
+
+namespace {
+static MaybeHandle<SharedFunctionInfo> GetFunctionInfo(Isolate* isolate,
+                                                       Handle<String> source,
+                                                       REPLMode repl_mode) {
+  ScriptDetails script_details(isolate->factory()->empty_string(),
+                               ScriptOriginOptions(true, true));
+  script_details.repl_mode = repl_mode;
+  return Compiler::GetSharedFunctionInfoForScript(
+      isolate, source, script_details, ScriptCompiler::kNoCompileOptions,
+      ScriptCompiler::kNoCacheNoReason, NOT_NATIVES_CODE);
+}
+}  // namespace
+
+MaybeHandle<Object> DebugEvaluate::Global(Isolate* isolate,
+                                          Handle<String> source,
+                                          debug::EvaluateGlobalMode mode,
+                                          REPLMode repl_mode) {
+  Handle<SharedFunctionInfo> shared_info;
+  if (!GetFunctionInfo(isolate, source, repl_mode).ToHandle(&shared_info)) {
+    return MaybeHandle<Object>();
+  }
+
+  Handle<NativeContext> context = isolate->native_context();
+  Handle<JSFunction> fun =
+      Factory::JSFunctionBuilder{isolate, shared_info, context}.Build();
+
+  return Global(isolate, fun, mode, repl_mode);
+}
+
+MaybeHandle<Object> DebugEvaluate::Global(Isolate* isolate,
+                                          Handle<JSFunction> function,
+                                          debug::EvaluateGlobalMode mode,
+                                          REPLMode repl_mode) {
+  // Disable breaks in side-effect free mode.
+  DisableBreak disable_break_scope(
+      isolate->debug(),
+      mode == debug::EvaluateGlobalMode::kDisableBreaks ||
+          mode ==
+              debug::EvaluateGlobalMode::kDisableBreaksAndThrowOnSideEffect);
+
+  Handle<NativeContext> context = isolate->native_context();
+  CHECK_EQ(function->native_context(), *context);
+
+  if (mode == debug::EvaluateGlobalMode::kDisableBreaksAndThrowOnSideEffect) {
+    isolate->debug()->StartSideEffectCheckMode();
+  }
+  // TODO(cbruni, 1244145): Use host-defined options from script context.
+  Handle<FixedArray> host_defined_options(
+      Script::cast(function->shared().script()).host_defined_options(),
+      isolate);
+  MaybeHandle<Object> result = Execution::CallScript(
+      isolate, function, Handle<JSObject>(context->global_proxy(), isolate),
+      host_defined_options);
+  if (mode == debug::EvaluateGlobalMode::kDisableBreaksAndThrowOnSideEffect) {
+    isolate->debug()->StopSideEffectCheckMode();
+  }
+  return result;
+}
+
+MaybeHandle<Object> DebugEvaluate::Local(Isolate* isolate,
+                                         StackFrameId frame_id,
+                                         int inlined_jsframe_index,
+                                         Handle<String> source,
+                                         bool throw_on_side_effect) {
+  // Handle the processing of break.
+  DisableBreak disable_break_scope(isolate->debug());
+
+  // Get the frame where the debugging is performed.
+  StackTraceFrameIterator it(isolate, frame_id);
+#if V8_ENABLE_WEBASSEMBLY
+  if (it.is_wasm()) {
+    WasmFrame* frame = WasmFrame::cast(it.frame());
+    Handle<SharedFunctionInfo> outer_info(
+        isolate->native_context()->empty_function().shared(), isolate);
+    Handle<JSObject> context_extension = GetWasmDebugProxy(frame);
+    Handle<ScopeInfo> scope_info =
+        ScopeInfo::CreateForWithScope(isolate, Handle<ScopeInfo>::null());
+    Handle<Context> context = isolate->factory()->NewWithContext(
+        isolate->native_context(), scope_info, context_extension);
+    return Evaluate(isolate, outer_info, context, context_extension, source,
+                    throw_on_side_effect);
+  }
+#endif  // V8_ENABLE_WEBASSEMBLY
+
+  CHECK(it.is_javascript());
+  JavaScriptFrame* frame = it.javascript_frame();
+  // This is not a lot different than DebugEvaluate::Global, except that
+  // variables accessible by the function we are evaluating from are
+  // materialized and included on top of the native context. Changes to
+  // the materialized object are written back afterwards.
+  // Note that the native context is taken from the original context chain,
+  // which may not be the current native context of the isolate.
+  ContextBuilder context_builder(isolate, frame, inlined_jsframe_index);
+  if (isolate->has_pending_exception()) return {};
+
+  Handle<Context> context = context_builder.evaluation_context();
+  Handle<JSObject> receiver(context->global_proxy(), isolate);
+  MaybeHandle<Object> maybe_result =
+      Evaluate(isolate, context_builder.outer_info(), context, receiver, source,
+               throw_on_side_effect);
+  if (!maybe_result.is_null()) context_builder.UpdateValues();
+  return maybe_result;
+}
+
+MaybeHandle<Object> DebugEvaluate::WithTopmostArguments(Isolate* isolate,
+                                                        Handle<String> source) {
+  // Handle the processing of break.
+  DisableBreak disable_break_scope(isolate->debug());
+  Factory* factory = isolate->factory();
+  JavaScriptFrameIterator it(isolate);
+
+  // Get context and receiver.
+  Handle<Context> native_context(
+      Context::cast(it.frame()->context()).native_context(), isolate);
+
+  // Materialize arguments as property on an extension object.
+  Handle<JSObject> materialized = factory->NewSlowJSObjectWithNullProto();
+  Handle<String> arguments_str = factory->arguments_string();
+  JSObject::SetOwnPropertyIgnoreAttributes(
+      materialized, arguments_str,
+      Accessors::FunctionGetArguments(it.frame(), 0), NONE)
+      .Check();
+
+  // Materialize receiver.
+  Handle<Object> this_value(it.frame()->receiver(), isolate);
+  DCHECK_EQ(it.frame()->IsConstructor(), this_value->IsTheHole(isolate));
+  if (!this_value->IsTheHole(isolate)) {
+    Handle<String> this_str = factory->this_string();
+    JSObject::SetOwnPropertyIgnoreAttributes(materialized, this_str, this_value,
+                                             NONE)
+        .Check();
+  }
+
+  // Use extension object in a debug-evaluate scope.
+  Handle<ScopeInfo> scope_info =
+      ScopeInfo::CreateForWithScope(isolate, Handle<ScopeInfo>::null());
+  scope_info->SetIsDebugEvaluateScope();
+  Handle<Context> evaluation_context = factory->NewDebugEvaluateContext(
+      native_context, scope_info, materialized, Handle<Context>());
+  Handle<SharedFunctionInfo> outer_info(
+      native_context->empty_function().shared(), isolate);
+  Handle<JSObject> receiver(native_context->global_proxy(), isolate);
+  const bool throw_on_side_effect = false;
+  MaybeHandle<Object> maybe_result =
+      Evaluate(isolate, outer_info, evaluation_context, receiver, source,
+               throw_on_side_effect);
+  return maybe_result;
+}
+
+// Compile and evaluate source for the given context.
+MaybeHandle<Object> DebugEvaluate::Evaluate(
+    Isolate* isolate, Handle<SharedFunctionInfo> outer_info,
+    Handle<Context> context, Handle<Object> receiver, Handle<String> source,
+    bool throw_on_side_effect) {
+  Handle<JSFunction> eval_fun;
+  ASSIGN_RETURN_ON_EXCEPTION(
+      isolate, eval_fun,
+      Compiler::GetFunctionFromEval(
+          source, outer_info, context, LanguageMode::kSloppy,
+          NO_PARSE_RESTRICTION, kNoSourcePosition, kNoSourcePosition,
+          kNoSourcePosition, ParsingWhileDebugging::kYes),
+      Object);
+
+  Handle<Object> result;
+  bool success = false;
+  if (throw_on_side_effect) isolate->debug()->StartSideEffectCheckMode();
+  success = Execution::Call(isolate, eval_fun, receiver, 0, nullptr)
+                .ToHandle(&result);
+  if (throw_on_side_effect) isolate->debug()->StopSideEffectCheckMode();
+  if (!success) DCHECK(isolate->has_pending_exception());
+  return success ? result : MaybeHandle<Object>();
+}
+
+Handle<SharedFunctionInfo> DebugEvaluate::ContextBuilder::outer_info() const {
+  return handle(frame_inspector_.GetFunction()->shared(), isolate_);
+}
+
+DebugEvaluate::ContextBuilder::ContextBuilder(Isolate* isolate,
+                                              JavaScriptFrame* frame,
+                                              int inlined_jsframe_index)
+    : isolate_(isolate),
+      frame_inspector_(frame, inlined_jsframe_index, isolate),
+      scope_iterator_(isolate, &frame_inspector_,
+                      v8_flags.experimental_reuse_locals_blocklists
+                          ? ScopeIterator::ReparseStrategy::kScriptIfNeeded
+                          : ScopeIterator::ReparseStrategy::kScript) {
+  Handle<Context> outer_context(frame_inspector_.GetFunction()->context(),
+                                isolate);
+  evaluation_context_ = outer_context;
+  Factory* factory = isolate->factory();
+
+  if (scope_iterator_.Done()) return;
+
+  // To evaluate as if we were running eval at the point of the debug break,
+  // we reconstruct the context chain as follows:
+  //  - To make stack-allocated variables visible, we materialize them and
+  //    use a debug-evaluate context to wrap both the materialized object and
+  //    the original context.
+  //  - We also wrap all contexts on the chain between the original context
+  //    and the function context.
+  //  - Between the function scope and the native context, we only resolve
+  //    variable names that are guaranteed to not be shadowed by stack-allocated
+  //    variables. Contexts between the function context and the original
+  //    context have a blocklist attached to implement that.
+  // Context::Lookup has special handling for debug-evaluate contexts:
+  //  - Look up in the materialized stack variables.
+  //  - Check the blocklist to find out whether to abort further lookup.
+  //  - Look up in the original context.
+  for (; !scope_iterator_.Done(); scope_iterator_.Next()) {
+    ScopeIterator::ScopeType scope_type = scope_iterator_.Type();
+    if (scope_type == ScopeIterator::ScopeTypeScript) break;
+    ContextChainElement context_chain_element;
+    if (scope_iterator_.InInnerScope() &&
+        (scope_type == ScopeIterator::ScopeTypeLocal ||
+         scope_iterator_.DeclaresLocals(ScopeIterator::Mode::STACK))) {
+      context_chain_element.materialized_object =
+          scope_iterator_.ScopeObject(ScopeIterator::Mode::STACK);
+    }
+    if (scope_iterator_.HasContext()) {
+      context_chain_element.wrapped_context = scope_iterator_.CurrentContext();
+    }
+    if (v8_flags.experimental_reuse_locals_blocklists) {
+      // With the re-use experiment we only need `DebugEvaluateContexts` up
+      // to (and including) the paused function scope so the evaluated
+      // expression can access the materialized stack locals.
+      if (!scope_iterator_.InInnerScope()) break;
+    } else {
+      CHECK(!v8_flags.experimental_reuse_locals_blocklists);
+      if (!scope_iterator_.InInnerScope()) {
+        context_chain_element.blocklist = scope_iterator_.GetLocals();
+      }
+    }
+    context_chain_.push_back(context_chain_element);
+  }
+
+  Handle<ScopeInfo> scope_info =
+      evaluation_context_->IsNativeContext()
+          ? Handle<ScopeInfo>::null()
+          : handle(evaluation_context_->scope_info(), isolate);
+  for (auto rit = context_chain_.rbegin(); rit != context_chain_.rend();
+       rit++) {
+    ContextChainElement element = *rit;
+    scope_info = ScopeInfo::CreateForWithScope(isolate, scope_info);
+    scope_info->SetIsDebugEvaluateScope();
+
+    if (v8_flags.experimental_reuse_locals_blocklists) {
+      if (rit == context_chain_.rbegin()) {
+        // The DebugEvaluateContext we create for the closure scope is the only
+        // DebugEvaluateContext with a block list. This means we'll retrieve
+        // the existing block list from the paused function scope
+        // and also associate the temporary scope_info we create here with that
+        // blocklist.
+        Handle<ScopeInfo> function_scope_info = handle(
+            frame_inspector_.GetFunction()->shared().scope_info(), isolate_);
+        Handle<Object> block_list = handle(
+            isolate_->LocalsBlockListCacheGet(function_scope_info), isolate_);
+        CHECK(block_list->IsStringSet());
+        isolate_->LocalsBlockListCacheSet(scope_info, Handle<ScopeInfo>::null(),
+                                          Handle<StringSet>::cast(block_list));
+      }
+    } else if (!element.blocklist.is_null()) {
+      CHECK(!v8_flags.experimental_reuse_locals_blocklists);
+      scope_info = ScopeInfo::RecreateWithBlockList(isolate, scope_info,
+                                                    element.blocklist);
+    }
+
+    evaluation_context_ = factory->NewDebugEvaluateContext(
+        evaluation_context_, scope_info, element.materialized_object,
+        element.wrapped_context);
+  }
+}
+
+void DebugEvaluate::ContextBuilder::UpdateValues() {
+  scope_iterator_.Restart();
+  for (ContextChainElement& element : context_chain_) {
+    if (!element.materialized_object.is_null()) {
+      Handle<FixedArray> keys =
+          KeyAccumulator::GetKeys(isolate_, element.materialized_object,
+                                  KeyCollectionMode::kOwnOnly,
+                                  ENUMERABLE_STRINGS)
+              .ToHandleChecked();
+
+      for (int i = 0; i < keys->length(); i++) {
+        DCHECK(keys->get(i).IsString());
+        Handle<String> key(String::cast(keys->get(i)), isolate_);
+        Handle<Object> value = JSReceiver::GetDataProperty(
+            isolate_, element.materialized_object, key);
+        scope_iterator_.SetVariableValue(key, value);
+      }
+    }
+    scope_iterator_.Next();
+  }
+}
+
+// static
+bool DebugEvaluate::IsSideEffectFreeIntrinsic(Runtime::FunctionId id) {
+// Use macro to include only the non-inlined version of an intrinsic.
+#define INTRINSIC_ALLOWLIST(V)                \
+  /* Conversions */                           \
+  V(NumberToStringSlow)                       \
+  V(ToBigInt)                                 \
+  V(ToLength)                                 \
+  V(ToNumber)                                 \
+  V(ToObject)                                 \
+  V(ToString)                                 \
+  /* Type checks */                           \
+  V(IsArray)                                  \
+  V(IsFunction)                               \
+  V(IsJSProxy)                                \
+  V(IsJSReceiver)                             \
+  V(IsRegExp)                                 \
+  V(IsSmi)                                    \
+  /* Loads */                                 \
+  V(LoadLookupSlotForCall)                    \
+  V(GetProperty)                              \
+  /* Arrays */                                \
+  V(ArraySpeciesConstructor)                  \
+  V(HasFastPackedElements)                    \
+  V(NewArray)                                 \
+  V(NormalizeElements)                        \
+  V(TypedArrayGetBuffer)                      \
+  /* Errors */                                \
+  V(NewTypeError)                             \
+  V(ReThrow)                                  \
+  V(ThrowCalledNonCallable)                   \
+  V(ThrowInvalidStringLength)                 \
+  V(ThrowIteratorError)                       \
+  V(ThrowIteratorResultNotAnObject)           \
+  V(ThrowPatternAssignmentNonCoercible)       \
+  V(ThrowReferenceError)                      \
+  V(ThrowSymbolIteratorInvalid)               \
+  /* Strings */                               \
+  V(StringReplaceOneCharWithString)           \
+  V(StringSubstring)                          \
+  V(StringToNumber)                           \
+  /* BigInts */                               \
+  V(BigIntEqualToBigInt)                      \
+  V(BigIntToBoolean)                          \
+  V(BigIntToNumber)                           \
+  /* Literals */                              \
+  V(CreateArrayLiteral)                       \
+  V(CreateArrayLiteralWithoutAllocationSite)  \
+  V(CreateObjectLiteral)                      \
+  V(CreateObjectLiteralWithoutAllocationSite) \
+  V(CreateRegExpLiteral)                      \
+  V(DefineClass)                              \
+  /* Called from builtins */                  \
+  V(AllocateInYoungGeneration)                \
+  V(AllocateInOldGeneration)                  \
+  V(AllocateSeqOneByteString)                 \
+  V(AllocateSeqTwoByteString)                 \
+  V(ArrayIncludes_Slow)                       \
+  V(ArrayIndexOf)                             \
+  V(ArrayIsArray)                             \
+  V(GetFunctionName)                          \
+  V(GetOwnPropertyDescriptor)                 \
+  V(GlobalPrint)                              \
+  V(HasProperty)                              \
+  V(ObjectCreate)                             \
+  V(ObjectEntries)                            \
+  V(ObjectEntriesSkipFastPath)                \
+  V(ObjectHasOwnProperty)                     \
+  V(ObjectKeys)                               \
+  V(ObjectValues)                             \
+  V(ObjectValuesSkipFastPath)                 \
+  V(ObjectGetOwnPropertyNames)                \
+  V(ObjectGetOwnPropertyNamesTryFast)         \
+  V(ObjectIsExtensible)                       \
+  V(RegExpInitializeAndCompile)               \
+  V(StackGuard)                               \
+  V(StringAdd)                                \
+  V(StringCharCodeAt)                         \
+  V(StringEqual)                              \
+  V(StringParseFloat)                         \
+  V(StringParseInt)                           \
+  V(SymbolDescriptiveString)                  \
+  V(ThrowRangeError)                          \
+  V(ThrowTypeError)                           \
+  V(ToName)                                   \
+  V(TransitionElementsKind)                   \
+  /* Misc. */                                 \
+  V(Call)                                     \
+  V(CompleteInobjectSlackTrackingForMap)      \
+  V(HasInPrototypeChain)                      \
+  V(IncrementUseCounter)                      \
+  V(MaxSmi)                                   \
+  V(NewObject)                                \
+  V(StringMaxLength)                          \
+  V(StringToArray)                            \
+  V(AsyncFunctionEnter)                       \
+  V(AsyncFunctionResolve)                     \
+  /* Test */                                  \
+  V(GetOptimizationStatus)                    \
+  V(OptimizeFunctionOnNextCall)               \
+  V(OptimizeOsr)
+
+// Intrinsics with inline versions have to be allowlisted here a second time.
+#define INLINE_INTRINSIC_ALLOWLIST(V) \
+  V(AsyncFunctionEnter)               \
+  V(AsyncFunctionResolve)
+
+#define CASE(Name) case Runtime::k##Name:
+#define INLINE_CASE(Name) case Runtime::kInline##Name:
+  switch (id) {
+    INTRINSIC_ALLOWLIST(CASE)
+    INLINE_INTRINSIC_ALLOWLIST(INLINE_CASE)
+    return true;
+    default:
+      if (v8_flags.trace_side_effect_free_debug_evaluate) {
+        PrintF("[debug-evaluate] intrinsic %s may cause side effect.\n",
+               Runtime::FunctionForId(id)->name);
+      }
+      return false;
+  }
+
+#undef CASE
+#undef INLINE_CASE
+#undef INTRINSIC_ALLOWLIST
+#undef INLINE_INTRINSIC_ALLOWLIST
+}
+
+namespace {
+
+bool BytecodeHasNoSideEffect(interpreter::Bytecode bytecode) {
+  using interpreter::Bytecode;
+  using interpreter::Bytecodes;
+  if (Bytecodes::IsWithoutExternalSideEffects(bytecode)) return true;
+  if (Bytecodes::IsCallOrConstruct(bytecode)) return true;
+  if (Bytecodes::IsJumpIfToBoolean(bytecode)) return true;
+  if (Bytecodes::IsPrefixScalingBytecode(bytecode)) return true;
+  switch (bytecode) {
+    // Allowlist for bytecodes.
+    // Loads.
+    case Bytecode::kLdaLookupSlot:
+    case Bytecode::kLdaGlobal:
+    case Bytecode::kGetNamedProperty:
+    case Bytecode::kGetKeyedProperty:
+    case Bytecode::kLdaGlobalInsideTypeof:
+    case Bytecode::kLdaLookupSlotInsideTypeof:
+    case Bytecode::kGetIterator:
+    // Arithmetics.
+    case Bytecode::kAdd:
+    case Bytecode::kAddSmi:
+    case Bytecode::kSub:
+    case Bytecode::kSubSmi:
+    case Bytecode::kMul:
+    case Bytecode::kMulSmi:
+    case Bytecode::kDiv:
+    case Bytecode::kDivSmi:
+    case Bytecode::kMod:
+    case Bytecode::kModSmi:
+    case Bytecode::kExp:
+    case Bytecode::kExpSmi:
+    case Bytecode::kNegate:
+    case Bytecode::kBitwiseAnd:
+    case Bytecode::kBitwiseAndSmi:
+    case Bytecode::kBitwiseNot:
+    case Bytecode::kBitwiseOr:
+    case Bytecode::kBitwiseOrSmi:
+    case Bytecode::kBitwiseXor:
+    case Bytecode::kBitwiseXorSmi:
+    case Bytecode::kShiftLeft:
+    case Bytecode::kShiftLeftSmi:
+    case Bytecode::kShiftRight:
+    case Bytecode::kShiftRightSmi:
+    case Bytecode::kShiftRightLogical:
+    case Bytecode::kShiftRightLogicalSmi:
+    case Bytecode::kInc:
+    case Bytecode::kDec:
+    case Bytecode::kLogicalNot:
+    case Bytecode::kToBooleanLogicalNot:
+    case Bytecode::kTypeOf:
+    // Contexts.
+    case Bytecode::kCreateBlockContext:
+    case Bytecode::kCreateCatchContext:
+    case Bytecode::kCreateFunctionContext:
+    case Bytecode::kCreateEvalContext:
+    case Bytecode::kCreateWithContext:
+    // Literals.
+    case Bytecode::kCreateArrayLiteral:
+    case Bytecode::kCreateEmptyArrayLiteral:
+    case Bytecode::kCreateArrayFromIterable:
+    case Bytecode::kCreateObjectLiteral:
+    case Bytecode::kCreateEmptyObjectLiteral:
+    case Bytecode::kCreateRegExpLiteral:
+    // Allocations.
+    case Bytecode::kCreateClosure:
+    case Bytecode::kCreateUnmappedArguments:
+    case Bytecode::kCreateRestParameter:
+    // Comparisons.
+    case Bytecode::kTestEqual:
+    case Bytecode::kTestEqualStrict:
+    case Bytecode::kTestLessThan:
+    case Bytecode::kTestLessThanOrEqual:
+    case Bytecode::kTestGreaterThan:
+    case Bytecode::kTestGreaterThanOrEqual:
+    case Bytecode::kTestInstanceOf:
+    case Bytecode::kTestIn:
+    case Bytecode::kTestReferenceEqual:
+    case Bytecode::kTestUndetectable:
+    case Bytecode::kTestTypeOf:
+    case Bytecode::kTestUndefined:
+    case Bytecode::kTestNull:
+    // Conversions.
+    case Bytecode::kToObject:
+    case Bytecode::kToName:
+    case Bytecode::kToNumber:
+    case Bytecode::kToNumeric:
+    case Bytecode::kToString:
+    // Misc.
+    case Bytecode::kIncBlockCounter:  // Coverage counters.
+    case Bytecode::kForInEnumerate:
+    case Bytecode::kForInPrepare:
+    case Bytecode::kForInContinue:
+    case Bytecode::kForInNext:
+    case Bytecode::kForInStep:
+    case Bytecode::kJumpLoop:
+    case Bytecode::kThrow:
+    case Bytecode::kReThrow:
+    case Bytecode::kThrowReferenceErrorIfHole:
+    case Bytecode::kThrowSuperNotCalledIfHole:
+    case Bytecode::kThrowSuperAlreadyCalledIfNotHole:
+    case Bytecode::kIllegal:
+    case Bytecode::kCallJSRuntime:
+    case Bytecode::kReturn:
+    case Bytecode::kSetPendingMessage:
+      return true;
+    default:
+      return false;
+  }
+}
+
+DebugInfo::SideEffectState BuiltinGetSideEffectState(Builtin id) {
+  switch (id) {
+    // Allowlist for builtins.
+    // Object builtins.
+    case Builtin::kObjectConstructor:
+    case Builtin::kObjectCreate:
+    case Builtin::kObjectEntries:
+    case Builtin::kObjectGetOwnPropertyDescriptor:
+    case Builtin::kObjectGetOwnPropertyDescriptors:
+    case Builtin::kObjectGetOwnPropertyNames:
+    case Builtin::kObjectGetOwnPropertySymbols:
+    case Builtin::kObjectGetPrototypeOf:
+    case Builtin::kObjectHasOwn:
+    case Builtin::kObjectIs:
+    case Builtin::kObjectIsExtensible:
+    case Builtin::kObjectIsFrozen:
+    case Builtin::kObjectIsSealed:
+    case Builtin::kObjectKeys:
+    case Builtin::kObjectPrototypeValueOf:
+    case Builtin::kObjectValues:
+    case Builtin::kObjectPrototypeHasOwnProperty:
+    case Builtin::kObjectPrototypeIsPrototypeOf:
+    case Builtin::kObjectPrototypePropertyIsEnumerable:
+    case Builtin::kObjectPrototypeToString:
+    case Builtin::kObjectPrototypeToLocaleString:
+    // Array builtins.
+    case Builtin::kArrayIsArray:
+    case Builtin::kArrayConstructor:
+    case Builtin::kArrayIndexOf:
+    case Builtin::kArrayPrototypeValues:
+    case Builtin::kArrayIncludes:
+    case Builtin::kArrayPrototypeAt:
+    case Builtin::kArrayPrototypeConcat:
+    case Builtin::kArrayPrototypeEntries:
+    case Builtin::kArrayPrototypeFill:
+    case Builtin::kArrayPrototypeFind:
+    case Builtin::kArrayPrototypeFindIndex:
+    case Builtin::kArrayPrototypeFindLast:
+    case Builtin::kArrayPrototypeFindLastIndex:
+    case Builtin::kArrayPrototypeFlat:
+    case Builtin::kArrayPrototypeFlatMap:
+    case Builtin::kArrayPrototypeJoin:
+    case Builtin::kArrayPrototypeGroup:
+    case Builtin::kArrayPrototypeGroupToMap:
+    case Builtin::kArrayPrototypeKeys:
+    case Builtin::kArrayPrototypeLastIndexOf:
+    case Builtin::kArrayPrototypeSlice:
+    case Builtin::kArrayPrototypeToLocaleString:
+    case Builtin::kArrayPrototypeToString:
+    case Builtin::kArrayForEach:
+    case Builtin::kArrayEvery:
+    case Builtin::kArraySome:
+    case Builtin::kArrayConcat:
+    case Builtin::kArrayFilter:
+    case Builtin::kArrayMap:
+    case Builtin::kArrayReduce:
+    case Builtin::kArrayReduceRight:
+    // Trace builtins.
+    case Builtin::kIsTraceCategoryEnabled:
+    case Builtin::kTrace:
+    // TypedArray builtins.
+    case Builtin::kTypedArrayConstructor:
+    case Builtin::kTypedArrayOf:
+    case Builtin::kTypedArrayPrototypeAt:
+    case Builtin::kTypedArrayPrototypeBuffer:
+    case Builtin::kTypedArrayPrototypeByteLength:
+    case Builtin::kTypedArrayPrototypeByteOffset:
+    case Builtin::kTypedArrayPrototypeLength:
+    case Builtin::kTypedArrayPrototypeEntries:
+    case Builtin::kTypedArrayPrototypeKeys:
+    case Builtin::kTypedArrayPrototypeValues:
+    case Builtin::kTypedArrayPrototypeFind:
+    case Builtin::kTypedArrayPrototypeFindIndex:
+    case Builtin::kTypedArrayPrototypeFindLast:
+    case Builtin::kTypedArrayPrototypeFindLastIndex:
+    case Builtin::kTypedArrayPrototypeIncludes:
+    case Builtin::kTypedArrayPrototypeJoin:
+    case Builtin::kTypedArrayPrototypeIndexOf:
+    case Builtin::kTypedArrayPrototypeLastIndexOf:
+    case Builtin::kTypedArrayPrototypeSlice:
+    case Builtin::kTypedArrayPrototypeSubArray:
+    case Builtin::kTypedArrayPrototypeEvery:
+    case Builtin::kTypedArrayPrototypeSome:
+    case Builtin::kTypedArrayPrototypeToLocaleString:
+    case Builtin::kTypedArrayPrototypeFilter:
+    case Builtin::kTypedArrayPrototypeMap:
+    case Builtin::kTypedArrayPrototypeReduce:
+    case Builtin::kTypedArrayPrototypeReduceRight:
+    case Builtin::kTypedArrayPrototypeForEach:
+    // ArrayBuffer builtins.
+    case Builtin::kArrayBufferConstructor:
+    case Builtin::kArrayBufferPrototypeGetByteLength:
+    case Builtin::kArrayBufferIsView:
+    case Builtin::kArrayBufferPrototypeSlice:
+    case Builtin::kReturnReceiver:
+    // DataView builtins.
+    case Builtin::kDataViewConstructor:
+    case Builtin::kDataViewPrototypeGetBuffer:
+    case Builtin::kDataViewPrototypeGetByteLength:
+    case Builtin::kDataViewPrototypeGetByteOffset:
+    case Builtin::kDataViewPrototypeGetInt8:
+    case Builtin::kDataViewPrototypeGetUint8:
+    case Builtin::kDataViewPrototypeGetInt16:
+    case Builtin::kDataViewPrototypeGetUint16:
+    case Builtin::kDataViewPrototypeGetInt32:
+    case Builtin::kDataViewPrototypeGetUint32:
+    case Builtin::kDataViewPrototypeGetFloat32:
+    case Builtin::kDataViewPrototypeGetFloat64:
+    case Builtin::kDataViewPrototypeGetBigInt64:
+    case Builtin::kDataViewPrototypeGetBigUint64:
+    // Boolean bulitins.
+    case Builtin::kBooleanConstructor:
+    case Builtin::kBooleanPrototypeToString:
+    case Builtin::kBooleanPrototypeValueOf:
+    // Date builtins.
+    case Builtin::kDateConstructor:
+    case Builtin::kDateNow:
+    case Builtin::kDateParse:
+    case Builtin::kDatePrototypeGetDate:
+    case Builtin::kDatePrototypeGetDay:
+    case Builtin::kDatePrototypeGetFullYear:
+    case Builtin::kDatePrototypeGetHours:
+    case Builtin::kDatePrototypeGetMilliseconds:
+    case Builtin::kDatePrototypeGetMinutes:
+    case Builtin::kDatePrototypeGetMonth:
+    case Builtin::kDatePrototypeGetSeconds:
+    case Builtin::kDatePrototypeGetTime:
+    case Builtin::kDatePrototypeGetTimezoneOffset:
+    case Builtin::kDatePrototypeGetUTCDate:
+    case Builtin::kDatePrototypeGetUTCDay:
+    case Builtin::kDatePrototypeGetUTCFullYear:
+    case Builtin::kDatePrototypeGetUTCHours:
+    case Builtin::kDatePrototypeGetUTCMilliseconds:
+    case Builtin::kDatePrototypeGetUTCMinutes:
+    case Builtin::kDatePrototypeGetUTCMonth:
+    case Builtin::kDatePrototypeGetUTCSeconds:
+    case Builtin::kDatePrototypeGetYear:
+    case Builtin::kDatePrototypeToDateString:
+    case Builtin::kDatePrototypeToISOString:
+    case Builtin::kDatePrototypeToUTCString:
+    case Builtin::kDatePrototypeToString:
+#ifdef V8_INTL_SUPPORT
+    case Builtin::kDatePrototypeToLocaleString:
+    case Builtin::kDatePrototypeToLocaleDateString:
+    case Builtin::kDatePrototypeToLocaleTimeString:
+#endif
+    case Builtin::kDatePrototypeToTimeString:
+    case Builtin::kDatePrototypeToJson:
+    case Builtin::kDatePrototypeToPrimitive:
+    case Builtin::kDatePrototypeValueOf:
+    // Map builtins.
+    case Builtin::kMapConstructor:
+    case Builtin::kMapPrototypeForEach:
+    case Builtin::kMapPrototypeGet:
+    case Builtin::kMapPrototypeHas:
+    case Builtin::kMapPrototypeEntries:
+    case Builtin::kMapPrototypeGetSize:
+    case Builtin::kMapPrototypeKeys:
+    case Builtin::kMapPrototypeValues:
+    // WeakMap builtins.
+    case Builtin::kWeakMapConstructor:
+    case Builtin::kWeakMapGet:
+    case Builtin::kWeakMapPrototypeHas:
+    // Math builtins.
+    case Builtin::kMathAbs:
+    case Builtin::kMathAcos:
+    case Builtin::kMathAcosh:
+    case Builtin::kMathAsin:
+    case Builtin::kMathAsinh:
+    case Builtin::kMathAtan:
+    case Builtin::kMathAtanh:
+    case Builtin::kMathAtan2:
+    case Builtin::kMathCeil:
+    case Builtin::kMathCbrt:
+    case Builtin::kMathExpm1:
+    case Builtin::kMathClz32:
+    case Builtin::kMathCos:
+    case Builtin::kMathCosh:
+    case Builtin::kMathExp:
+    case Builtin::kMathFloor:
+    case Builtin::kMathFround:
+    case Builtin::kMathHypot:
+    case Builtin::kMathImul:
+    case Builtin::kMathLog:
+    case Builtin::kMathLog1p:
+    case Builtin::kMathLog2:
+    case Builtin::kMathLog10:
+    case Builtin::kMathMax:
+    case Builtin::kMathMin:
+    case Builtin::kMathPow:
+    case Builtin::kMathRound:
+    case Builtin::kMathSign:
+    case Builtin::kMathSin:
+    case Builtin::kMathSinh:
+    case Builtin::kMathSqrt:
+    case Builtin::kMathTan:
+    case Builtin::kMathTanh:
+    case Builtin::kMathTrunc:
+    // Number builtins.
+    case Builtin::kNumberConstructor:
+    case Builtin::kNumberIsFinite:
+    case Builtin::kNumberIsInteger:
+    case Builtin::kNumberIsNaN:
+    case Builtin::kNumberIsSafeInteger:
+    case Builtin::kNumberParseFloat:
+    case Builtin::kNumberParseInt:
+    case Builtin::kNumberPrototypeToExponential:
+    case Builtin::kNumberPrototypeToFixed:
+    case Builtin::kNumberPrototypeToPrecision:
+    case Builtin::kNumberPrototypeToString:
+    case Builtin::kNumberPrototypeToLocaleString:
+    case Builtin::kNumberPrototypeValueOf:
+    // BigInt builtins.
+    case Builtin::kBigIntConstructor:
+    case Builtin::kBigIntAsIntN:
+    case Builtin::kBigIntAsUintN:
+    case Builtin::kBigIntPrototypeToString:
+    case Builtin::kBigIntPrototypeValueOf:
+    // Set builtins.
+    case Builtin::kSetConstructor:
+    case Builtin::kSetPrototypeEntries:
+    case Builtin::kSetPrototypeForEach:
+    case Builtin::kSetPrototypeGetSize:
+    case Builtin::kSetPrototypeHas:
+    case Builtin::kSetPrototypeValues:
+    // WeakSet builtins.
+    case Builtin::kWeakSetConstructor:
+    case Builtin::kWeakSetPrototypeHas:
+    // String builtins. Strings are immutable.
+    case Builtin::kStringFromCharCode:
+    case Builtin::kStringFromCodePoint:
+    case Builtin::kStringConstructor:
+    case Builtin::kStringListFromIterable:
+    case Builtin::kStringPrototypeAnchor:
+    case Builtin::kStringPrototypeAt:
+    case Builtin::kStringPrototypeBig:
+    case Builtin::kStringPrototypeBlink:
+    case Builtin::kStringPrototypeBold:
+    case Builtin::kStringPrototypeCharAt:
+    case Builtin::kStringPrototypeCharCodeAt:
+    case Builtin::kStringPrototypeCodePointAt:
+    case Builtin::kStringPrototypeConcat:
+    case Builtin::kStringPrototypeEndsWith:
+    case Builtin::kStringPrototypeFixed:
+    case Builtin::kStringPrototypeFontcolor:
+    case Builtin::kStringPrototypeFontsize:
+    case Builtin::kStringPrototypeIncludes:
+    case Builtin::kStringPrototypeIndexOf:
+    case Builtin::kStringPrototypeItalics:
+    case Builtin::kStringPrototypeLastIndexOf:
+    case Builtin::kStringPrototypeLink:
+    case Builtin::kStringPrototypeMatchAll:
+    case Builtin::kStringPrototypePadEnd:
+    case Builtin::kStringPrototypePadStart:
+    case Builtin::kStringPrototypeRepeat:
+    case Builtin::kStringPrototypeSlice:
+    case Builtin::kStringPrototypeSmall:
+    case Builtin::kStringPrototypeStartsWith:
+    case Builtin::kStringSlowFlatten:
+    case Builtin::kStringPrototypeStrike:
+    case Builtin::kStringPrototypeSub:
+    case Builtin::kStringPrototypeSubstr:
+    case Builtin::kStringPrototypeSubstring:
+    case Builtin::kStringPrototypeSup:
+    case Builtin::kStringPrototypeToString:
+#ifndef V8_INTL_SUPPORT
+    case Builtin::kStringPrototypeToLowerCase:
+    case Builtin::kStringPrototypeToUpperCase:
+#endif
+    case Builtin::kStringPrototypeTrim:
+    case Builtin::kStringPrototypeTrimEnd:
+    case Builtin::kStringPrototypeTrimStart:
+    case Builtin::kStringPrototypeValueOf:
+    case Builtin::kStringToNumber:
+    case Builtin::kStringSubstring:
+    // Symbol builtins.
+    case Builtin::kSymbolConstructor:
+    case Builtin::kSymbolKeyFor:
+    case Builtin::kSymbolPrototypeToString:
+    case Builtin::kSymbolPrototypeValueOf:
+    case Builtin::kSymbolPrototypeToPrimitive:
+    // JSON builtins.
+    case Builtin::kJsonParse:
+    case Builtin::kJsonStringify:
+    // Global function builtins.
+    case Builtin::kGlobalDecodeURI:
+    case Builtin::kGlobalDecodeURIComponent:
+    case Builtin::kGlobalEncodeURI:
+    case Builtin::kGlobalEncodeURIComponent:
+    case Builtin::kGlobalEscape:
+    case Builtin::kGlobalUnescape:
+    case Builtin::kGlobalIsFinite:
+    case Builtin::kGlobalIsNaN:
+    // Function builtins.
+    case Builtin::kFunctionPrototypeToString:
+    case Builtin::kFunctionPrototypeBind:
+    case Builtin::kFastFunctionPrototypeBind:
+    case Builtin::kFunctionPrototypeCall:
+    case Builtin::kFunctionPrototypeApply:
+    // Error builtins.
+    case Builtin::kErrorConstructor:
+    // RegExp builtins.
+    case Builtin::kRegExpConstructor:
+    // Reflect builtins.
+    case Builtin::kReflectApply:
+    case Builtin::kReflectConstruct:
+    case Builtin::kReflectGetOwnPropertyDescriptor:
+    case Builtin::kReflectGetPrototypeOf:
+    case Builtin::kReflectHas:
+    case Builtin::kReflectIsExtensible:
+    case Builtin::kReflectOwnKeys:
+    // Internal.
+    case Builtin::kStrictPoisonPillThrower:
+    case Builtin::kAllocateInYoungGeneration:
+    case Builtin::kAllocateInOldGeneration:
+    case Builtin::kAllocateRegularInYoungGeneration:
+    case Builtin::kAllocateRegularInOldGeneration:
+    case Builtin::kConstructVarargs:
+    case Builtin::kConstructWithArrayLike:
+      return DebugInfo::kHasNoSideEffect;
+
+#ifdef V8_INTL_SUPPORT
+    // Intl builtins.
+    case Builtin::kIntlGetCanonicalLocales:
+    // Intl.Collator builtins.
+    case Builtin::kCollatorConstructor:
+    case Builtin::kCollatorInternalCompare:
+    case Builtin::kCollatorPrototypeCompare:
+    case Builtin::kCollatorPrototypeResolvedOptions:
+    case Builtin::kCollatorSupportedLocalesOf:
+    // Intl.DateTimeFormat builtins.
+    case Builtin::kDateTimeFormatConstructor:
+    case Builtin::kDateTimeFormatInternalFormat:
+    case Builtin::kDateTimeFormatPrototypeFormat:
+    case Builtin::kDateTimeFormatPrototypeFormatRange:
+    case Builtin::kDateTimeFormatPrototypeFormatRangeToParts:
+    case Builtin::kDateTimeFormatPrototypeFormatToParts:
+    case Builtin::kDateTimeFormatPrototypeResolvedOptions:
+    case Builtin::kDateTimeFormatSupportedLocalesOf:
+    // Intl.DisplayNames builtins.
+    case Builtin::kDisplayNamesConstructor:
+    case Builtin::kDisplayNamesPrototypeOf:
+    case Builtin::kDisplayNamesPrototypeResolvedOptions:
+    case Builtin::kDisplayNamesSupportedLocalesOf:
+    // Intl.ListFormat builtins.
+    case Builtin::kListFormatConstructor:
+    case Builtin::kListFormatPrototypeFormat:
+    case Builtin::kListFormatPrototypeFormatToParts:
+    case Builtin::kListFormatPrototypeResolvedOptions:
+    case Builtin::kListFormatSupportedLocalesOf:
+    // Intl.Locale builtins.
+    case Builtin::kLocaleConstructor:
+    case Builtin::kLocalePrototypeBaseName:
+    case Builtin::kLocalePrototypeCalendar:
+    case Builtin::kLocalePrototypeCalendars:
+    case Builtin::kLocalePrototypeCaseFirst:
+    case Builtin::kLocalePrototypeCollation:
+    case Builtin::kLocalePrototypeCollations:
+    case Builtin::kLocalePrototypeHourCycle:
+    case Builtin::kLocalePrototypeHourCycles:
+    case Builtin::kLocalePrototypeLanguage:
+    case Builtin::kLocalePrototypeMaximize:
+    case Builtin::kLocalePrototypeMinimize:
+    case Builtin::kLocalePrototypeNumeric:
+    case Builtin::kLocalePrototypeNumberingSystem:
+    case Builtin::kLocalePrototypeNumberingSystems:
+    case Builtin::kLocalePrototypeRegion:
+    case Builtin::kLocalePrototypeScript:
+    case Builtin::kLocalePrototypeTextInfo:
+    case Builtin::kLocalePrototypeTimeZones:
+    case Builtin::kLocalePrototypeToString:
+    case Builtin::kLocalePrototypeWeekInfo:
+    // Intl.NumberFormat builtins.
+    case Builtin::kNumberFormatConstructor:
+    case Builtin::kNumberFormatInternalFormatNumber:
+    case Builtin::kNumberFormatPrototypeFormatNumber:
+    case Builtin::kNumberFormatPrototypeFormatToParts:
+    case Builtin::kNumberFormatPrototypeResolvedOptions:
+    case Builtin::kNumberFormatSupportedLocalesOf:
+    // Intl.PluralRules builtins.
+    case Builtin::kPluralRulesConstructor:
+    case Builtin::kPluralRulesPrototypeResolvedOptions:
+    case Builtin::kPluralRulesPrototypeSelect:
+    case Builtin::kPluralRulesSupportedLocalesOf:
+    // Intl.RelativeTimeFormat builtins.
+    case Builtin::kRelativeTimeFormatConstructor:
+    case Builtin::kRelativeTimeFormatPrototypeFormat:
+    case Builtin::kRelativeTimeFormatPrototypeFormatToParts:
+    case Builtin::kRelativeTimeFormatPrototypeResolvedOptions:
+    case Builtin::kRelativeTimeFormatSupportedLocalesOf:
+      return DebugInfo::kHasNoSideEffect;
+#endif  // V8_INTL_SUPPORT
+
+    // Set builtins.
+    case Builtin::kSetIteratorPrototypeNext:
+    case Builtin::kSetPrototypeAdd:
+    case Builtin::kSetPrototypeClear:
+    case Builtin::kSetPrototypeDelete:
+    // Array builtins.
+    case Builtin::kArrayIteratorPrototypeNext:
+    case Builtin::kArrayPrototypePop:
+    case Builtin::kArrayPrototypePush:
+    case Builtin::kArrayPrototypeReverse:
+    case Builtin::kArrayPrototypeShift:
+    case Builtin::kArrayPrototypeUnshift:
+    case Builtin::kArrayPrototypeSort:
+    case Builtin::kArrayPrototypeSplice:
+    case Builtin::kArrayUnshift:
+    // Map builtins.
+    case Builtin::kMapIteratorPrototypeNext:
+    case Builtin::kMapPrototypeClear:
+    case Builtin::kMapPrototypeDelete:
+    case Builtin::kMapPrototypeSet:
+    // Date builtins.
+    case Builtin::kDatePrototypeSetDate:
+    case Builtin::kDatePrototypeSetFullYear:
+    case Builtin::kDatePrototypeSetHours:
+    case Builtin::kDatePrototypeSetMilliseconds:
+    case Builtin::kDatePrototypeSetMinutes:
+    case Builtin::kDatePrototypeSetMonth:
+    case Builtin::kDatePrototypeSetSeconds:
+    case Builtin::kDatePrototypeSetTime:
+    case Builtin::kDatePrototypeSetUTCDate:
+    case Builtin::kDatePrototypeSetUTCFullYear:
+    case Builtin::kDatePrototypeSetUTCHours:
+    case Builtin::kDatePrototypeSetUTCMilliseconds:
+    case Builtin::kDatePrototypeSetUTCMinutes:
+    case Builtin::kDatePrototypeSetUTCMonth:
+    case Builtin::kDatePrototypeSetUTCSeconds:
+    case Builtin::kDatePrototypeSetYear:
+    // RegExp builtins.
+    case Builtin::kRegExpPrototypeTest:
+    case Builtin::kRegExpPrototypeExec:
+    case Builtin::kRegExpPrototypeSplit:
+    case Builtin::kRegExpPrototypeFlagsGetter:
+    case Builtin::kRegExpPrototypeGlobalGetter:
+    case Builtin::kRegExpPrototypeHasIndicesGetter:
+    case Builtin::kRegExpPrototypeIgnoreCaseGetter:
+    case Builtin::kRegExpPrototypeMatchAll:
+    case Builtin::kRegExpPrototypeMultilineGetter:
+    case Builtin::kRegExpPrototypeDotAllGetter:
+    case Builtin::kRegExpPrototypeUnicodeGetter:
+    case Builtin::kRegExpPrototypeStickyGetter:
+      return DebugInfo::kRequiresRuntimeChecks;
+
+    default:
+      if (v8_flags.trace_side_effect_free_debug_evaluate) {
+        PrintF("[debug-evaluate] built-in %s may cause side effect.\n",
+               Builtins::name(id));
+      }
+      return DebugInfo::kHasSideEffects;
+  }
+}
+
+bool BytecodeRequiresRuntimeCheck(interpreter::Bytecode bytecode) {
+  using interpreter::Bytecode;
+  switch (bytecode) {
+    case Bytecode::kSetNamedProperty:
+    case Bytecode::kDefineNamedOwnProperty:
+    case Bytecode::kSetKeyedProperty:
+    case Bytecode::kStaInArrayLiteral:
+    case Bytecode::kDefineKeyedOwnPropertyInLiteral:
+    case Bytecode::kStaCurrentContextSlot:
+      return true;
+    default:
+      return interpreter::Bytecodes::IsCallRuntime(bytecode);
+  }
+}
+
+}  // anonymous namespace
+
+// static
+DebugInfo::SideEffectState DebugEvaluate::FunctionGetSideEffectState(
+    Isolate* isolate, Handle<SharedFunctionInfo> info) {
+  if (v8_flags.trace_side_effect_free_debug_evaluate) {
+    PrintF("[debug-evaluate] Checking function %s for side effect.\n",
+           info->DebugNameCStr().get());
+  }
+
+  DCHECK(info->is_compiled());
+  DCHECK(!info->needs_script_context());
+  if (info->HasBytecodeArray()) {
+    // Check bytecodes against allowlist.
+    Handle<BytecodeArray> bytecode_array(info->GetBytecodeArray(isolate),
+                                         isolate);
+    if (v8_flags.trace_side_effect_free_debug_evaluate) {
+      bytecode_array->Print();
+    }
+    bool requires_runtime_checks = false;
+    for (interpreter::BytecodeArrayIterator it(bytecode_array); !it.done();
+         it.Advance()) {
+      interpreter::Bytecode bytecode = it.current_bytecode();
+      if (BytecodeHasNoSideEffect(bytecode)) continue;
+      if (BytecodeRequiresRuntimeCheck(bytecode)) {
+        requires_runtime_checks = true;
+        continue;
+      }
+
+      if (v8_flags.trace_side_effect_free_debug_evaluate) {
+        PrintF("[debug-evaluate] bytecode %s may cause side effect.\n",
+               interpreter::Bytecodes::ToString(bytecode));
+      }
+
+      // Did not match allowlist.
+      return DebugInfo::kHasSideEffects;
+    }
+    return requires_runtime_checks ? DebugInfo::kRequiresRuntimeChecks
+                                   : DebugInfo::kHasNoSideEffect;
+  } else if (info->IsApiFunction()) {
+    if (info->GetCode().is_builtin()) {
+      return info->GetCode().builtin_id() == Builtin::kHandleApiCall
+                 ? DebugInfo::kHasNoSideEffect
+                 : DebugInfo::kHasSideEffects;
+    }
+  } else {
+    // Check built-ins against allowlist.
+    Builtin builtin =
+        info->HasBuiltinId() ? info->builtin_id() : Builtin::kNoBuiltinId;
+    if (!Builtins::IsBuiltinId(builtin)) return DebugInfo::kHasSideEffects;
+    DebugInfo::SideEffectState state = BuiltinGetSideEffectState(builtin);
+    return state;
+  }
+
+  return DebugInfo::kHasSideEffects;
+}
+
+#ifdef DEBUG
+static bool TransitivelyCalledBuiltinHasNoSideEffect(Builtin caller,
+                                                     Builtin callee) {
+  switch (callee) {
+      // Transitively called Builtins:
+    case Builtin::kAbort:
+    case Builtin::kAbortCSADcheck:
+    case Builtin::kAdaptorWithBuiltinExitFrame:
+    case Builtin::kArrayConstructorImpl:
+    case Builtin::kArrayEveryLoopContinuation:
+    case Builtin::kArrayFilterLoopContinuation:
+    case Builtin::kArrayFindIndexLoopContinuation:
+    case Builtin::kArrayFindLoopContinuation:
+    case Builtin::kArrayFindLastIndexLoopContinuation:
+    case Builtin::kArrayFindLastLoopContinuation:
+    case Builtin::kArrayForEachLoopContinuation:
+    case Builtin::kArrayIncludesHoleyDoubles:
+    case Builtin::kArrayIncludesPackedDoubles:
+    case Builtin::kArrayIncludesSmi:
+    case Builtin::kArrayIncludesSmiOrObject:
+    case Builtin::kArrayIndexOfHoleyDoubles:
+    case Builtin::kArrayIndexOfPackedDoubles:
+    case Builtin::kArrayIndexOfSmi:
+    case Builtin::kArrayIndexOfSmiOrObject:
+    case Builtin::kArrayMapLoopContinuation:
+    case Builtin::kArrayReduceLoopContinuation:
+    case Builtin::kArrayReduceRightLoopContinuation:
+    case Builtin::kArraySomeLoopContinuation:
+    case Builtin::kArrayTimSort:
+    case Builtin::kCall_ReceiverIsAny:
+    case Builtin::kCall_ReceiverIsNotNullOrUndefined:
+    case Builtin::kCall_ReceiverIsNullOrUndefined:
+    case Builtin::kCallWithArrayLike:
+    case Builtin::kCEntry_Return1_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit:
+    case Builtin::kCEntry_Return1_DontSaveFPRegs_ArgvOnStack_BuiltinExit:
+    case Builtin::kCEntry_Return1_DontSaveFPRegs_ArgvInRegister_NoBuiltinExit:
+    case Builtin::kCEntry_Return1_SaveFPRegs_ArgvOnStack_NoBuiltinExit:
+    case Builtin::kCEntry_Return1_SaveFPRegs_ArgvOnStack_BuiltinExit:
+    case Builtin::kCEntry_Return2_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit:
+    case Builtin::kCEntry_Return2_DontSaveFPRegs_ArgvOnStack_BuiltinExit:
+    case Builtin::kCEntry_Return2_DontSaveFPRegs_ArgvInRegister_NoBuiltinExit:
+    case Builtin::kCEntry_Return2_SaveFPRegs_ArgvOnStack_NoBuiltinExit:
+    case Builtin::kCEntry_Return2_SaveFPRegs_ArgvOnStack_BuiltinExit:
+    case Builtin::kCloneFastJSArray:
+    case Builtin::kConstruct:
+    case Builtin::kConvertToLocaleString:
+    case Builtin::kCreateTypedArray:
+    case Builtin::kDirectCEntry:
+    case Builtin::kDoubleToI:
+    case Builtin::kExtractFastJSArray:
+    case Builtin::kFastNewObject:
+    case Builtin::kFindOrderedHashMapEntry:
+    case Builtin::kFindOrderedHashSetEntry:
+    case Builtin::kFlatMapIntoArray:
+    case Builtin::kFlattenIntoArray:
+    case Builtin::kGetProperty:
+    case Builtin::kHasProperty:
+    case Builtin::kCreateHTML:
+    case Builtin::kNonNumberToNumber:
+    case Builtin::kNonPrimitiveToPrimitive_Number:
+    case Builtin::kNumberToString:
+    case Builtin::kObjectToString:
+    case Builtin::kOrderedHashTableHealIndex:
+    case Builtin::kOrdinaryToPrimitive_Number:
+    case Builtin::kOrdinaryToPrimitive_String:
+    case Builtin::kParseInt:
+    case Builtin::kProxyHasProperty:
+    case Builtin::kProxyIsExtensible:
+    case Builtin::kProxyGetPrototypeOf:
+    case Builtin::kRecordWriteSaveFP:
+    case Builtin::kRecordWriteIgnoreFP:
+    case Builtin::kStringAdd_CheckNone:
+    case Builtin::kStringEqual:
+    case Builtin::kStringIndexOf:
+    case Builtin::kStringRepeat:
+    case Builtin::kToInteger:
+    case Builtin::kToLength:
+    case Builtin::kToName:
+    case Builtin::kToObject:
+    case Builtin::kToString:
+#ifdef V8_IS_TSAN
+    case Builtin::kTSANRelaxedStore8IgnoreFP:
+    case Builtin::kTSANRelaxedStore8SaveFP:
+    case Builtin::kTSANRelaxedStore16IgnoreFP:
+    case Builtin::kTSANRelaxedStore16SaveFP:
+    case Builtin::kTSANRelaxedStore32IgnoreFP:
+    case Builtin::kTSANRelaxedStore32SaveFP:
+    case Builtin::kTSANRelaxedStore64IgnoreFP:
+    case Builtin::kTSANRelaxedStore64SaveFP:
+    case Builtin::kTSANSeqCstStore8IgnoreFP:
+    case Builtin::kTSANSeqCstStore8SaveFP:
+    case Builtin::kTSANSeqCstStore16IgnoreFP:
+    case Builtin::kTSANSeqCstStore16SaveFP:
+    case Builtin::kTSANSeqCstStore32IgnoreFP:
+    case Builtin::kTSANSeqCstStore32SaveFP:
+    case Builtin::kTSANSeqCstStore64IgnoreFP:
+    case Builtin::kTSANSeqCstStore64SaveFP:
+    case Builtin::kTSANRelaxedLoad32IgnoreFP:
+    case Builtin::kTSANRelaxedLoad32SaveFP:
+    case Builtin::kTSANRelaxedLoad64IgnoreFP:
+    case Builtin::kTSANRelaxedLoad64SaveFP:
+#endif  // V8_IS_TSAN
+    case Builtin::kWeakMapLookupHashIndex:
+      return true;
+    case Builtin::kJoinStackPop:
+    case Builtin::kJoinStackPush:
+      switch (caller) {
+        case Builtin::kArrayPrototypeJoin:
+        case Builtin::kArrayPrototypeToLocaleString:
+        case Builtin::kTypedArrayPrototypeJoin:
+        case Builtin::kTypedArrayPrototypeToLocaleString:
+          return true;
+        default:
+          return false;
+      }
+    case Builtin::kFastCreateDataProperty:
+      switch (caller) {
+        case Builtin::kArrayPrototypeSlice:
+        case Builtin::kArrayFilter:
+          return true;
+        default:
+          return false;
+      }
+    case Builtin::kSetProperty:
+      switch (caller) {
+        case Builtin::kArrayPrototypeSlice:
+        case Builtin::kTypedArrayPrototypeMap:
+        case Builtin::kStringPrototypeMatchAll:
+          return true;
+        default:
+          return false;
+      }
+    default:
+      return false;
+  }
+}
+
+// static
+void DebugEvaluate::VerifyTransitiveBuiltins(Isolate* isolate) {
+  // TODO(yangguo): also check runtime calls.
+  bool failed = false;
+  bool sanity_check = false;
+  for (Builtin caller = Builtins::kFirst; caller <= Builtins::kLast; ++caller) {
+    DebugInfo::SideEffectState state = BuiltinGetSideEffectState(caller);
+    if (state != DebugInfo::kHasNoSideEffect) continue;
+    Code code = FromCodeT(isolate->builtins()->code(caller));
+    int mode = RelocInfo::ModeMask(RelocInfo::CODE_TARGET) |
+               RelocInfo::ModeMask(RelocInfo::RELATIVE_CODE_TARGET);
+
+    for (RelocIterator it(code, mode); !it.done(); it.next()) {
+      RelocInfo* rinfo = it.rinfo();
+      DCHECK(RelocInfo::IsCodeTargetMode(rinfo->rmode()));
+      CodeLookupResult lookup_result =
+          isolate->heap()->GcSafeFindCodeForInnerPointer(
+              rinfo->target_address());
+      CHECK(lookup_result.IsFound());
+      Builtin callee = lookup_result.builtin_id();
+      if (BuiltinGetSideEffectState(callee) == DebugInfo::kHasNoSideEffect) {
+        continue;
+      }
+      if (TransitivelyCalledBuiltinHasNoSideEffect(caller, callee)) {
+        sanity_check = true;
+        continue;
+      }
+      PrintF("Allowlisted builtin %s calls non-allowlisted builtin %s\n",
+             Builtins::name(caller), Builtins::name(callee));
+      failed = true;
+    }
+  }
+  CHECK(!failed);
+#if defined(V8_TARGET_ARCH_PPC) || defined(V8_TARGET_ARCH_PPC64) ||      \
+    defined(V8_TARGET_ARCH_MIPS64) || defined(V8_TARGET_ARCH_RISCV32) || \
+    defined(V8_TARGET_ARCH_RISCV64)
+  // Isolate-independent builtin calls and jumps do not emit reloc infos
+  // on PPC. We try to avoid using PC relative code due to performance
+  // issue with especially older hardwares.
+  // MIPS64 doesn't have PC relative code currently.
+  // TODO(mips): Add PC relative code to MIPS64.
+  USE(sanity_check);
+#else
+  CHECK(sanity_check);
+#endif
+}
+#endif  // DEBUG
+
+// static
+void DebugEvaluate::ApplySideEffectChecks(
+    Handle<BytecodeArray> bytecode_array) {
+  for (interpreter::BytecodeArrayIterator it(bytecode_array); !it.done();
+       it.Advance()) {
+    interpreter::Bytecode bytecode = it.current_bytecode();
+    if (BytecodeRequiresRuntimeCheck(bytecode)) it.ApplyDebugBreak();
+  }
+}
+
+}  // namespace internal
+}  // namespace v8
diff --git a/deps/v8/src/debug/debug-scopes.cc b/deps/v8/src/debug/debug-scopes.cc
index 03caab3900d1bf..93911cc19d8a4c 100644
--- a/deps/v8/src/debug/debug-scopes.cc
+++ b/deps/v8/src/debug/debug-scopes.cc
@@ -706,7 +706,7 @@ void ScopeIterator::DebugPrint() {
       if (NeedsContext()) {
         context_->Print(os);
         if (context_->has_extension()) {
-          Handle<HeapObject> extension(context_->extension(), isolate_);
+          Handle<Object> extension(context_->extension(), isolate_);
           DCHECK(extension->IsJSContextExtensionObject());
           extension->Print(os);
         }
@@ -729,7 +729,7 @@ void ScopeIterator::DebugPrint() {
       os << "Closure:\n";
       context_->Print(os);
       if (context_->has_extension()) {
-        Handle<HeapObject> extension(context_->extension(), isolate_);
+        Handle<Object> extension(context_->extension(), isolate_);
         DCHECK(extension->IsJSContextExtensionObject());
         extension->Print(os);
       }
diff --git a/deps/v8/src/debug/debug-scopes.cc.orig b/deps/v8/src/debug/debug-scopes.cc.orig
new file mode 100644
index 00000000000000..03caab3900d1bf
--- /dev/null
+++ b/deps/v8/src/debug/debug-scopes.cc.orig
@@ -0,0 +1,1307 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/debug/debug-scopes.h"
+
+#include <memory>
+
+#include "src/ast/ast.h"
+#include "src/ast/scopes.h"
+#include "src/common/globals.h"
+#include "src/debug/debug.h"
+#include "src/execution/frames-inl.h"
+#include "src/objects/js-generator-inl.h"
+#include "src/objects/source-text-module.h"
+#include "src/objects/string-set.h"
+#include "src/parsing/parse-info.h"
+#include "src/parsing/parsing.h"
+#include "src/utils/ostreams.h"
+
+namespace v8 {
+namespace internal {
+
+ScopeIterator::ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
+                             ReparseStrategy strategy)
+    : isolate_(isolate),
+      frame_inspector_(frame_inspector),
+      function_(frame_inspector_->GetFunction()),
+      script_(frame_inspector_->GetScript()),
+      locals_(StringSet::New(isolate)) {
+  if (!frame_inspector->GetContext()->IsContext()) {
+    // Optimized frame, context or function cannot be materialized. Give up.
+    return;
+  }
+  context_ = Handle<Context>::cast(frame_inspector->GetContext());
+
+#if V8_ENABLE_WEBASSEMBLY
+  // We should not instantiate a ScopeIterator for wasm frames.
+  DCHECK_NE(Script::TYPE_WASM, frame_inspector->GetScript()->type());
+#endif  // V8_ENABLE_WEBASSEMBLY
+
+  TryParseAndRetrieveScopes(strategy);
+}
+
+ScopeIterator::~ScopeIterator() = default;
+
+Handle<Object> ScopeIterator::GetFunctionDebugName() const {
+  if (!function_.is_null()) return JSFunction::GetDebugName(function_);
+
+  if (!context_->IsNativeContext()) {
+    DisallowGarbageCollection no_gc;
+    ScopeInfo closure_info = context_->closure_context().scope_info();
+    Handle<String> debug_name(closure_info.FunctionDebugName(), isolate_);
+    if (debug_name->length() > 0) return debug_name;
+  }
+  return isolate_->factory()->undefined_value();
+}
+
+ScopeIterator::ScopeIterator(Isolate* isolate, Handle<JSFunction> function)
+    : isolate_(isolate),
+      context_(function->context(), isolate),
+      locals_(StringSet::New(isolate)) {
+  if (!function->shared().IsSubjectToDebugging()) {
+    context_ = Handle<Context>();
+    return;
+  }
+  script_ = handle(Script::cast(function->shared().script()), isolate);
+  UnwrapEvaluationContext();
+}
+
+ScopeIterator::ScopeIterator(Isolate* isolate,
+                             Handle<JSGeneratorObject> generator)
+    : isolate_(isolate),
+      generator_(generator),
+      function_(generator->function(), isolate),
+      context_(generator->context(), isolate),
+      script_(Script::cast(function_->shared().script()), isolate),
+      locals_(StringSet::New(isolate)) {
+  CHECK(function_->shared().IsSubjectToDebugging());
+  TryParseAndRetrieveScopes(ReparseStrategy::kFunctionLiteral);
+}
+
+void ScopeIterator::Restart() {
+  DCHECK_NOT_NULL(frame_inspector_);
+  function_ = frame_inspector_->GetFunction();
+  context_ = Handle<Context>::cast(frame_inspector_->GetContext());
+  current_scope_ = start_scope_;
+  DCHECK_NOT_NULL(current_scope_);
+  UnwrapEvaluationContext();
+}
+
+namespace {
+
+// Takes the scope of a parsed script, a function and a break location
+// inside the function. The result is the innermost lexical scope around
+// the break point, which serves as the starting point of the ScopeIterator.
+// And the scope of the function that was passed in (called closure scope).
+//
+// The start scope is guaranteed to be either the closure scope itself,
+// or a child of the closure scope.
+class ScopeChainRetriever {
+ public:
+  ScopeChainRetriever(DeclarationScope* scope, Handle<JSFunction> function,
+                      int position)
+      : scope_(scope),
+        break_scope_start_(function->shared().StartPosition()),
+        break_scope_end_(function->shared().EndPosition()),
+        position_(position) {
+    DCHECK_NOT_NULL(scope);
+    RetrieveScopes();
+  }
+
+  DeclarationScope* ClosureScope() { return closure_scope_; }
+  Scope* StartScope() { return start_scope_; }
+
+ private:
+  DeclarationScope* scope_;
+  const int break_scope_start_;
+  const int break_scope_end_;
+  const int position_;
+
+  DeclarationScope* closure_scope_ = nullptr;
+  Scope* start_scope_ = nullptr;
+
+  void RetrieveScopes() {
+    // 1. Find the closure scope with a DFS.
+    RetrieveClosureScope(scope_);
+    DCHECK_NOT_NULL(closure_scope_);
+
+    // 2. Starting from the closure scope search inwards. Given that V8's scope
+    //    tree doesn't guarantee that siblings don't overlap, we look at all
+    //    scopes and pick the one with the tightest bounds around `position_`.
+    start_scope_ = closure_scope_;
+    RetrieveStartScope(closure_scope_);
+    DCHECK_NOT_NULL(start_scope_);
+  }
+
+  bool RetrieveClosureScope(Scope* scope) {
+    // The closure scope is the scope that matches exactly the function we
+    // paused in. There is one quirk though, member initializder functions have
+    // the same source position as their class scope, so when looking for the
+    // declaration scope of the member initializer, we need to skip the
+    // corresponding class scope and keep looking.
+    if (!scope->is_class_scope() &&
+        break_scope_start_ == scope->start_position() &&
+        break_scope_end_ == scope->end_position()) {
+      closure_scope_ = scope->AsDeclarationScope();
+      return true;
+    }
+
+    for (Scope* inner_scope = scope->inner_scope(); inner_scope != nullptr;
+         inner_scope = inner_scope->sibling()) {
+      if (RetrieveClosureScope(inner_scope)) return true;
+    }
+    return false;
+  }
+
+  void RetrieveStartScope(Scope* scope) {
+    const int start = scope->start_position();
+    const int end = scope->end_position();
+
+    // Update start_scope_ if scope contains `position_` and scope is a tighter
+    // fit than the currently set start_scope_.
+    // Generators have the same source position so we also check for equality.
+    if (ContainsPosition(scope) && start >= start_scope_->start_position() &&
+        end <= start_scope_->end_position()) {
+      start_scope_ = scope;
+    }
+
+    for (Scope* inner_scope = scope->inner_scope(); inner_scope != nullptr;
+         inner_scope = inner_scope->sibling()) {
+      RetrieveStartScope(inner_scope);
+    }
+  }
+
+  bool ContainsPosition(Scope* scope) {
+    const int start = scope->start_position();
+    const int end = scope->end_position();
+    // In case the closure_scope_ hasn't been found yet, we are less strict
+    // about recursing downwards. This might be the case for nested arrow
+    // functions that have the same end position.
+    const bool position_fits_end =
+        closure_scope_ ? position_ < end : position_ <= end;
+    // While we're evaluating a class, the calling function will have a class
+    // context on the stack with a range that starts at Token::CLASS, and the
+    // source position will also point to Token::CLASS.  To identify the
+    // matching scope we include start in the accepted range for class scopes.
+    const bool position_fits_start =
+        scope->is_class_scope() ? start <= position_ : start < position_;
+    return position_fits_start && position_fits_end;
+  }
+};
+
+}  // namespace
+
+void ScopeIterator::TryParseAndRetrieveScopes(ReparseStrategy strategy) {
+  // Catch the case when the debugger stops in an internal function.
+  Handle<SharedFunctionInfo> shared_info(function_->shared(), isolate_);
+  Handle<ScopeInfo> scope_info(shared_info->scope_info(), isolate_);
+  if (shared_info->script().IsUndefined(isolate_)) {
+    current_scope_ = closure_scope_ = nullptr;
+    context_ = handle(function_->context(), isolate_);
+    function_ = Handle<JSFunction>();
+    return;
+  }
+
+  bool ignore_nested_scopes = false;
+  if (shared_info->HasBreakInfo() && frame_inspector_ != nullptr) {
+    // The source position at return is always the end of the function,
+    // which is not consistent with the current scope chain. Therefore all
+    // nested with, catch and block contexts are skipped, and we can only
+    // inspect the function scope.
+    // This can only happen if we set a break point inside right before the
+    // return, which requires a debug info to be available.
+    Handle<DebugInfo> debug_info(shared_info->GetDebugInfo(), isolate_);
+
+    // Find the break point where execution has stopped.
+    BreakLocation location = BreakLocation::FromFrame(debug_info, GetFrame());
+
+    ignore_nested_scopes = location.IsReturn();
+  }
+
+  if (strategy == ReparseStrategy::kScriptIfNeeded) {
+    CHECK(v8_flags.experimental_reuse_locals_blocklists);
+    Object maybe_block_list = isolate_->LocalsBlockListCacheGet(scope_info);
+    calculate_blocklists_ = maybe_block_list.IsTheHole();
+    strategy = calculate_blocklists_ ? ReparseStrategy::kScript
+                                     : ReparseStrategy::kFunctionLiteral;
+  }
+
+  // Reparse the code and analyze the scopes.
+  // Depending on the choosen strategy, the whole script or just
+  // the closure is re-parsed for function scopes.
+  Handle<Script> script(Script::cast(shared_info->script()), isolate_);
+
+  // Pick between flags for a single function compilation, or an eager
+  // compilation of the whole script.
+  UnoptimizedCompileFlags flags =
+      (scope_info->scope_type() == FUNCTION_SCOPE &&
+       strategy == ReparseStrategy::kFunctionLiteral)
+          ? UnoptimizedCompileFlags::ForFunctionCompile(isolate_, *shared_info)
+          : UnoptimizedCompileFlags::ForScriptCompile(isolate_, *script)
+                .set_is_eager(true);
+  flags.set_is_reparse(true);
+
+  MaybeHandle<ScopeInfo> maybe_outer_scope;
+  if (scope_info->scope_type() == EVAL_SCOPE || script->is_wrapped()) {
+    flags.set_is_eval(true);
+    if (!context_->IsNativeContext()) {
+      maybe_outer_scope = handle(context_->scope_info(), isolate_);
+    }
+    // Language mode may be inherited from the eval caller.
+    // Retrieve it from shared function info.
+    flags.set_outer_language_mode(shared_info->language_mode());
+  } else if (scope_info->scope_type() == MODULE_SCOPE) {
+    DCHECK(script->origin_options().IsModule());
+    DCHECK(flags.is_module());
+  } else {
+    DCHECK(scope_info->scope_type() == SCRIPT_SCOPE ||
+           scope_info->scope_type() == FUNCTION_SCOPE);
+  }
+
+  UnoptimizedCompileState compile_state;
+
+  reusable_compile_state_ =
+      std::make_unique<ReusableUnoptimizedCompileState>(isolate_);
+  info_ = std::make_unique<ParseInfo>(isolate_, flags, &compile_state,
+                                      reusable_compile_state_.get());
+
+  const bool parse_result =
+      flags.is_toplevel()
+          ? parsing::ParseProgram(info_.get(), script, maybe_outer_scope,
+                                  isolate_, parsing::ReportStatisticsMode::kNo)
+          : parsing::ParseFunction(info_.get(), shared_info, isolate_,
+                                   parsing::ReportStatisticsMode::kNo);
+
+  if (parse_result) {
+    DeclarationScope* literal_scope = info_->literal()->scope();
+
+    ScopeChainRetriever scope_chain_retriever(literal_scope, function_,
+                                              GetSourcePosition());
+    start_scope_ = scope_chain_retriever.StartScope();
+    current_scope_ = start_scope_;
+
+    // In case of a FUNCTION_SCOPE, the ScopeIterator expects
+    // {closure_scope_} to be set to the scope of the function.
+    closure_scope_ = scope_info->scope_type() == FUNCTION_SCOPE
+                         ? scope_chain_retriever.ClosureScope()
+                         : literal_scope;
+
+    if (ignore_nested_scopes) {
+      current_scope_ = closure_scope_;
+      start_scope_ = current_scope_;
+      // ignore_nested_scopes is only used for the return-position breakpoint,
+      // so we can safely assume that the closure context for the current
+      // function exists if it needs one.
+      if (closure_scope_->NeedsContext()) {
+        context_ = handle(context_->closure_context(), isolate_);
+      }
+    }
+
+    MaybeCollectAndStoreLocalBlocklists();
+    UnwrapEvaluationContext();
+  } else {
+    // A failed reparse indicates that the preparser has diverged from the
+    // parser, that the preparse data given to the initial parse was faulty, or
+    // a stack overflow.
+    // TODO(leszeks): This error is pretty unexpected, so we could report the
+    // error in debug mode. Better to not fail in release though, in case it's
+    // just a stack overflow.
+
+    // Silently fail by presenting an empty context chain.
+    context_ = Handle<Context>();
+  }
+}
+
+void ScopeIterator::UnwrapEvaluationContext() {
+  if (!context_->IsDebugEvaluateContext()) return;
+  Context current = *context_;
+  do {
+    Object wrapped = current.get(Context::WRAPPED_CONTEXT_INDEX);
+    if (wrapped.IsContext()) {
+      current = Context::cast(wrapped);
+    } else {
+      DCHECK(!current.previous().is_null());
+      current = current.previous();
+    }
+  } while (current.IsDebugEvaluateContext());
+  context_ = handle(current, isolate_);
+}
+
+Handle<JSObject> ScopeIterator::MaterializeScopeDetails() {
+  // Calculate the size of the result.
+  Handle<FixedArray> details =
+      isolate_->factory()->NewFixedArray(kScopeDetailsSize);
+  // Fill in scope details.
+  details->set(kScopeDetailsTypeIndex, Smi::FromInt(Type()));
+  Handle<JSObject> scope_object = ScopeObject(Mode::ALL);
+  details->set(kScopeDetailsObjectIndex, *scope_object);
+  if (Type() == ScopeTypeGlobal || Type() == ScopeTypeScript) {
+    return isolate_->factory()->NewJSArrayWithElements(details);
+  } else if (HasContext()) {
+    Handle<Object> closure_name = GetFunctionDebugName();
+    details->set(kScopeDetailsNameIndex, *closure_name);
+    details->set(kScopeDetailsStartPositionIndex,
+                 Smi::FromInt(start_position()));
+    details->set(kScopeDetailsEndPositionIndex, Smi::FromInt(end_position()));
+    if (InInnerScope()) {
+      details->set(kScopeDetailsFunctionIndex, *function_);
+    }
+  }
+  return isolate_->factory()->NewJSArrayWithElements(details);
+}
+
+bool ScopeIterator::HasPositionInfo() {
+  return InInnerScope() || !context_->IsNativeContext();
+}
+
+int ScopeIterator::start_position() {
+  if (InInnerScope()) return current_scope_->start_position();
+  if (context_->IsNativeContext()) return 0;
+  return context_->closure_context().scope_info().StartPosition();
+}
+
+int ScopeIterator::end_position() {
+  if (InInnerScope()) return current_scope_->end_position();
+  if (context_->IsNativeContext()) return 0;
+  return context_->closure_context().scope_info().EndPosition();
+}
+
+bool ScopeIterator::DeclaresLocals(Mode mode) const {
+  ScopeType type = Type();
+
+  if (type == ScopeTypeWith) return mode == Mode::ALL;
+  if (type == ScopeTypeGlobal) return mode == Mode::ALL;
+
+  bool declares_local = false;
+  auto visitor = [&](Handle<String> name, Handle<Object> value,
+                     ScopeType scope_type) {
+    declares_local = true;
+    return true;
+  };
+  VisitScope(visitor, mode);
+  return declares_local;
+}
+
+bool ScopeIterator::HasContext() const {
+  return !InInnerScope() || NeedsContext();
+}
+
+bool ScopeIterator::NeedsContext() const {
+  const bool needs_context = current_scope_->NeedsContext();
+
+  // We try very hard to ensure that a function's context is already
+  // available when we pause right at the beginning of that function.
+  // This can be tricky when we pause via stack check or via
+  // `BreakOnNextFunctionCall`, which happens normally in the middle of frame
+  // construction and we have to "step into" the function first.
+  //
+  // We check this by ensuring that the current context is not the closure
+  // context should the function need one. In that case the function has already
+  // pushed the context and we are good.
+  CHECK_IMPLIES(needs_context && current_scope_ == closure_scope_ &&
+                    current_scope_->is_function_scope() &&
+                    !function_->is_null(),
+                function_->context() != *context_);
+
+  return needs_context;
+}
+
+bool ScopeIterator::AdvanceOneScope() {
+  if (!current_scope_ || !current_scope_->outer_scope()) return false;
+
+  current_scope_ = current_scope_->outer_scope();
+  CollectLocalsFromCurrentScope();
+  return true;
+}
+
+void ScopeIterator::AdvanceOneContext() {
+  DCHECK(!context_->IsNativeContext());
+  DCHECK(!context_->previous().is_null());
+  context_ = handle(context_->previous(), isolate_);
+
+  // The locals blocklist is always associated with a context. So when we
+  // move one context up, we also reset the locals_ blocklist.
+  locals_ = StringSet::New(isolate_);
+}
+
+void ScopeIterator::AdvanceScope() {
+  DCHECK(InInnerScope());
+
+  do {
+    if (NeedsContext()) {
+      // current_scope_ needs a context so moving one scope up requires us to
+      // also move up one context.
+      AdvanceOneContext();
+    }
+
+    CHECK(AdvanceOneScope());
+  } while (current_scope_->is_hidden());
+}
+
+void ScopeIterator::AdvanceContext() {
+  AdvanceOneContext();
+
+  // While advancing one context, we need to advance at least one
+  // scope, but until we hit the next scope that actually requires
+  // a context. All the locals collected along the way build the
+  // blocklist for debug-evaluate for this context.
+  while (AdvanceOneScope() && !NeedsContext()) {
+  }
+}
+
+void ScopeIterator::Next() {
+  DCHECK(!Done());
+
+  ScopeType scope_type = Type();
+
+  if (scope_type == ScopeTypeGlobal) {
+    // The global scope is always the last in the chain.
+    DCHECK(context_->IsNativeContext());
+    context_ = Handle<Context>();
+    DCHECK(Done());
+    return;
+  }
+
+  bool leaving_closure = current_scope_ == closure_scope_;
+
+  if (scope_type == ScopeTypeScript) {
+    DCHECK_IMPLIES(InInnerScope() && !leaving_closure,
+                   current_scope_->is_script_scope());
+    seen_script_scope_ = true;
+    if (context_->IsScriptContext()) {
+      context_ = handle(context_->previous(), isolate_);
+    }
+  } else if (!InInnerScope()) {
+    AdvanceContext();
+  } else {
+    DCHECK_NOT_NULL(current_scope_);
+    AdvanceScope();
+
+    if (leaving_closure) {
+      DCHECK(current_scope_ != closure_scope_);
+      // If the current_scope_ doesn't need a context, we advance the scopes
+      // and collect the blocklist along the way until we find the scope
+      // that should match `context_`.
+      // But only do this if we have complete scope information.
+      while (!NeedsContext() && AdvanceOneScope()) {
+      }
+    }
+  }
+
+  MaybeCollectAndStoreLocalBlocklists();
+  UnwrapEvaluationContext();
+
+  if (leaving_closure) function_ = Handle<JSFunction>();
+}
+
+// Return the type of the current scope.
+ScopeIterator::ScopeType ScopeIterator::Type() const {
+  DCHECK(!Done());
+  if (InInnerScope()) {
+    switch (current_scope_->scope_type()) {
+      case FUNCTION_SCOPE:
+        DCHECK_IMPLIES(NeedsContext(), context_->IsFunctionContext() ||
+                                           context_->IsDebugEvaluateContext());
+        return ScopeTypeLocal;
+      case MODULE_SCOPE:
+        DCHECK_IMPLIES(NeedsContext(), context_->IsModuleContext());
+        return ScopeTypeModule;
+      case SCRIPT_SCOPE:
+        DCHECK_IMPLIES(NeedsContext(), context_->IsScriptContext() ||
+                                           context_->IsNativeContext());
+        return ScopeTypeScript;
+      case WITH_SCOPE:
+        DCHECK_IMPLIES(NeedsContext(), context_->IsWithContext());
+        return ScopeTypeWith;
+      case CATCH_SCOPE:
+        DCHECK(context_->IsCatchContext());
+        return ScopeTypeCatch;
+      case BLOCK_SCOPE:
+      case CLASS_SCOPE:
+        DCHECK_IMPLIES(NeedsContext(), context_->IsBlockContext());
+        return ScopeTypeBlock;
+      case EVAL_SCOPE:
+        DCHECK_IMPLIES(NeedsContext(), context_->IsEvalContext());
+        return ScopeTypeEval;
+    }
+    UNREACHABLE();
+  }
+  if (context_->IsNativeContext()) {
+    DCHECK(context_->global_object().IsJSGlobalObject());
+    // If we are at the native context and have not yet seen script scope,
+    // fake it.
+    return seen_script_scope_ ? ScopeTypeGlobal : ScopeTypeScript;
+  }
+  if (context_->IsFunctionContext() || context_->IsEvalContext() ||
+      context_->IsDebugEvaluateContext()) {
+    return ScopeTypeClosure;
+  }
+  if (context_->IsCatchContext()) {
+    return ScopeTypeCatch;
+  }
+  if (context_->IsBlockContext()) {
+    return ScopeTypeBlock;
+  }
+  if (context_->IsModuleContext()) {
+    return ScopeTypeModule;
+  }
+  if (context_->IsScriptContext()) {
+    return ScopeTypeScript;
+  }
+  DCHECK(context_->IsWithContext());
+  return ScopeTypeWith;
+}
+
+Handle<JSObject> ScopeIterator::ScopeObject(Mode mode) {
+  DCHECK(!Done());
+
+  ScopeType type = Type();
+  if (type == ScopeTypeGlobal) {
+    DCHECK_EQ(Mode::ALL, mode);
+    return handle(context_->global_proxy(), isolate_);
+  }
+  if (type == ScopeTypeWith) {
+    DCHECK_EQ(Mode::ALL, mode);
+    return WithContextExtension();
+  }
+
+  Handle<JSObject> scope = isolate_->factory()->NewSlowJSObjectWithNullProto();
+  auto visitor = [=](Handle<String> name, Handle<Object> value,
+                     ScopeType scope_type) {
+    if (value->IsOptimizedOut(isolate_)) {
+      if (v8_flags.experimental_value_unavailable) {
+        JSObject::SetAccessor(scope, name,
+                              isolate_->factory()->value_unavailable_accessor(),
+                              NONE)
+            .Check();
+        return false;
+      }
+      // Reflect optimized out variables as undefined in scope object.
+      value = isolate_->factory()->undefined_value();
+    } else if (value->IsTheHole(isolate_)) {
+      if (scope_type == ScopeTypeScript &&
+          JSReceiver::HasOwnProperty(isolate_, scope, name).FromMaybe(true)) {
+        // We also use the hole to represent overridden let-declarations via
+        // REPL mode in a script context. Catch this case.
+        return false;
+      }
+      if (v8_flags.experimental_value_unavailable) {
+        JSObject::SetAccessor(scope, name,
+                              isolate_->factory()->value_unavailable_accessor(),
+                              NONE)
+            .Check();
+        return false;
+      }
+      // Reflect variables under TDZ as undefined in scope object.
+      value = isolate_->factory()->undefined_value();
+    }
+    // Overwrite properties. Sometimes names in the same scope can collide, e.g.
+    // with extension objects introduced via local eval.
+    JSObject::SetPropertyOrElement(isolate_, scope, name, value,
+                                   Just(ShouldThrow::kDontThrow))
+        .Check();
+    return false;
+  };
+
+  VisitScope(visitor, mode);
+  return scope;
+}
+
+void ScopeIterator::VisitScope(const Visitor& visitor, Mode mode) const {
+  switch (Type()) {
+    case ScopeTypeLocal:
+    case ScopeTypeClosure:
+    case ScopeTypeCatch:
+    case ScopeTypeBlock:
+    case ScopeTypeEval:
+      return VisitLocalScope(visitor, mode, Type());
+    case ScopeTypeModule:
+      if (InInnerScope()) {
+        return VisitLocalScope(visitor, mode, Type());
+      }
+      DCHECK_EQ(Mode::ALL, mode);
+      return VisitModuleScope(visitor);
+    case ScopeTypeScript:
+      DCHECK_EQ(Mode::ALL, mode);
+      return VisitScriptScope(visitor);
+    case ScopeTypeWith:
+    case ScopeTypeGlobal:
+      UNREACHABLE();
+  }
+}
+
+bool ScopeIterator::SetVariableValue(Handle<String> name,
+                                     Handle<Object> value) {
+  DCHECK(!Done());
+  name = isolate_->factory()->InternalizeString(name);
+  switch (Type()) {
+    case ScopeTypeGlobal:
+    case ScopeTypeWith:
+      break;
+
+    case ScopeTypeEval:
+    case ScopeTypeBlock:
+    case ScopeTypeCatch:
+    case ScopeTypeModule:
+      if (InInnerScope()) return SetLocalVariableValue(name, value);
+      if (Type() == ScopeTypeModule && SetModuleVariableValue(name, value)) {
+        return true;
+      }
+      return SetContextVariableValue(name, value);
+
+    case ScopeTypeLocal:
+    case ScopeTypeClosure:
+      if (InInnerScope()) {
+        DCHECK_EQ(ScopeTypeLocal, Type());
+        if (SetLocalVariableValue(name, value)) return true;
+        // There may not be an associated context since we're InInnerScope().
+        if (!NeedsContext()) return false;
+      } else {
+        DCHECK_EQ(ScopeTypeClosure, Type());
+        if (SetContextVariableValue(name, value)) return true;
+      }
+      // The above functions only set variables statically declared in the
+      // function. There may be eval-introduced variables. Check them in
+      // SetContextExtensionValue.
+      return SetContextExtensionValue(name, value);
+
+    case ScopeTypeScript:
+      return SetScriptVariableValue(name, value);
+  }
+  return false;
+}
+
+bool ScopeIterator::ClosureScopeHasThisReference() const {
+  // closure_scope_ can be nullptr if parsing failed. See the TODO in
+  // TryParseAndRetrieveScopes.
+  return closure_scope_ && !closure_scope_->has_this_declaration() &&
+         closure_scope_->HasThisReference();
+}
+
+void ScopeIterator::CollectLocalsFromCurrentScope() {
+  DCHECK(locals_->IsStringSet());
+  for (Variable* var : *current_scope_->locals()) {
+    if (var->location() == VariableLocation::PARAMETER ||
+        var->location() == VariableLocation::LOCAL) {
+      locals_ = StringSet::Add(isolate_, locals_, var->name());
+    }
+  }
+}
+
+#ifdef DEBUG
+// Debug print of the content of the current scope.
+void ScopeIterator::DebugPrint() {
+  StdoutStream os;
+  DCHECK(!Done());
+  switch (Type()) {
+    case ScopeIterator::ScopeTypeGlobal:
+      os << "Global:\n";
+      context_->Print(os);
+      break;
+
+    case ScopeIterator::ScopeTypeLocal: {
+      os << "Local:\n";
+      if (NeedsContext()) {
+        context_->Print(os);
+        if (context_->has_extension()) {
+          Handle<HeapObject> extension(context_->extension(), isolate_);
+          DCHECK(extension->IsJSContextExtensionObject());
+          extension->Print(os);
+        }
+      }
+      break;
+    }
+
+    case ScopeIterator::ScopeTypeWith:
+      os << "With:\n";
+      context_->extension().Print(os);
+      break;
+
+    case ScopeIterator::ScopeTypeCatch:
+      os << "Catch:\n";
+      context_->extension().Print(os);
+      context_->get(Context::THROWN_OBJECT_INDEX).Print(os);
+      break;
+
+    case ScopeIterator::ScopeTypeClosure:
+      os << "Closure:\n";
+      context_->Print(os);
+      if (context_->has_extension()) {
+        Handle<HeapObject> extension(context_->extension(), isolate_);
+        DCHECK(extension->IsJSContextExtensionObject());
+        extension->Print(os);
+      }
+      break;
+
+    case ScopeIterator::ScopeTypeScript:
+      os << "Script:\n";
+      context_->global_object().native_context().script_context_table().Print(
+          os);
+      break;
+
+    default:
+      UNREACHABLE();
+  }
+  PrintF("\n");
+}
+#endif
+
+int ScopeIterator::GetSourcePosition() const {
+  if (frame_inspector_) {
+    return frame_inspector_->GetSourcePosition();
+  } else {
+    DCHECK(!generator_.is_null());
+    SharedFunctionInfo::EnsureSourcePositionsAvailable(
+        isolate_, handle(generator_->function().shared(), isolate_));
+    return generator_->source_position();
+  }
+}
+
+void ScopeIterator::VisitScriptScope(const Visitor& visitor) const {
+  Handle<JSGlobalObject> global(context_->global_object(), isolate_);
+  Handle<ScriptContextTable> script_contexts(
+      global->native_context().script_context_table(), isolate_);
+
+  // Skip the first script since that just declares 'this'.
+  for (int context_index = 1;
+       context_index < script_contexts->used(kAcquireLoad); context_index++) {
+    Handle<Context> context = ScriptContextTable::GetContext(
+        isolate_, script_contexts, context_index);
+    Handle<ScopeInfo> scope_info(context->scope_info(), isolate_);
+    if (VisitContextLocals(visitor, scope_info, context, ScopeTypeScript))
+      return;
+  }
+}
+
+void ScopeIterator::VisitModuleScope(const Visitor& visitor) const {
+  DCHECK(context_->IsModuleContext());
+
+  Handle<ScopeInfo> scope_info(context_->scope_info(), isolate_);
+  if (VisitContextLocals(visitor, scope_info, context_, ScopeTypeModule))
+    return;
+
+  int module_variable_count = scope_info->ModuleVariableCount();
+
+  Handle<SourceTextModule> module(context_->module(), isolate_);
+
+  for (int i = 0; i < module_variable_count; ++i) {
+    int index;
+    Handle<String> name;
+    {
+      String raw_name;
+      scope_info->ModuleVariable(i, &raw_name, &index);
+      if (ScopeInfo::VariableIsSynthetic(raw_name)) continue;
+      name = handle(raw_name, isolate_);
+    }
+    Handle<Object> value =
+        SourceTextModule::LoadVariable(isolate_, module, index);
+
+    if (visitor(name, value, ScopeTypeModule)) return;
+  }
+}
+
+bool ScopeIterator::VisitContextLocals(const Visitor& visitor,
+                                       Handle<ScopeInfo> scope_info,
+                                       Handle<Context> context,
+                                       ScopeType scope_type) const {
+  // Fill all context locals to the context extension.
+  for (auto it : ScopeInfo::IterateLocalNames(scope_info)) {
+    Handle<String> name(it->name(), isolate_);
+    if (ScopeInfo::VariableIsSynthetic(*name)) continue;
+    int context_index = scope_info->ContextHeaderLength() + it->index();
+    Handle<Object> value(context->get(context_index), isolate_);
+    if (visitor(name, value, scope_type)) return true;
+  }
+  return false;
+}
+
+bool ScopeIterator::VisitLocals(const Visitor& visitor, Mode mode,
+                                ScopeType scope_type) const {
+  if (mode == Mode::STACK && current_scope_->is_declaration_scope() &&
+      current_scope_->AsDeclarationScope()->has_this_declaration()) {
+    // TODO(bmeurer): We should refactor the general variable lookup
+    // around "this", since the current way is rather hacky when the
+    // receiver is context-allocated.
+    auto this_var = current_scope_->AsDeclarationScope()->receiver();
+    Handle<Object> receiver =
+        this_var->location() == VariableLocation::CONTEXT
+            ? handle(context_->get(this_var->index()), isolate_)
+        : frame_inspector_ == nullptr ? handle(generator_->receiver(), isolate_)
+                                      : frame_inspector_->GetReceiver();
+    if (visitor(isolate_->factory()->this_string(), receiver, scope_type))
+      return true;
+  }
+
+  if (current_scope_->is_function_scope()) {
+    Variable* function_var =
+        current_scope_->AsDeclarationScope()->function_var();
+    if (function_var != nullptr) {
+      Handle<JSFunction> function = frame_inspector_ == nullptr
+                                        ? function_
+                                        : frame_inspector_->GetFunction();
+      Handle<String> name = function_var->name();
+      if (visitor(name, function, scope_type)) return true;
+    }
+  }
+
+  for (Variable* var : *current_scope_->locals()) {
+    if (ScopeInfo::VariableIsSynthetic(*var->name())) continue;
+
+    int index = var->index();
+    Handle<Object> value;
+    switch (var->location()) {
+      case VariableLocation::LOOKUP:
+        UNREACHABLE();
+
+      case VariableLocation::REPL_GLOBAL:
+        // REPL declared variables are ignored for now.
+      case VariableLocation::UNALLOCATED:
+        continue;
+
+      case VariableLocation::PARAMETER: {
+        if (frame_inspector_ == nullptr) {
+          // Get the variable from the suspended generator.
+          DCHECK(!generator_.is_null());
+          FixedArray parameters_and_registers =
+              generator_->parameters_and_registers();
+          DCHECK_LT(index, parameters_and_registers.length());
+          value = handle(parameters_and_registers.get(index), isolate_);
+        } else {
+          value = frame_inspector_->GetParameter(index);
+        }
+        break;
+      }
+
+      case VariableLocation::LOCAL:
+        if (frame_inspector_ == nullptr) {
+          // Get the variable from the suspended generator.
+          DCHECK(!generator_.is_null());
+          FixedArray parameters_and_registers =
+              generator_->parameters_and_registers();
+          int parameter_count =
+              function_->shared().scope_info().ParameterCount();
+          index += parameter_count;
+          DCHECK_LT(index, parameters_and_registers.length());
+          value = handle(parameters_and_registers.get(index), isolate_);
+        } else {
+          value = frame_inspector_->GetExpression(index);
+          if (value->IsOptimizedOut(isolate_)) {
+            // We'll rematerialize this later.
+            if (current_scope_->is_declaration_scope() &&
+                current_scope_->AsDeclarationScope()->arguments() == var) {
+              continue;
+            }
+          } else if (IsLexicalVariableMode(var->mode()) &&
+                     value->IsUndefined(isolate_) &&
+                     GetSourcePosition() != kNoSourcePosition &&
+                     GetSourcePosition() <= var->initializer_position()) {
+            // Variables that are `undefined` could also mean an elided hole
+            // write. We explicitly check the static scope information if we
+            // are currently stopped before the variable is actually initialized
+            // which means we are in the middle of that var's TDZ.
+            value = isolate_->factory()->the_hole_value();
+          }
+        }
+        break;
+
+      case VariableLocation::CONTEXT:
+        if (mode == Mode::STACK) continue;
+        DCHECK(var->IsContextSlot());
+        value = handle(context_->get(index), isolate_);
+        break;
+
+      case VariableLocation::MODULE: {
+        if (mode == Mode::STACK) continue;
+        // if (var->IsExport()) continue;
+        Handle<SourceTextModule> module(context_->module(), isolate_);
+        value = SourceTextModule::LoadVariable(isolate_, module, var->index());
+        break;
+      }
+    }
+
+    if (visitor(var->name(), value, scope_type)) return true;
+  }
+  return false;
+}
+
+// Retrieve the with-context extension object. If the extension object is
+// a proxy, return an empty object.
+Handle<JSObject> ScopeIterator::WithContextExtension() {
+  DCHECK(context_->IsWithContext());
+  if (context_->extension_receiver().IsJSProxy()) {
+    return isolate_->factory()->NewSlowJSObjectWithNullProto();
+  }
+  return handle(JSObject::cast(context_->extension_receiver()), isolate_);
+}
+
+// Create a plain JSObject which materializes the block scope for the specified
+// block context.
+void ScopeIterator::VisitLocalScope(const Visitor& visitor, Mode mode,
+                                    ScopeType scope_type) const {
+  if (InInnerScope()) {
+    if (VisitLocals(visitor, mode, scope_type)) return;
+    if (mode == Mode::STACK && Type() == ScopeTypeLocal) {
+      // Hide |this| in arrow functions that may be embedded in other functions
+      // but don't force |this| to be context-allocated. Otherwise we'd find the
+      // wrong |this| value.
+      if (!closure_scope_->has_this_declaration() &&
+          !closure_scope_->HasThisReference()) {
+        if (visitor(isolate_->factory()->this_string(),
+                    isolate_->factory()->undefined_value(), scope_type))
+          return;
+      }
+      // Add |arguments| to the function scope even if it wasn't used.
+      // Currently we don't yet support materializing the arguments object of
+      // suspended generators. We'd need to read the arguments out from the
+      // suspended generator rather than from an activation as
+      // FunctionGetArguments does.
+      if (frame_inspector_ != nullptr && !closure_scope_->is_arrow_scope() &&
+          (closure_scope_->arguments() == nullptr ||
+           frame_inspector_->GetExpression(closure_scope_->arguments()->index())
+               ->IsOptimizedOut(isolate_))) {
+        JavaScriptFrame* frame = GetFrame();
+        Handle<JSObject> arguments = Accessors::FunctionGetArguments(
+            frame, frame_inspector_->inlined_frame_index());
+        if (visitor(isolate_->factory()->arguments_string(), arguments,
+                    scope_type))
+          return;
+      }
+    }
+  } else {
+    DCHECK_EQ(Mode::ALL, mode);
+    Handle<ScopeInfo> scope_info(context_->scope_info(), isolate_);
+    if (VisitContextLocals(visitor, scope_info, context_, scope_type)) return;
+  }
+
+  if (mode == Mode::ALL && HasContext()) {
+    DCHECK(!context_->IsScriptContext());
+    DCHECK(!context_->IsNativeContext());
+    DCHECK(!context_->IsWithContext());
+    if (!context_->scope_info().SloppyEvalCanExtendVars()) return;
+    if (context_->extension_object().is_null()) return;
+    Handle<JSObject> extension(context_->extension_object(), isolate_);
+    Handle<FixedArray> keys =
+        KeyAccumulator::GetKeys(isolate_, extension,
+                                KeyCollectionMode::kOwnOnly, ENUMERABLE_STRINGS)
+            .ToHandleChecked();
+
+    for (int i = 0; i < keys->length(); i++) {
+      // Names of variables introduced by eval are strings.
+      DCHECK(keys->get(i).IsString());
+      Handle<String> key(String::cast(keys->get(i)), isolate_);
+      Handle<Object> value =
+          JSReceiver::GetDataProperty(isolate_, extension, key);
+      if (visitor(key, value, scope_type)) return;
+    }
+  }
+}
+
+bool ScopeIterator::SetLocalVariableValue(Handle<String> variable_name,
+                                          Handle<Object> new_value) {
+  // TODO(verwaest): Walk parameters backwards, not forwards.
+  // TODO(verwaest): Use VariableMap rather than locals() list for lookup.
+  for (Variable* var : *current_scope_->locals()) {
+    if (String::Equals(isolate_, var->name(), variable_name)) {
+      int index = var->index();
+      switch (var->location()) {
+        case VariableLocation::LOOKUP:
+        case VariableLocation::UNALLOCATED:
+          // Drop assignments to unallocated locals.
+          DCHECK(var->is_this() ||
+                 *variable_name == ReadOnlyRoots(isolate_).arguments_string());
+          return false;
+
+        case VariableLocation::REPL_GLOBAL:
+          // Assignments to REPL declared variables are ignored for now.
+          return false;
+
+        case VariableLocation::PARAMETER: {
+          if (var->is_this()) return false;
+          if (frame_inspector_ == nullptr) {
+            // Set the variable in the suspended generator.
+            DCHECK(!generator_.is_null());
+            Handle<FixedArray> parameters_and_registers(
+                generator_->parameters_and_registers(), isolate_);
+            DCHECK_LT(index, parameters_and_registers->length());
+            parameters_and_registers->set(index, *new_value);
+          } else {
+            JavaScriptFrame* frame = GetFrame();
+            if (!frame->is_unoptimized()) return false;
+
+            frame->SetParameterValue(index, *new_value);
+          }
+          return true;
+        }
+
+        case VariableLocation::LOCAL:
+          if (frame_inspector_ == nullptr) {
+            // Set the variable in the suspended generator.
+            DCHECK(!generator_.is_null());
+            int parameter_count =
+                function_->shared().scope_info().ParameterCount();
+            index += parameter_count;
+            Handle<FixedArray> parameters_and_registers(
+                generator_->parameters_and_registers(), isolate_);
+            DCHECK_LT(index, parameters_and_registers->length());
+            parameters_and_registers->set(index, *new_value);
+          } else {
+            // Set the variable on the stack.
+            JavaScriptFrame* frame = GetFrame();
+            if (!frame->is_unoptimized()) return false;
+
+            frame->SetExpression(index, *new_value);
+          }
+          return true;
+
+        case VariableLocation::CONTEXT:
+          DCHECK(var->IsContextSlot());
+          context_->set(index, *new_value);
+          return true;
+
+        case VariableLocation::MODULE:
+          if (!var->IsExport()) return false;
+          Handle<SourceTextModule> module(context_->module(), isolate_);
+          SourceTextModule::StoreVariable(module, var->index(), new_value);
+          return true;
+      }
+      UNREACHABLE();
+    }
+  }
+
+  return false;
+}
+
+bool ScopeIterator::SetContextExtensionValue(Handle<String> variable_name,
+                                             Handle<Object> new_value) {
+  if (!context_->has_extension()) return false;
+
+  DCHECK(context_->extension_object().IsJSContextExtensionObject());
+  Handle<JSObject> ext(context_->extension_object(), isolate_);
+  LookupIterator it(isolate_, ext, variable_name, LookupIterator::OWN);
+  Maybe<bool> maybe = JSReceiver::HasProperty(&it);
+  DCHECK(maybe.IsJust());
+  if (!maybe.FromJust()) return false;
+
+  CHECK(Object::SetDataProperty(&it, new_value).ToChecked());
+  return true;
+}
+
+bool ScopeIterator::SetContextVariableValue(Handle<String> variable_name,
+                                            Handle<Object> new_value) {
+  int slot_index = context_->scope_info().ContextSlotIndex(variable_name);
+  if (slot_index < 0) return false;
+  context_->set(slot_index, *new_value);
+  return true;
+}
+
+bool ScopeIterator::SetModuleVariableValue(Handle<String> variable_name,
+                                           Handle<Object> new_value) {
+  DisallowGarbageCollection no_gc;
+  int cell_index;
+  VariableMode mode;
+  InitializationFlag init_flag;
+  MaybeAssignedFlag maybe_assigned_flag;
+  cell_index = context_->scope_info().ModuleIndex(
+      *variable_name, &mode, &init_flag, &maybe_assigned_flag);
+
+  // Setting imports is currently not supported.
+  if (SourceTextModuleDescriptor::GetCellIndexKind(cell_index) !=
+      SourceTextModuleDescriptor::kExport) {
+    return false;
+  }
+
+  Handle<SourceTextModule> module(context_->module(), isolate_);
+  SourceTextModule::StoreVariable(module, cell_index, new_value);
+  return true;
+}
+
+bool ScopeIterator::SetScriptVariableValue(Handle<String> variable_name,
+                                           Handle<Object> new_value) {
+  Handle<ScriptContextTable> script_contexts(
+      context_->global_object().native_context().script_context_table(),
+      isolate_);
+  VariableLookupResult lookup_result;
+  if (script_contexts->Lookup(variable_name, &lookup_result)) {
+    Handle<Context> script_context = ScriptContextTable::GetContext(
+        isolate_, script_contexts, lookup_result.context_index);
+    script_context->set(lookup_result.slot_index, *new_value);
+    return true;
+  }
+
+  return false;
+}
+
+namespace {
+
+// Given the scope and context of a paused function, this class calculates
+// all the necessary block lists on the scope chain and stores them in the
+// global LocalsBlockListCache ephemeron table.
+//
+// Doc: bit.ly/chrome-devtools-debug-evaluate-design.
+//
+// The algorithm works in a single walk of the scope chain from the
+// paused function scope outwards to the script scope.
+//
+// When we step from scope "a" to its outer scope "b", we do:
+//
+//   1. Add all stack-allocated variables from "b" to the blocklists.
+//   2. Does "b" need a context? If yes:
+//        - Store all current blocklists in the global table
+//        - Start a new blocklist for scope "b"
+//   3. Is "b" a function scope without a context? If yes:
+//        - Start a new blocklist for scope "b"
+//
+class LocalBlocklistsCollector {
+ public:
+  LocalBlocklistsCollector(Isolate* isolate, Handle<Script> script,
+                           Handle<Context> context,
+                           DeclarationScope* closure_scope);
+  void CollectAndStore();
+
+ private:
+  void InitializeWithClosureScope();
+  void AdvanceToNextNonHiddenScope();
+  void CollectCurrentLocalsIntoBlocklists();
+  Handle<ScopeInfo> FindScopeInfoForScope(Scope* scope) const;
+  void StoreFunctionBlocklists(Handle<ScopeInfo> outer_scope_info);
+
+  Isolate* isolate_;
+  Handle<Script> script_;
+  Handle<Context> context_;
+  Scope* scope_;
+  DeclarationScope* closure_scope_;
+
+  Handle<StringSet> context_blocklist_;
+  std::map<Scope*, Handle<StringSet>> function_blocklists_;
+};
+
+LocalBlocklistsCollector::LocalBlocklistsCollector(
+    Isolate* isolate, Handle<Script> script, Handle<Context> context,
+    DeclarationScope* closure_scope)
+    : isolate_(isolate),
+      script_(script),
+      context_(context),
+      scope_(closure_scope),
+      closure_scope_(closure_scope) {}
+
+void LocalBlocklistsCollector::InitializeWithClosureScope() {
+  CHECK(scope_->is_declaration_scope());
+  function_blocklists_.emplace(scope_, StringSet::New(isolate_));
+  if (scope_->NeedsContext()) context_blocklist_ = StringSet::New(isolate_);
+}
+
+void LocalBlocklistsCollector::AdvanceToNextNonHiddenScope() {
+  DCHECK(scope_ && scope_->outer_scope());
+  do {
+    scope_ = scope_->outer_scope();
+    CHECK(scope_);
+  } while (scope_->is_hidden());
+}
+
+void LocalBlocklistsCollector::CollectCurrentLocalsIntoBlocklists() {
+  for (Variable* var : *scope_->locals()) {
+    if (var->location() == VariableLocation::PARAMETER ||
+        var->location() == VariableLocation::LOCAL) {
+      if (!context_blocklist_.is_null()) {
+        context_blocklist_ =
+            StringSet::Add(isolate_, context_blocklist_, var->name());
+      }
+      for (auto& pair : function_blocklists_) {
+        pair.second = StringSet::Add(isolate_, pair.second, var->name());
+      }
+    }
+  }
+}
+
+Handle<ScopeInfo> LocalBlocklistsCollector::FindScopeInfoForScope(
+    Scope* scope) const {
+  DisallowGarbageCollection no_gc;
+  SharedFunctionInfo::ScriptIterator iterator(isolate_, *script_);
+  for (SharedFunctionInfo info = iterator.Next(); !info.is_null();
+       info = iterator.Next()) {
+    if (scope->start_position() == info.StartPosition() &&
+        scope->end_position() == info.EndPosition()) {
+      if (info.is_compiled() && !info.scope_info().is_null()) {
+        return handle(info.scope_info(), isolate_);
+      }
+      return Handle<ScopeInfo>();
+    }
+  }
+  return Handle<ScopeInfo>();
+}
+
+void LocalBlocklistsCollector::StoreFunctionBlocklists(
+    Handle<ScopeInfo> outer_scope_info) {
+  for (const auto& pair : function_blocklists_) {
+    Handle<ScopeInfo> scope_info = FindScopeInfoForScope(pair.first);
+    // If we don't find a ScopeInfo it's not tragic. It means we'll do
+    // a full-reparse in case we pause in that function in the future.
+    // The only ScopeInfo that MUST be found is for the closure_scope_.
+    CHECK_IMPLIES(pair.first == closure_scope_, !scope_info.is_null());
+    if (scope_info.is_null()) continue;
+    isolate_->LocalsBlockListCacheSet(scope_info, outer_scope_info,
+                                      pair.second);
+  }
+}
+
+void LocalBlocklistsCollector::CollectAndStore() {
+  InitializeWithClosureScope();
+
+  while (scope_->outer_scope() && !context_->IsNativeContext()) {
+    AdvanceToNextNonHiddenScope();
+    // 1. Add all stack-allocated variables of `scope_` to the various lists.
+    CollectCurrentLocalsIntoBlocklists();
+
+    // 2. If the current scope requires a context then all the blocklists "stop"
+    //    here and we store them.  Next, advance the current context so
+    //    `context_` and `scope_` match again.
+    if (scope_->NeedsContext()) {
+      if (!context_blocklist_.is_null()) {
+        // Only store the block list and advance the context if the
+        // context_blocklist is set. This handles the case when we start on
+        // a closure scope that doesn't require a context. In that case
+        // `context_` is already the right context for `scope_` so we don't
+        // need to advance `context_`.
+        isolate_->LocalsBlockListCacheSet(
+            handle(context_->scope_info(), isolate_),
+            handle(context_->previous().scope_info(), isolate_),
+            context_blocklist_);
+        context_ = handle(context_->previous(), isolate_);
+      }
+
+      StoreFunctionBlocklists(handle(context_->scope_info(), isolate_));
+
+      context_blocklist_ = StringSet::New(isolate_);
+      function_blocklists_.clear();
+    } else if (scope_->is_function_scope()) {
+      // 3. If `scope` is a function scope with an SFI, start recording
+      //    locals for its ScopeInfo.
+      CHECK(!scope_->NeedsContext());
+      function_blocklists_.emplace(scope_, StringSet::New(isolate_));
+    }
+  }
+
+  // In case we don't have any outer scopes we still need to record the empty
+  // block list for the paused function to prevent future re-parses.
+  StoreFunctionBlocklists(handle(context_->scope_info(), isolate_));
+}
+
+}  // namespace
+
+void ScopeIterator::MaybeCollectAndStoreLocalBlocklists() const {
+  if (!calculate_blocklists_ || current_scope_ != closure_scope_) return;
+
+  CHECK(v8_flags.experimental_reuse_locals_blocklists);
+  DCHECK(isolate_
+             ->LocalsBlockListCacheGet(
+                 handle(function_->shared().scope_info(), isolate_))
+             .IsTheHole());
+  LocalBlocklistsCollector collector(isolate_, script_, context_,
+                                     closure_scope_);
+  collector.CollectAndStore();
+}
+
+}  // namespace internal
+}  // namespace v8
diff --git a/deps/v8/src/diagnostics/objects-printer.cc b/deps/v8/src/diagnostics/objects-printer.cc
index ce4d15b2c27e14..baf40fc43e9095 100644
--- a/deps/v8/src/diagnostics/objects-printer.cc
+++ b/deps/v8/src/diagnostics/objects-printer.cc
@@ -2337,7 +2337,6 @@ void Script::ScriptPrint(std::ostream& os) {
   os << "\n - id: " << id();
   os << "\n - source_url: " << Brief(source_url());
   os << "\n - source_mapping_url: " << Brief(source_mapping_url());
-  os << "\n - host_defined_options: " << Brief(host_defined_options());
   os << "\n - compilation type: " << compilation_type();
   bool is_wasm = false;
 #if V8_ENABLE_WEBASSEMBLY
diff --git a/deps/v8/src/execution/execution.cc b/deps/v8/src/execution/execution.cc
index b76a601b8fe9c6..b8113e70670c95 100644
--- a/deps/v8/src/execution/execution.cc
+++ b/deps/v8/src/execution/execution.cc
@@ -100,6 +100,7 @@ InvokeParams InvokeParams::SetUpForNew(Isolate* isolate,
   params.is_construct = true;
   params.execution_target = Execution::Target::kCallable;
   params.reschedule_terminate = true;
+  DCHECK(!params.IsScript());
   return params;
 }
 
@@ -113,7 +114,6 @@ InvokeParams InvokeParams::SetUpForCall(Isolate* isolate,
   params.receiver = NormalizeReceiver(isolate, receiver);
   // Check for host-defined options argument for scripts.
   DCHECK_IMPLIES(params.IsScript(), argc == 1);
-  DCHECK_IMPLIES(params.IsScript(), argv[0]->IsFixedArray());
   params.argc = argc;
   params.argv = argv;
   params.new_target = isolate->factory()->undefined_value();
@@ -136,7 +136,6 @@ InvokeParams InvokeParams::SetUpForTryCall(
   params.receiver = NormalizeReceiver(isolate, receiver);
   // Check for host-defined options argument for scripts.
   DCHECK_IMPLIES(params.IsScript(), argc == 1);
-  DCHECK_IMPLIES(params.IsScript(), argv[0]->IsFixedArray());
   params.argc = argc;
   params.argv = argv;
   params.new_target = isolate->factory()->undefined_value();
@@ -186,7 +185,6 @@ Handle<CodeT> JSEntry(Isolate* isolate, Execution::Target execution_target,
 MaybeHandle<Context> NewScriptContext(Isolate* isolate,
                                       Handle<JSFunction> function,
                                       Handle<FixedArray> host_defined_options) {
-  // TODO(cbruni, 1244145): Use passed in host_defined_options.
   // Creating a script context is a side effect, so abort if that's not
   // allowed.
   if (isolate->debug_execution_mode() == DebugInfo::kSideEffects) {
@@ -258,8 +256,8 @@ MaybeHandle<Context> NewScriptContext(Isolate* isolate,
     }
   }
 
-  Handle<Context> result =
-      isolate->factory()->NewScriptContext(native_context, scope_info);
+  Handle<Context> result = isolate->factory()->NewScriptContext(
+      native_context, scope_info, host_defined_options);
 
   result->Initialize(isolate);
   // In REPL mode, we are allowed to add/modify let/const variables.
@@ -338,7 +336,6 @@ V8_WARN_UNUSED_RESULT MaybeHandle<Object> Invoke(Isolate* isolate,
       DCHECK(params.IsScript());
       DCHECK(params.receiver->IsJSGlobalProxy());
       DCHECK_EQ(params.argc, 1);
-      DCHECK(params.argv[0]->IsFixedArray());
     } else {
       DCHECK(!params.IsScript());
     }
@@ -468,6 +465,7 @@ V8_WARN_UNUSED_RESULT MaybeHandle<Object> Invoke(Isolate* isolate,
 
 MaybeHandle<Object> InvokeWithTryCatch(Isolate* isolate,
                                        const InvokeParams& params) {
+  // DCHECK(!params.IsScript());
   bool is_termination = false;
   MaybeHandle<Object> maybe_result;
   if (params.exception_out != nullptr) {
diff --git a/deps/v8/src/execution/execution.h b/deps/v8/src/execution/execution.h
index 7fb97a77450d0b..b2d81a9ca81f0b 100644
--- a/deps/v8/src/execution/execution.h
+++ b/deps/v8/src/execution/execution.h
@@ -6,6 +6,7 @@
 #define V8_EXECUTION_EXECUTION_H_
 
 #include "src/common/globals.h"
+#include "src/handles/maybe-handles.h"
 
 namespace v8 {
 namespace internal {
diff --git a/deps/v8/src/execution/isolate.cc b/deps/v8/src/execution/isolate.cc
index 3d6717a8778433..57f1448e50ce11 100644
--- a/deps/v8/src/execution/isolate.cc
+++ b/deps/v8/src/execution/isolate.cc
@@ -4992,6 +4992,7 @@ MaybeHandle<JSPromise> NewRejectedPromise(Isolate* isolate,
 
 MaybeHandle<JSPromise> Isolate::RunHostImportModuleDynamicallyCallback(
     MaybeHandle<Script> maybe_referrer, Handle<Object> specifier,
+    Handle<Object> host_defined_options,
     MaybeHandle<Object> maybe_import_assertions_argument) {
   v8::Local<v8::Context> api_context =
       v8::Utils::ToLocal(Handle<Context>::cast(native_context()));
@@ -5020,14 +5021,9 @@ MaybeHandle<JSPromise> Isolate::RunHostImportModuleDynamicallyCallback(
     clear_pending_exception();
     return NewRejectedPromise(this, api_context, exception);
   }
-  Handle<FixedArray> host_defined_options;
-  Handle<Object> resource_name;
-  if (maybe_referrer.is_null()) {
-    host_defined_options = factory()->empty_fixed_array();
-    resource_name = factory()->null_value();
-  } else {
-    Handle<Script> referrer = maybe_referrer.ToHandleChecked();
-    host_defined_options = handle(referrer->host_defined_options(), this);
+  Handle<Object> resource_name = factory()->null_value();
+  Handle<Script> referrer;
+  if (maybe_referrer.ToHandle(&referrer)) {
     resource_name = handle(referrer->name(), this);
   }
 
diff --git a/deps/v8/src/execution/isolate.h b/deps/v8/src/execution/isolate.h
index c25ad662bf3579..f64b3748d122b4 100644
--- a/deps/v8/src/execution/isolate.h
+++ b/deps/v8/src/execution/isolate.h
@@ -1802,6 +1802,7 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
       HostImportModuleDynamicallyCallback callback);
   MaybeHandle<JSPromise> RunHostImportModuleDynamicallyCallback(
       MaybeHandle<Script> maybe_referrer, Handle<Object> specifier,
+      Handle<Object> host_defined_options,
       MaybeHandle<Object> maybe_import_assertions_argument);
 
   void SetHostInitializeImportMetaObjectCallback(
diff --git a/deps/v8/src/heap/factory-base.cc b/deps/v8/src/heap/factory-base.cc
index 0dec79f03456d0..c1d34e40e73334 100644
--- a/deps/v8/src/heap/factory-base.cc
+++ b/deps/v8/src/heap/factory-base.cc
@@ -291,7 +291,6 @@ Handle<Script> FactoryBase<Impl>::NewScriptWithId(
     raw.set_shared_function_infos(roots.empty_weak_fixed_array(),
                                   SKIP_WRITE_BARRIER);
     raw.set_flags(0);
-    raw.set_host_defined_options(roots.empty_fixed_array(), SKIP_WRITE_BARRIER);
     raw.set_source_hash(roots.undefined_value(), SKIP_WRITE_BARRIER);
 #ifdef V8_SCRIPTORMODULE_LEGACY_LIFETIME
     raw.set_script_or_modules(roots.empty_array_list());
diff --git a/deps/v8/src/heap/factory.cc b/deps/v8/src/heap/factory.cc
index bcb2f6475ec357..3f5593e49752f8 100644
--- a/deps/v8/src/heap/factory.cc
+++ b/deps/v8/src/heap/factory.cc
@@ -1296,8 +1296,9 @@ Handle<NativeContext> Factory::NewNativeContext() {
   return handle(context, isolate());
 }
 
-Handle<Context> Factory::NewScriptContext(Handle<NativeContext> outer,
-                                          Handle<ScopeInfo> scope_info) {
+Handle<Context> Factory::NewScriptContext(
+    Handle<NativeContext> outer, Handle<ScopeInfo> scope_info,
+    MaybeHandle<Object> maybe_host_defined_options) {
   DCHECK_EQ(scope_info->scope_type(), SCRIPT_SCOPE);
   int variadic_part_length = scope_info->ContextLength();
   Context context =
@@ -1307,6 +1308,9 @@ Handle<Context> Factory::NewScriptContext(Handle<NativeContext> outer,
   DisallowGarbageCollection no_gc;
   context.set_scope_info(*scope_info);
   context.set_previous(*outer);
+  if (scope_info->HasContextExtensionSlot()) {
+    context.set_extension(*(maybe_host_defined_options.ToHandleChecked()));
+  }
   DCHECK(context.IsScriptContext());
   return handle(context, isolate());
 }
@@ -1522,7 +1526,6 @@ Handle<Script> Factory::CloneScript(Handle<Script> script) {
                                          SKIP_WRITE_BARRIER);
     new_script.set_eval_from_position(old_script.eval_from_position());
     new_script.set_flags(old_script.flags());
-    new_script.set_host_defined_options(old_script.host_defined_options());
     new_script.set_source_hash(*undefined_value(), SKIP_WRITE_BARRIER);
 #ifdef V8_SCRIPTORMODULE_LEGACY_LIFETIME
     new_script.set_script_or_modules(*list);
@@ -2956,7 +2959,7 @@ Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
 }
 
 Handle<SourceTextModule> Factory::NewSourceTextModule(
-    Handle<SharedFunctionInfo> sfi) {
+    Handle<SharedFunctionInfo> sfi, Handle<Object> host_defined_options) {
   Handle<SourceTextModuleInfo> module_info(
       sfi->scope_info().ModuleDescriptorInfo(), isolate());
   Handle<ObjectHashTable> exports =
@@ -2994,6 +2997,7 @@ Handle<SourceTextModule> Factory::NewSourceTextModule(
   module.set_cycle_root(roots.the_hole_value(), SKIP_WRITE_BARRIER);
   module.set_async_parent_modules(roots.empty_array_list());
   module.set_pending_async_dependencies(0);
+  module.set_host_defined_options(*host_defined_options);
   return handle(module, isolate());
 }
 
diff --git a/deps/v8/src/heap/factory.h b/deps/v8/src/heap/factory.h
index 6c9cc2d4d8ed1e..e540698711c5b1 100644
--- a/deps/v8/src/heap/factory.h
+++ b/deps/v8/src/heap/factory.h
@@ -365,8 +365,9 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
   Handle<NativeContext> NewNativeContext();
 
   // Create a script context.
-  Handle<Context> NewScriptContext(Handle<NativeContext> outer,
-                                   Handle<ScopeInfo> scope_info);
+  Handle<Context> NewScriptContext(
+      Handle<NativeContext> outer, Handle<ScopeInfo> scope_info,
+      MaybeHandle<Object> maybe_host_defined_options = kNullMaybeHandle);
 
   // Create an empty script context table.
   Handle<ScriptContextTable> NewScriptContextTable();
@@ -681,7 +682,8 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
       Handle<WasmCapiFunctionData> data);
 #endif  // V8_ENABLE_WEBASSEMBLY
 
-  Handle<SourceTextModule> NewSourceTextModule(Handle<SharedFunctionInfo> code);
+  Handle<SourceTextModule> NewSourceTextModule(
+      Handle<SharedFunctionInfo> code, Handle<Object> host_defined_options);
   Handle<SyntheticModule> NewSyntheticModule(
       Handle<String> module_name, Handle<FixedArray> export_names,
       v8::Module::SyntheticModuleEvaluationSteps evaluation_steps);
diff --git a/deps/v8/src/ic/accessor-assembler.cc b/deps/v8/src/ic/accessor-assembler.cc
index 33bcb390610b5a..a1f1931c46df16 100644
--- a/deps/v8/src/ic/accessor-assembler.cc
+++ b/deps/v8/src/ic/accessor-assembler.cc
@@ -3434,13 +3434,9 @@ void AccessorAssembler::ScriptContextTableLookup(
         ScriptContextTable::kFirstContextSlotIndex * kTaggedSize));
     TNode<ScopeInfo> scope_info =
         CAST(LoadContextElement(script_context, Context::SCOPE_INFO_INDEX));
+    TNode<Object> result =
+        LoadContextElementWithName(scope_info, name, script_context, &loop);
 
-    TNode<IntPtrT> context_local_index =
-        IndexOfLocalName(scope_info, name, &loop);
-
-    TNode<IntPtrT> var_index = IntPtrAdd(
-        IntPtrConstant(Context::MIN_CONTEXT_SLOTS), context_local_index);
-    TNode<Object> result = LoadContextElement(script_context, var_index);
     GotoIf(IsTheHole(result), found_hole);
     Return(result);
   }
diff --git a/deps/v8/src/inspector/v8-inspector-impl.cc b/deps/v8/src/inspector/v8-inspector-impl.cc
index e437868f314a7f..3cc7e8ab952d3d 100644
--- a/deps/v8/src/inspector/v8-inspector-impl.cc
+++ b/deps/v8/src/inspector/v8-inspector-impl.cc
@@ -107,8 +107,7 @@ v8::MaybeLocal<v8::Value> V8InspectorImpl::compileAndRunInternalScript(
 v8::MaybeLocal<v8::Script> V8InspectorImpl::compileScript(
     v8::Local<v8::Context> context, const String16& code,
     const String16& fileName) {
-  v8::ScriptOrigin origin(m_isolate, toV8String(m_isolate, fileName), 0, 0,
-                          false);
+  v8::ScriptOrigin origin(toV8String(m_isolate, fileName), 0, 0, false);
   v8::ScriptCompiler::Source source(toV8String(m_isolate, code), origin);
   return v8::ScriptCompiler::Compile(context, &source,
                                      v8::ScriptCompiler::kNoCompileOptions);
diff --git a/deps/v8/src/objects/compilation-cache-table-inl.h b/deps/v8/src/objects/compilation-cache-table-inl.h
index 831cc474fe6493..395a7a264f123a 100644
--- a/deps/v8/src/objects/compilation-cache-table-inl.h
+++ b/deps/v8/src/objects/compilation-cache-table-inl.h
@@ -66,8 +66,7 @@ class ScriptCacheKey : public HashTableKey {
                  Isolate* isolate);
   ScriptCacheKey(Handle<String> source, MaybeHandle<Object> name,
                  int line_offset, int column_offset,
-                 v8::ScriptOriginOptions origin_options,
-                 MaybeHandle<Object> host_defined_options, Isolate* isolate);
+                 v8::ScriptOriginOptions origin_options, Isolate* isolate);
 
   bool IsMatch(Object other) override;
   bool MatchesOrigin(Script script);
@@ -97,7 +96,6 @@ class ScriptCacheKey : public HashTableKey {
   int line_offset_;
   int column_offset_;
   v8::ScriptOriginOptions origin_options_;
-  MaybeHandle<Object> host_defined_options_;
   Isolate* isolate_;
 };
 
diff --git a/deps/v8/src/objects/compilation-cache-table.cc b/deps/v8/src/objects/compilation-cache-table.cc
index 0377c92888061d..e31309cbd536eb 100644
--- a/deps/v8/src/objects/compilation-cache-table.cc
+++ b/deps/v8/src/objects/compilation-cache-table.cc
@@ -267,26 +267,6 @@ bool ScriptCacheKey::MatchesOrigin(Script script) {
   if (!String::cast(*name).Equals(String::cast(script.name()))) {
     return false;
   }
-
-  // TODO(cbruni, chromium:1244145): Remove once migrated to the context
-  Handle<Object> maybe_host_defined_options;
-  if (!host_defined_options_.ToHandle(&maybe_host_defined_options)) {
-    maybe_host_defined_options = isolate_->factory()->empty_fixed_array();
-  }
-  FixedArray host_defined_options =
-      FixedArray::cast(*maybe_host_defined_options);
-  FixedArray script_options = FixedArray::cast(script.host_defined_options());
-  int length = host_defined_options.length();
-  if (length != script_options.length()) return false;
-
-  for (int i = 0; i < length; i++) {
-    // host-defined options is a v8::PrimitiveArray.
-    DCHECK(host_defined_options.get(i).IsPrimitive());
-    DCHECK(script_options.get(i).IsPrimitive());
-    if (!host_defined_options.get(i).StrictEquals(script_options.get(i))) {
-      return false;
-    }
-  }
   return true;
 }
 
@@ -295,13 +275,11 @@ ScriptCacheKey::ScriptCacheKey(Handle<String> source,
                                Isolate* isolate)
     : ScriptCacheKey(source, script_details->name_obj,
                      script_details->line_offset, script_details->column_offset,
-                     script_details->origin_options,
-                     script_details->host_defined_options, isolate) {}
+                     script_details->origin_options, isolate) {}
 
 ScriptCacheKey::ScriptCacheKey(Handle<String> source, MaybeHandle<Object> name,
                                int line_offset, int column_offset,
                                v8::ScriptOriginOptions origin_options,
-                               MaybeHandle<Object> host_defined_options,
                                Isolate* isolate)
     : HashTableKey(static_cast<uint32_t>(ScriptHash(*source, name, line_offset,
                                                     column_offset,
@@ -312,7 +290,6 @@ ScriptCacheKey::ScriptCacheKey(Handle<String> source, MaybeHandle<Object> name,
       line_offset_(line_offset),
       column_offset_(column_offset),
       origin_options_(origin_options),
-      host_defined_options_(host_defined_options),
       isolate_(isolate) {
   DCHECK(Smi::IsValid(static_cast<int>(Hash())));
 }
@@ -469,11 +446,9 @@ Handle<CompilationCacheTable> CompilationCacheTable::PutScript(
   if (script->name().IsString(isolate)) {
     script_name = handle(script->name(), isolate);
   }
-  Handle<FixedArray> host_defined_options(script->host_defined_options(),
-                                          isolate);
   ScriptCacheKey key(src, script_name, script->line_offset(),
                      script->column_offset(), script->origin_options(),
-                     host_defined_options, isolate);
+                     isolate);
   Handle<Object> k = key.AsHandle(isolate, value);
 
   // Check whether there is already a matching entry. If so, we must overwrite
diff --git a/deps/v8/src/objects/contexts-inl.h b/deps/v8/src/objects/contexts-inl.h
index 8f552a13e91e65..2ecbe773ee7807 100644
--- a/deps/v8/src/objects/contexts-inl.h
+++ b/deps/v8/src/objects/contexts-inl.h
@@ -132,9 +132,9 @@ bool Context::has_extension() const {
   return scope_info().HasContextExtensionSlot() && !extension().IsUndefined();
 }
 
-HeapObject Context::extension() const {
+Object Context::extension() const {
   DCHECK(scope_info().HasContextExtensionSlot());
-  return HeapObject::cast(get(EXTENSION_INDEX));
+  return Object::cast(get(EXTENSION_INDEX));
 }
 
 NativeContext Context::native_context() const {
diff --git a/deps/v8/src/objects/contexts.cc b/deps/v8/src/objects/contexts.cc
index e35e7ee7e40d7d..0ae3fe3120fc87 100644
--- a/deps/v8/src/objects/contexts.cc
+++ b/deps/v8/src/objects/contexts.cc
@@ -124,7 +124,7 @@ Context Context::closure_context() const {
 JSObject Context::extension_object() const {
   DCHECK(IsNativeContext() || IsFunctionContext() || IsBlockContext() ||
          IsEvalContext() || IsCatchContext());
-  HeapObject object = extension();
+  Object object = extension();
   if (object.IsUndefined()) return JSObject();
   DCHECK(object.IsJSContextExtensionObject() ||
          (IsNativeContext() && object.IsJSGlobalObject()));
@@ -138,6 +138,7 @@ JSReceiver Context::extension_receiver() const {
 }
 
 SourceTextModule Context::module() const {
+  DisallowGarbageCollection no_gc;
   Context current = *this;
   while (!current.IsModuleContext()) {
     current = current.previous();
@@ -145,6 +146,29 @@ SourceTextModule Context::module() const {
   return SourceTextModule::cast(current.extension());
 }
 
+Object Context::host_defined_options() const {
+  Context current = *this;
+  DisallowGarbageCollection no_gc;
+  while (true) {
+    if (current.IsModuleContext()) {
+      return SourceTextModule::cast(current.extension()).host_defined_options();
+    } else if (current.IsScriptContext()) {
+      if (current.has_extension()) {
+        return FixedArray::cast(current.extension());
+      } else {
+        // TODO(cbruni): decide to go all or nothing on context extension
+        // allocated host-defined options.
+        return ReadOnlyRoots(GetIsolate()).empty_fixed_array();
+      }
+    } else if (current.IsNativeContext()) {
+      // TODO(cbruni): decide to go all or nothing on context extension
+      // allocated host-defined options.
+      return ReadOnlyRoots(GetIsolate()).empty_fixed_array();
+    }
+    current = current.previous();
+  }
+}
+
 JSGlobalObject Context::global_object() const {
   return JSGlobalObject::cast(native_context().extension());
 }
@@ -511,13 +535,13 @@ namespace {
 // TODO(v8:12298): Fix js-context-specialization cctests to set up full
 // native contexts instead of using dummy internalized strings as
 // extensions.
-bool IsContexExtensionTestObject(HeapObject extension) {
+bool IsContexExtensionTestObject(Object extension) {
   return extension.IsInternalizedString() &&
          String::cast(extension).length() == 1;
 }
 }  // namespace
 
-void Context::VerifyExtensionSlot(HeapObject extension) {
+void Context::VerifyExtensionSlot(Object extension) {
   CHECK(scope_info().HasContextExtensionSlot());
   // Early exit for potentially uninitialized contexfts.
   if (extension.IsUndefined()) return;
@@ -539,7 +563,7 @@ void Context::VerifyExtensionSlot(HeapObject extension) {
 }
 #endif  // VERIFY_HEAP
 
-void Context::set_extension(HeapObject object, WriteBarrierMode mode) {
+void Context::set_extension(Object object, WriteBarrierMode mode) {
   DCHECK(scope_info().HasContextExtensionSlot());
 #ifdef VERIFY_HEAP
   VerifyExtensionSlot(object);
diff --git a/deps/v8/src/objects/contexts.cc.orig b/deps/v8/src/objects/contexts.cc.orig
new file mode 100644
index 00000000000000..e35e7ee7e40d7d
--- /dev/null
+++ b/deps/v8/src/objects/contexts.cc.orig
@@ -0,0 +1,652 @@
+// Copyright 2011 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/objects/contexts.h"
+
+#include "src/ast/modules.h"
+#include "src/debug/debug.h"
+#include "src/execution/isolate-inl.h"
+#include "src/init/bootstrapper.h"
+#include "src/objects/module-inl.h"
+#include "src/objects/string-set-inl.h"
+
+namespace v8 {
+namespace internal {
+
+void ScriptContextTable::AddLocalNamesFromContext(
+    Isolate* isolate, Handle<ScriptContextTable> script_context_table,
+    Handle<Context> script_context, bool ignore_duplicates,
+    int script_context_index) {
+  ReadOnlyRoots roots(isolate);
+  PtrComprCageBase cage_base(isolate);
+  Handle<NameToIndexHashTable> names_table(
+      script_context_table->names_to_context_index(cage_base), isolate);
+  Handle<ScopeInfo> scope_info(script_context->scope_info(cage_base), isolate);
+  int local_count = scope_info->ContextLocalCount();
+  names_table = names_table->EnsureCapacity(isolate, names_table, local_count);
+  for (auto it : ScopeInfo::IterateLocalNames(scope_info)) {
+    Handle<Name> name(it->name(cage_base), isolate);
+    if (ignore_duplicates) {
+      int32_t hash = NameToIndexShape::Hash(roots, name);
+      if (names_table->FindEntry(cage_base, roots, name, hash).is_found()) {
+        continue;
+      }
+    }
+    names_table = NameToIndexHashTable::Add(isolate, names_table, name,
+                                            script_context_index);
+  }
+  script_context_table->set_names_to_context_index(*names_table);
+}
+
+Handle<ScriptContextTable> ScriptContextTable::Extend(
+    Isolate* isolate, Handle<ScriptContextTable> table,
+    Handle<Context> script_context, bool ignore_duplicates) {
+  Handle<ScriptContextTable> result;
+  int used = table->used(kAcquireLoad);
+  int length = table->length();
+  CHECK(used >= 0 && length > 0 && used < length);
+  if (used + kFirstContextSlotIndex == length) {
+    CHECK(length < Smi::kMaxValue / 2);
+    Handle<FixedArray> copy =
+        isolate->factory()->CopyFixedArrayAndGrow(table, length);
+    copy->set_map(ReadOnlyRoots(isolate).script_context_table_map());
+    result = Handle<ScriptContextTable>::cast(copy);
+  } else {
+    result = table;
+  }
+  DCHECK(script_context->IsScriptContext());
+  ScriptContextTable::AddLocalNamesFromContext(isolate, result, script_context,
+                                               ignore_duplicates, used);
+  result->set(used + kFirstContextSlotIndex, *script_context, kReleaseStore);
+  result->set_used(used + 1, kReleaseStore);
+  return result;
+}
+
+void Context::Initialize(Isolate* isolate) {
+  ScopeInfo scope_info = this->scope_info();
+  int header = scope_info.ContextHeaderLength();
+  for (int var = 0; var < scope_info.ContextLocalCount(); var++) {
+    if (scope_info.ContextLocalInitFlag(var) == kNeedsInitialization) {
+      set(header + var, ReadOnlyRoots(isolate).the_hole_value());
+    }
+  }
+}
+
+bool ScriptContextTable::Lookup(Handle<String> name,
+                                VariableLookupResult* result) {
+  DisallowGarbageCollection no_gc;
+  int index = names_to_context_index().Lookup(name);
+  if (index == -1) return false;
+  DCHECK_LE(0, index);
+  DCHECK_LT(index, used(kAcquireLoad));
+  Context context = get_context(index);
+  DCHECK(context.IsScriptContext());
+  int slot_index = context.scope_info().ContextSlotIndex(name, result);
+  if (slot_index >= 0) {
+    result->context_index = index;
+    result->slot_index = slot_index;
+    return true;
+  }
+  return false;
+}
+
+bool Context::is_declaration_context() const {
+  if (IsFunctionContext() || IsNativeContext() || IsScriptContext() ||
+      IsModuleContext()) {
+    return true;
+  }
+  if (IsEvalContext()) {
+    return scope_info().language_mode() == LanguageMode::kStrict;
+  }
+  if (!IsBlockContext()) return false;
+  return scope_info().is_declaration_scope();
+}
+
+Context Context::declaration_context() const {
+  Context current = *this;
+  while (!current.is_declaration_context()) {
+    current = current.previous();
+  }
+  return current;
+}
+
+Context Context::closure_context() const {
+  Context current = *this;
+  while (!current.IsFunctionContext() && !current.IsScriptContext() &&
+         !current.IsModuleContext() && !current.IsNativeContext() &&
+         !current.IsEvalContext()) {
+    current = current.previous();
+  }
+  return current;
+}
+
+JSObject Context::extension_object() const {
+  DCHECK(IsNativeContext() || IsFunctionContext() || IsBlockContext() ||
+         IsEvalContext() || IsCatchContext());
+  HeapObject object = extension();
+  if (object.IsUndefined()) return JSObject();
+  DCHECK(object.IsJSContextExtensionObject() ||
+         (IsNativeContext() && object.IsJSGlobalObject()));
+  return JSObject::cast(object);
+}
+
+JSReceiver Context::extension_receiver() const {
+  DCHECK(IsNativeContext() || IsWithContext() || IsEvalContext() ||
+         IsFunctionContext() || IsBlockContext());
+  return IsWithContext() ? JSReceiver::cast(extension()) : extension_object();
+}
+
+SourceTextModule Context::module() const {
+  Context current = *this;
+  while (!current.IsModuleContext()) {
+    current = current.previous();
+  }
+  return SourceTextModule::cast(current.extension());
+}
+
+JSGlobalObject Context::global_object() const {
+  return JSGlobalObject::cast(native_context().extension());
+}
+
+Context Context::script_context() const {
+  Context current = *this;
+  while (!current.IsScriptContext()) {
+    current = current.previous();
+  }
+  return current;
+}
+
+JSGlobalProxy Context::global_proxy() const {
+  return native_context().global_proxy_object();
+}
+
+/**
+ * Lookups a property in an object environment, taking the unscopables into
+ * account. This is used For HasBinding spec algorithms for ObjectEnvironment.
+ */
+static Maybe<bool> UnscopableLookup(LookupIterator* it, bool is_with_context) {
+  Isolate* isolate = it->isolate();
+
+  Maybe<bool> found = JSReceiver::HasProperty(it);
+  if (!is_with_context || found.IsNothing() || !found.FromJust()) return found;
+
+  Handle<Object> unscopables;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, unscopables,
+      JSReceiver::GetProperty(isolate,
+                              Handle<JSReceiver>::cast(it->GetReceiver()),
+                              isolate->factory()->unscopables_symbol()),
+      Nothing<bool>());
+  if (!unscopables->IsJSReceiver()) return Just(true);
+  Handle<Object> blocklist;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, blocklist,
+      JSReceiver::GetProperty(isolate, Handle<JSReceiver>::cast(unscopables),
+                              it->name()),
+      Nothing<bool>());
+  return Just(!blocklist->BooleanValue(isolate));
+}
+
+static PropertyAttributes GetAttributesForMode(VariableMode mode) {
+  DCHECK(IsSerializableVariableMode(mode));
+  return IsConstVariableMode(mode) ? READ_ONLY : NONE;
+}
+
+// static
+Handle<Object> Context::Lookup(Handle<Context> context, Handle<String> name,
+                               ContextLookupFlags flags, int* index,
+                               PropertyAttributes* attributes,
+                               InitializationFlag* init_flag,
+                               VariableMode* variable_mode,
+                               bool* is_sloppy_function_name) {
+  Isolate* isolate = context->GetIsolate();
+
+  bool follow_context_chain = (flags & FOLLOW_CONTEXT_CHAIN) != 0;
+  bool has_seen_debug_evaluate_context = false;
+  *index = kNotFound;
+  *attributes = ABSENT;
+  *init_flag = kCreatedInitialized;
+  *variable_mode = VariableMode::kVar;
+  if (is_sloppy_function_name != nullptr) {
+    *is_sloppy_function_name = false;
+  }
+
+  if (v8_flags.trace_contexts) {
+    PrintF("Context::Lookup(");
+    name->ShortPrint();
+    PrintF(")\n");
+  }
+
+  do {
+    if (v8_flags.trace_contexts) {
+      PrintF(" - looking in context %p",
+             reinterpret_cast<void*>(context->ptr()));
+      if (context->IsScriptContext()) PrintF(" (script context)");
+      if (context->IsNativeContext()) PrintF(" (native context)");
+      if (context->IsDebugEvaluateContext()) PrintF(" (debug context)");
+      PrintF("\n");
+    }
+
+    // 1. Check global objects, subjects of with, and extension objects.
+    DCHECK_IMPLIES(context->IsEvalContext() && context->has_extension(),
+                   context->extension().IsTheHole(isolate));
+    if ((context->IsNativeContext() || context->IsWithContext() ||
+         context->IsFunctionContext() || context->IsBlockContext()) &&
+        context->has_extension() && !context->extension_receiver().is_null()) {
+      Handle<JSReceiver> object(context->extension_receiver(), isolate);
+
+      if (context->IsNativeContext()) {
+        DisallowGarbageCollection no_gc;
+        if (v8_flags.trace_contexts) {
+          PrintF(" - trying other script contexts\n");
+        }
+        // Try other script contexts.
+        ScriptContextTable script_contexts =
+            context->global_object().native_context().script_context_table();
+        VariableLookupResult r;
+        if (script_contexts.Lookup(name, &r)) {
+          Context script_context = script_contexts.get_context(r.context_index);
+          if (v8_flags.trace_contexts) {
+            PrintF("=> found property in script context %d: %p\n",
+                   r.context_index,
+                   reinterpret_cast<void*>(script_context.ptr()));
+          }
+          *index = r.slot_index;
+          *variable_mode = r.mode;
+          *init_flag = r.init_flag;
+          *attributes = GetAttributesForMode(r.mode);
+          return handle(script_context, isolate);
+        }
+      }
+
+      // Context extension objects needs to behave as if they have no
+      // prototype.  So even if we want to follow prototype chains, we need
+      // to only do a local lookup for context extension objects.
+      Maybe<PropertyAttributes> maybe = Nothing<PropertyAttributes>();
+      if ((flags & FOLLOW_PROTOTYPE_CHAIN) == 0 ||
+          object->IsJSContextExtensionObject()) {
+        maybe = JSReceiver::GetOwnPropertyAttributes(object, name);
+      } else {
+        // A with context will never bind "this", but debug-eval may look into
+        // a with context when resolving "this". Other synthetic variables such
+        // as new.target may be resolved as VariableMode::kDynamicLocal due to
+        // bug v8:5405 , skipping them here serves as a workaround until a more
+        // thorough fix can be applied.
+        // TODO(v8:5405): Replace this check with a DCHECK when resolution of
+        // of synthetic variables does not go through this code path.
+        if (ScopeInfo::VariableIsSynthetic(*name)) {
+          DCHECK(context->IsWithContext());
+          maybe = Just(ABSENT);
+        } else {
+          LookupIterator it(isolate, object, name, object);
+          Maybe<bool> found = UnscopableLookup(&it, context->IsWithContext());
+          if (found.IsNothing()) {
+            maybe = Nothing<PropertyAttributes>();
+          } else {
+            // Luckily, consumers of |maybe| only care whether the property
+            // was absent or not, so we can return a dummy |NONE| value
+            // for its attributes when it was present.
+            maybe = Just(found.FromJust() ? NONE : ABSENT);
+          }
+        }
+      }
+
+      if (maybe.IsNothing()) return Handle<Object>();
+      DCHECK(!isolate->has_pending_exception());
+      *attributes = maybe.FromJust();
+
+      if (maybe.FromJust() != ABSENT) {
+        if (v8_flags.trace_contexts) {
+          PrintF("=> found property in context object %p\n",
+                 reinterpret_cast<void*>(object->ptr()));
+        }
+        return object;
+      }
+    }
+
+    // 2. Check the context proper if it has slots.
+    if (context->IsFunctionContext() || context->IsBlockContext() ||
+        context->IsScriptContext() || context->IsEvalContext() ||
+        context->IsModuleContext() || context->IsCatchContext()) {
+      DisallowGarbageCollection no_gc;
+      // Use serialized scope information of functions and blocks to search
+      // for the context index.
+      ScopeInfo scope_info = context->scope_info();
+      VariableLookupResult lookup_result;
+      int slot_index = scope_info.ContextSlotIndex(name, &lookup_result);
+      DCHECK(slot_index < 0 || slot_index >= MIN_CONTEXT_SLOTS);
+      if (slot_index >= 0) {
+        // Re-direct lookup to the ScriptContextTable in case we find a hole in
+        // a REPL script context. REPL scripts allow re-declaration of
+        // script-level let bindings. The value itself is stored in the script
+        // context of the first script that declared a variable, all other
+        // script contexts will contain 'the hole' for that particular name.
+        if (scope_info.IsReplModeScope() &&
+            context->get(slot_index).IsTheHole(isolate)) {
+          context = Handle<Context>(context->previous(), isolate);
+          continue;
+        }
+
+        if (v8_flags.trace_contexts) {
+          PrintF("=> found local in context slot %d (mode = %hhu)\n",
+                 slot_index, static_cast<uint8_t>(lookup_result.mode));
+        }
+        *index = slot_index;
+        *variable_mode = lookup_result.mode;
+        *init_flag = lookup_result.init_flag;
+        *attributes = GetAttributesForMode(lookup_result.mode);
+        return context;
+      }
+
+      // Check the slot corresponding to the intermediate context holding
+      // only the function name variable. It's conceptually (and spec-wise)
+      // in an outer scope of the function's declaration scope.
+      if (follow_context_chain && context->IsFunctionContext()) {
+        int function_index = scope_info.FunctionContextSlotIndex(*name);
+        if (function_index >= 0) {
+          if (v8_flags.trace_contexts) {
+            PrintF("=> found intermediate function in context slot %d\n",
+                   function_index);
+          }
+          *index = function_index;
+          *attributes = READ_ONLY;
+          *init_flag = kCreatedInitialized;
+          *variable_mode = VariableMode::kConst;
+          if (is_sloppy_function_name != nullptr &&
+              is_sloppy(scope_info.language_mode())) {
+            *is_sloppy_function_name = true;
+          }
+          return context;
+        }
+      }
+
+      // Lookup variable in module imports and exports.
+      if (context->IsModuleContext()) {
+        VariableMode mode;
+        InitializationFlag flag;
+        MaybeAssignedFlag maybe_assigned_flag;
+        int cell_index =
+            scope_info.ModuleIndex(*name, &mode, &flag, &maybe_assigned_flag);
+        if (cell_index != 0) {
+          if (v8_flags.trace_contexts) {
+            PrintF("=> found in module imports or exports\n");
+          }
+          *index = cell_index;
+          *variable_mode = mode;
+          *init_flag = flag;
+          *attributes = SourceTextModuleDescriptor::GetCellIndexKind(
+                            cell_index) == SourceTextModuleDescriptor::kExport
+                            ? GetAttributesForMode(mode)
+                            : READ_ONLY;
+          return handle(context->module(), isolate);
+        }
+      }
+    } else if (context->IsDebugEvaluateContext()) {
+      has_seen_debug_evaluate_context = true;
+
+      // Check materialized locals.
+      Object ext = context->get(EXTENSION_INDEX);
+      if (ext.IsJSReceiver()) {
+        Handle<JSReceiver> extension(JSReceiver::cast(ext), isolate);
+        LookupIterator it(isolate, extension, name, extension);
+        Maybe<bool> found = JSReceiver::HasProperty(&it);
+        if (found.FromMaybe(false)) {
+          *attributes = NONE;
+          return extension;
+        }
+      }
+
+      // Check blocklist. Names that are listed, cannot be resolved further.
+      ScopeInfo scope_info = context->scope_info();
+      CHECK_IMPLIES(v8_flags.experimental_reuse_locals_blocklists,
+                    !scope_info.HasLocalsBlockList());
+      if (scope_info.HasLocalsBlockList() &&
+          scope_info.LocalsBlockList().Has(isolate, name)) {
+        if (v8_flags.trace_contexts) {
+          PrintF(" - name is blocklisted. Aborting.\n");
+        }
+        break;
+      }
+
+      // Check the original context, but do not follow its context chain.
+      Object obj = context->get(WRAPPED_CONTEXT_INDEX);
+      if (obj.IsContext()) {
+        Handle<Context> wrapped_context(Context::cast(obj), isolate);
+        Handle<Object> result =
+            Context::Lookup(wrapped_context, name, DONT_FOLLOW_CHAINS, index,
+                            attributes, init_flag, variable_mode);
+        if (!result.is_null()) return result;
+      }
+    }
+
+    // 3. Prepare to continue with the previous (next outermost) context.
+    if (context->IsNativeContext()) break;
+
+    // In case we saw any DebugEvaluateContext, we'll need to check the block
+    // list before we can advance to properly "shadow" stack-allocated
+    // variables.
+    // Note that this implicitly skips the block list check for the
+    // "wrapped" context lookup for DebugEvaluateContexts. In that case
+    // `has_seen_debug_evaluate_context` will always be false.
+    if (v8_flags.experimental_reuse_locals_blocklists &&
+        has_seen_debug_evaluate_context &&
+        isolate->heap()->locals_block_list_cache().IsEphemeronHashTable()) {
+      Handle<ScopeInfo> scope_info = handle(context->scope_info(), isolate);
+      Object maybe_outer_block_list =
+          isolate->LocalsBlockListCacheGet(scope_info);
+      if (maybe_outer_block_list.IsStringSet() &&
+          StringSet::cast(maybe_outer_block_list).Has(isolate, name)) {
+        if (v8_flags.trace_contexts) {
+          PrintF(" - name is blocklisted. Aborting.\n");
+        }
+        break;
+      }
+    }
+
+    context = Handle<Context>(context->previous(), isolate);
+  } while (follow_context_chain);
+
+  if (v8_flags.trace_contexts) {
+    PrintF("=> no property/slot found\n");
+  }
+  return Handle<Object>::null();
+}
+
+bool NativeContext::HasTemplateLiteralObject(JSArray array) {
+  return array.map() == js_array_template_literal_object_map();
+}
+
+void NativeContext::AddOptimizedCode(CodeT code) {
+  DCHECK(CodeKindCanDeoptimize(code.kind()));
+  DCHECK(code.next_code_link().IsUndefined());
+  code.set_next_code_link(OptimizedCodeListHead());
+  set(OPTIMIZED_CODE_LIST, code, UPDATE_WRITE_BARRIER, kReleaseStore);
+}
+
+Handle<Object> Context::ErrorMessageForCodeGenerationFromStrings() {
+  Isolate* isolate = GetIsolate();
+  Handle<Object> result(error_message_for_code_gen_from_strings(), isolate);
+  if (!result->IsUndefined(isolate)) return result;
+  return isolate->factory()->NewStringFromStaticChars(
+      "Code generation from strings disallowed for this context");
+}
+
+Handle<Object> Context::ErrorMessageForWasmCodeGeneration() {
+  Isolate* isolate = GetIsolate();
+  Handle<Object> result(error_message_for_wasm_code_gen(), isolate);
+  if (!result->IsUndefined(isolate)) return result;
+  return isolate->factory()->NewStringFromStaticChars(
+      "Wasm code generation disallowed by embedder");
+}
+
+#define COMPARE_NAME(index, type, name) \
+  if (string->IsOneByteEqualTo(base::StaticCharVector(#name))) return index;
+
+int Context::IntrinsicIndexForName(Handle<String> string) {
+  NATIVE_CONTEXT_INTRINSIC_FUNCTIONS(COMPARE_NAME);
+  return kNotFound;
+}
+
+#undef COMPARE_NAME
+
+#define COMPARE_NAME(index, type, name)                                      \
+  {                                                                          \
+    const int name_length = static_cast<int>(arraysize(#name)) - 1;          \
+    if ((length == name_length) && strncmp(string, #name, name_length) == 0) \
+      return index;                                                          \
+  }
+
+int Context::IntrinsicIndexForName(const unsigned char* unsigned_string,
+                                   int length) {
+  const char* string = reinterpret_cast<const char*>(unsigned_string);
+  NATIVE_CONTEXT_INTRINSIC_FUNCTIONS(COMPARE_NAME);
+  return kNotFound;
+}
+
+#undef COMPARE_NAME
+
+#ifdef VERIFY_HEAP
+namespace {
+// TODO(v8:12298): Fix js-context-specialization cctests to set up full
+// native contexts instead of using dummy internalized strings as
+// extensions.
+bool IsContexExtensionTestObject(HeapObject extension) {
+  return extension.IsInternalizedString() &&
+         String::cast(extension).length() == 1;
+}
+}  // namespace
+
+void Context::VerifyExtensionSlot(HeapObject extension) {
+  CHECK(scope_info().HasContextExtensionSlot());
+  // Early exit for potentially uninitialized contexfts.
+  if (extension.IsUndefined()) return;
+  if (extension.IsJSContextExtensionObject()) {
+    CHECK((IsBlockContext() && scope_info().is_declaration_scope()) ||
+          IsFunctionContext());
+  } else if (IsModuleContext()) {
+    CHECK(extension.IsSourceTextModule());
+  } else if (IsDebugEvaluateContext() || IsWithContext()) {
+    CHECK(extension.IsJSReceiver() ||
+          (IsWithContext() && IsContexExtensionTestObject(extension)));
+  } else if (IsNativeContext()) {
+    CHECK(extension.IsJSGlobalObject() ||
+          IsContexExtensionTestObject(extension));
+  } else if (IsScriptContext()) {
+    // Host-defined options can be stored on the context for classic scripts.
+    CHECK(extension.IsFixedArray());
+  }
+}
+#endif  // VERIFY_HEAP
+
+void Context::set_extension(HeapObject object, WriteBarrierMode mode) {
+  DCHECK(scope_info().HasContextExtensionSlot());
+#ifdef VERIFY_HEAP
+  VerifyExtensionSlot(object);
+#endif
+  set(EXTENSION_INDEX, object, mode);
+}
+
+#ifdef DEBUG
+
+bool Context::IsBootstrappingOrValidParentContext(Object object,
+                                                  Context child) {
+  // During bootstrapping we allow all objects to pass as
+  // contexts. This is necessary to fix circular dependencies.
+  if (child.GetIsolate()->bootstrapper()->IsActive()) return true;
+  if (!object.IsContext()) return false;
+  Context context = Context::cast(object);
+  return context.IsNativeContext() || context.IsScriptContext() ||
+         context.IsModuleContext() || !child.IsModuleContext();
+}
+
+#endif
+
+void NativeContext::ResetErrorsThrown() { set_errors_thrown(Smi::FromInt(0)); }
+
+void NativeContext::IncrementErrorsThrown() {
+  int previous_value = errors_thrown().value();
+  set_errors_thrown(Smi::FromInt(previous_value + 1));
+}
+
+int NativeContext::GetErrorsThrown() { return errors_thrown().value(); }
+
+static_assert(Context::MIN_CONTEXT_SLOTS == 2);
+static_assert(Context::MIN_CONTEXT_EXTENDED_SLOTS == 3);
+static_assert(NativeContext::kScopeInfoOffset ==
+              Context::OffsetOfElementAt(NativeContext::SCOPE_INFO_INDEX));
+static_assert(NativeContext::kPreviousOffset ==
+              Context::OffsetOfElementAt(NativeContext::PREVIOUS_INDEX));
+static_assert(NativeContext::kExtensionOffset ==
+              Context::OffsetOfElementAt(NativeContext::EXTENSION_INDEX));
+
+static_assert(NativeContext::kStartOfStrongFieldsOffset ==
+              Context::OffsetOfElementAt(-1));
+static_assert(NativeContext::kStartOfWeakFieldsOffset ==
+              Context::OffsetOfElementAt(NativeContext::FIRST_WEAK_SLOT));
+static_assert(NativeContext::kMicrotaskQueueOffset ==
+              Context::SizeFor(NativeContext::NATIVE_CONTEXT_SLOTS));
+static_assert(NativeContext::kSize ==
+              (Context::SizeFor(NativeContext::NATIVE_CONTEXT_SLOTS) +
+               kSystemPointerSize));
+
+#ifdef V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS
+void NativeContext::RunPromiseHook(PromiseHookType type,
+                                   Handle<JSPromise> promise,
+                                   Handle<Object> parent) {
+  Isolate* isolate = promise->GetIsolate();
+  DCHECK(isolate->HasContextPromiseHooks());
+  int contextSlot;
+
+  switch (type) {
+    case PromiseHookType::kInit:
+      contextSlot = PROMISE_HOOK_INIT_FUNCTION_INDEX;
+      break;
+    case PromiseHookType::kResolve:
+      contextSlot = PROMISE_HOOK_RESOLVE_FUNCTION_INDEX;
+      break;
+    case PromiseHookType::kBefore:
+      contextSlot = PROMISE_HOOK_BEFORE_FUNCTION_INDEX;
+      break;
+    case PromiseHookType::kAfter:
+      contextSlot = PROMISE_HOOK_AFTER_FUNCTION_INDEX;
+      break;
+    default:
+      UNREACHABLE();
+  }
+
+  Handle<Object> hook(isolate->native_context()->get(contextSlot), isolate);
+  if (hook->IsUndefined()) return;
+
+  int argc = type == PromiseHookType::kInit ? 2 : 1;
+  Handle<Object> argv[2] = {
+    Handle<Object>::cast(promise),
+    parent
+  };
+
+  Handle<Object> receiver = isolate->global_proxy();
+
+  StackLimitCheck check(isolate);
+  bool failed = false;
+  if (check.HasOverflowed()) {
+    isolate->StackOverflow();
+    failed = true;
+  } else {
+    failed = Execution::Call(isolate, hook, receiver, argc, argv).is_null();
+  }
+  if (failed) {
+    DCHECK(isolate->has_pending_exception());
+    Handle<Object> exception(isolate->pending_exception(), isolate);
+
+    MessageLocation* no_location = nullptr;
+    Handle<JSMessageObject> message =
+        isolate->CreateMessageOrAbort(exception, no_location);
+    MessageHandler::ReportMessage(isolate, no_location, message);
+
+    isolate->clear_pending_exception();
+  }
+}
+#endif
+
+}  // namespace internal
+}  // namespace v8
diff --git a/deps/v8/src/objects/contexts.h b/deps/v8/src/objects/contexts.h
index 7e1e715038ff6c..08b7638a8a990d 100644
--- a/deps/v8/src/objects/contexts.h
+++ b/deps/v8/src/objects/contexts.h
@@ -594,15 +594,16 @@ class Context : public TorqueGeneratedContext<Context, HeapObject> {
   inline Object next_context_link() const;
 
   inline bool has_extension() const;
-  inline HeapObject extension() const;
+  inline Object extension() const;
   V8_EXPORT_PRIVATE void set_extension(
-      HeapObject object, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
+      Object object, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
   JSObject extension_object() const;
   JSReceiver extension_receiver() const;
 
   // Find the module context (assuming there is one) and return the associated
   // module object.
   SourceTextModule module() const;
+  Object host_defined_options() const;
 
   // Get the context where var declarations will be hoisted to, which
   // may be the context itself.
@@ -699,7 +700,7 @@ class Context : public TorqueGeneratedContext<Context, HeapObject> {
   class BodyDescriptor;
 
 #ifdef VERIFY_HEAP
-  V8_EXPORT_PRIVATE void VerifyExtensionSlot(HeapObject extension);
+  V8_EXPORT_PRIVATE void VerifyExtensionSlot(Object extension);
 #endif
 
  private:
diff --git a/deps/v8/src/objects/module.tq b/deps/v8/src/objects/module.tq
index e28bad94086015..98990da19674fb 100644
--- a/deps/v8/src/objects/module.tq
+++ b/deps/v8/src/objects/module.tq
@@ -23,5 +23,5 @@ extern class JSModuleNamespace extends JSSpecialObject {
 
 extern class ScriptOrModule extends Struct {
   resource_name: Object;
-  host_defined_options: FixedArray;
+  host_defined_options: Object;
 }
diff --git a/deps/v8/src/objects/scope-info-inl.h b/deps/v8/src/objects/scope-info-inl.h
index ae8c60129fda39..5566f2c8249482 100644
--- a/deps/v8/src/objects/scope-info-inl.h
+++ b/deps/v8/src/objects/scope-info-inl.h
@@ -33,6 +33,14 @@ int ScopeInfo::ContextLocalCount() const { return context_local_count(); }
 
 ObjectSlot ScopeInfo::data_start() { return RawField(OffsetOfElementAt(0)); }
 
+bool ScopeInfo::HasContextExtensionSlot() const {
+  return HasContextExtensionSlotBit::decode(Flags());
+}
+
+bool ScopeInfo::NeedsContext() const {
+  return ContextLocalCount() > 0 || HasContextExtensionSlot();
+}
+
 bool ScopeInfo::HasInlinedLocalNames() const {
   return ContextLocalCount() < kScopeInfoMaxInlinedLocalNamesSize;
 }
diff --git a/deps/v8/src/objects/scope-info.cc b/deps/v8/src/objects/scope-info.cc
index 045f6c1cecea38..c7205779fb38f7 100644
--- a/deps/v8/src/objects/scope-info.cc
+++ b/deps/v8/src/objects/scope-info.cc
@@ -243,12 +243,13 @@ Handle<ScopeInfo> ScopeInfo::Create(IsolateT* isolate, Zone* zone, Scope* scope,
         HasOuterScopeInfoBit::encode(has_outer_scope_info) |
         IsDebugEvaluateScopeBit::encode(scope->is_debug_evaluate_scope()) |
         ForceContextAllocationBit::encode(
-            scope->ForceContextForLanguageMode()) |
+            scope->ForceContextForLanguageMode() ||
+            scope->NeedsHostDefinedOptions()) |
         PrivateNameLookupSkipsOuterClassBit::encode(
             scope->private_name_lookup_skips_outer_class()) |
         HasContextExtensionSlotBit::encode(scope->HasContextExtensionSlot()) |
         IsReplModeScopeBit::encode(scope->is_repl_mode_scope()) |
-        HasLocalsBlockListBit::encode(false);
+        HasLocalsBlockListBit::encode(false) | IsEmptyBit::encode(false);
     scope_info.set_flags(flags);
 
     scope_info.set_parameter_count(parameter_count);
@@ -456,7 +457,8 @@ Handle<ScopeInfo> ScopeInfo::CreateForWithScope(
       ForceContextAllocationBit::encode(false) |
       PrivateNameLookupSkipsOuterClassBit::encode(false) |
       HasContextExtensionSlotBit::encode(true) |
-      IsReplModeScopeBit::encode(false) | HasLocalsBlockListBit::encode(false);
+      IsReplModeScopeBit::encode(false) | HasLocalsBlockListBit::encode(false) |
+      IsEmptyBit::encode(false);
   scope_info->set_flags(flags);
 
   scope_info->set_parameter_count(0);
@@ -534,7 +536,8 @@ Handle<ScopeInfo> ScopeInfo::CreateForBootstrapping(Isolate* isolate,
       ForceContextAllocationBit::encode(false) |
       PrivateNameLookupSkipsOuterClassBit::encode(false) |
       HasContextExtensionSlotBit::encode(is_native_context) |
-      IsReplModeScopeBit::encode(false) | HasLocalsBlockListBit::encode(false);
+      IsReplModeScopeBit::encode(false) | HasLocalsBlockListBit::encode(false) |
+      IsEmptyBit::encode(false);
   auto raw_scope_info = *scope_info;
   raw_scope_info.set_flags(flags);
   raw_scope_info.set_parameter_count(parameter_count);
@@ -714,10 +717,6 @@ int ScopeInfo::ContextLength() const {
          (function_name_context_slot ? 1 : 0);
 }
 
-bool ScopeInfo::HasContextExtensionSlot() const {
-  return HasContextExtensionSlotBit::decode(Flags());
-}
-
 int ScopeInfo::ContextHeaderLength() const {
   return HasContextExtensionSlot() ? Context::MIN_CONTEXT_EXTENDED_SLOTS
                                    : Context::MIN_CONTEXT_SLOTS;
diff --git a/deps/v8/src/objects/scope-info.h b/deps/v8/src/objects/scope-info.h
index 89001da93b5655..f6ad973943d7d6 100644
--- a/deps/v8/src/objects/scope-info.h
+++ b/deps/v8/src/objects/scope-info.h
@@ -82,7 +82,8 @@ class ScopeInfo : public TorqueGeneratedScopeInfo<ScopeInfo, HeapObject> {
   int ContextLength() const;
   int ContextHeaderLength() const;
 
-  bool HasContextExtensionSlot() const;
+  inline bool NeedsContext() const;
+  inline bool HasContextExtensionSlot() const;
 
   // Does this scope declare a "this" binding?
   bool HasReceiver() const;
diff --git a/deps/v8/src/objects/scope-info.tq b/deps/v8/src/objects/scope-info.tq
index d03228063f4b9d..676e3c01218942 100644
--- a/deps/v8/src/objects/scope-info.tq
+++ b/deps/v8/src/objects/scope-info.tq
@@ -206,3 +206,16 @@ macro IndexOfLocalName(scopeInfo: ScopeInfo, name: Name):
         scopeInfo.context_local_names_hashtable, name) otherwise goto NotFound;
   }
 }
+
+@export
+macro LoadContextElementWithName(
+    scopeInfo: ScopeInfo, name: Name, scriptContext: Context):
+    Object labels NotFound {
+  let index: intptr = IndexOfLocalName(scopeInfo, name) otherwise NotFound;
+  if (scopeInfo.flags.has_context_extension_slot) {
+    index += ContextSlot::MIN_CONTEXT_SLOTS + 1;
+  } else {
+    index += ContextSlot::MIN_CONTEXT_SLOTS;
+  }
+  return LoadContextElement(scriptContext, index);
+}
diff --git a/deps/v8/src/objects/script.tq b/deps/v8/src/objects/script.tq
index e4f99e62d9cf2b..63db82216245e9 100644
--- a/deps/v8/src/objects/script.tq
+++ b/deps/v8/src/objects/script.tq
@@ -57,9 +57,6 @@ extern class Script extends Struct {
   // [source_mapping_url]: sourceMappingURL magic comment
   source_mapping_url: Object;
 
-  // [host_defined_options]: Options defined by the embedder.
-  host_defined_options: FixedArray;
-
   // TODO(cbruni, v8:12302): remove once module callback API is updated.
   // Used to make sure we are backwards compatible with node to gaurantee
   // the same lifetime for ScriptOrModule as the Script they originated.
diff --git a/deps/v8/src/objects/shared-function-info-inl.h b/deps/v8/src/objects/shared-function-info-inl.h
index 43ef0d3d1732b0..5afd55dbb88aea 100644
--- a/deps/v8/src/objects/shared-function-info-inl.h
+++ b/deps/v8/src/objects/shared-function-info-inl.h
@@ -190,7 +190,7 @@ bool SharedFunctionInfo::is_script() const {
 }
 
 bool SharedFunctionInfo::needs_script_context() const {
-  return is_script() && scope_info(kAcquireLoad).ContextLocalCount() > 0;
+  return is_script() && scope_info(kAcquireLoad).NeedsContext();
 }
 
 template <typename IsolateT>
diff --git a/deps/v8/src/objects/source-text-module.tq b/deps/v8/src/objects/source-text-module.tq
index c663c6906a6177..d3d12f2854eaed 100644
--- a/deps/v8/src/objects/source-text-module.tq
+++ b/deps/v8/src/objects/source-text-module.tq
@@ -44,6 +44,8 @@ extern class SourceTextModule extends Module {
   // The number of currently evaluating async dependencies of this module.
   pending_async_dependencies: Smi;
 
+  host_defined_options: Object;
+
   flags: SmiTagged<SourceTextModuleFlags>;
 }
 
diff --git a/deps/v8/src/parsing/parser-base.h b/deps/v8/src/parsing/parser-base.h
index aff9c5f481fdce..070a7e09eb05e1 100644
--- a/deps/v8/src/parsing/parser-base.h
+++ b/deps/v8/src/parsing/parser-base.h
@@ -3735,6 +3735,7 @@ ParserBase<Impl>::ParseImportExpressions() {
   AcceptINScope scope(this, true);
   ExpressionT specifier = ParseAssignmentExpressionCoverGrammar();
 
+  impl()->scope()->RecordInnerScopeCallsDynamicImport();
   if (v8_flags.harmony_import_assertions && Check(Token::COMMA)) {
     if (Check(Token::RPAREN)) {
       // A trailing comma allowed after the specifier.
diff --git a/deps/v8/src/parsing/preparse-data.cc b/deps/v8/src/parsing/preparse-data.cc
index 7ebdb4e925a3a6..8f0acaa8e5da61 100644
--- a/deps/v8/src/parsing/preparse-data.cc
+++ b/deps/v8/src/parsing/preparse-data.cc
@@ -26,8 +26,10 @@ namespace {
 
 using ScopeSloppyEvalCanExtendVarsBit = base::BitField8<bool, 0, 1>;
 using InnerScopeCallsEvalField = ScopeSloppyEvalCanExtendVarsBit::Next<bool, 1>;
-using NeedsPrivateNameContextChainRecalcField =
+using InnerScopeCallsDynamicImportField =
     InnerScopeCallsEvalField::Next<bool, 1>;
+using NeedsPrivateNameContextChainRecalcField =
+    InnerScopeCallsDynamicImportField::Next<bool, 1>;
 using ShouldSaveClassVariableIndexField =
     NeedsPrivateNameContextChainRecalcField::Next<bool, 1>;
 
@@ -366,6 +368,8 @@ void PreparseDataBuilder::SaveDataForScope(Scope* scope) {
           scope->is_declaration_scope() &&
           scope->AsDeclarationScope()->sloppy_eval_can_extend_vars()) |
       InnerScopeCallsEvalField::encode(scope->inner_scope_calls_eval()) |
+      InnerScopeCallsDynamicImportField::encode(
+          scope->inner_scope_calls_dynamic_import()) |
       NeedsPrivateNameContextChainRecalcField::encode(
           scope->is_function_scope() &&
           scope->AsDeclarationScope()
@@ -666,7 +670,10 @@ void BaseConsumedPreparseData<Data>::RestoreDataForScope(
     scope->RecordEvalCall();
   }
   if (InnerScopeCallsEvalField::decode(scope_data_flags)) {
-    scope->RecordInnerScopeEvalCall();
+    scope->RecordInnerScopeCallsEval();
+  }
+  if (InnerScopeCallsDynamicImportField::decode(scope_data_flags)) {
+    scope->RecordInnerScopeCallsDynamicImport();
   }
   if (NeedsPrivateNameContextChainRecalcField::decode(scope_data_flags)) {
     scope->AsDeclarationScope()->RecordNeedsPrivateNameContextChainRecalc();
diff --git a/deps/v8/src/profiler/heap-snapshot-generator.cc b/deps/v8/src/profiler/heap-snapshot-generator.cc
index edbdb4c91a0e15..fd359cd1171d47 100644
--- a/deps/v8/src/profiler/heap-snapshot-generator.cc
+++ b/deps/v8/src/profiler/heap-snapshot-generator.cc
@@ -1519,8 +1519,6 @@ void V8HeapExplorer::ExtractScriptReferences(HeapEntry* entry, Script script) {
                        Script::kLineEndsOffset);
   TagObject(script.shared_function_infos(), "(shared function infos)",
             HeapEntry::kCode);
-  TagObject(script.host_defined_options(), "(host-defined options)",
-            HeapEntry::kCode);
 }
 
 void V8HeapExplorer::ExtractAccessorInfoReferences(HeapEntry* entry,
diff --git a/deps/v8/src/runtime/runtime-module.cc b/deps/v8/src/runtime/runtime-module.cc
index c3f06993b40868..a83b0d80cfe82e 100644
--- a/deps/v8/src/runtime/runtime-module.cc
+++ b/deps/v8/src/runtime/runtime-module.cc
@@ -33,11 +33,15 @@ RUNTIME_FUNCTION(Runtime_DynamicImportCall) {
     import_assertions = args.at<Object>(2);
   }
 
+  Handle<Object> host_defined_options(isolate->context().host_defined_options(),
+                                      isolate);
+
   Handle<Script> referrer_script =
       GetEvalOrigin(isolate, Script::cast(function->shared().script()));
-  RETURN_RESULT_OR_FAILURE(isolate,
-                           isolate->RunHostImportModuleDynamicallyCallback(
-                               referrer_script, specifier, import_assertions));
+  RETURN_RESULT_OR_FAILURE(
+      isolate,
+      isolate->RunHostImportModuleDynamicallyCallback(
+          referrer_script, specifier, host_defined_options, import_assertions));
 }
 
 RUNTIME_FUNCTION(Runtime_GetModuleNamespace) {
diff --git a/deps/v8/src/runtime/runtime-shadow-realm.cc b/deps/v8/src/runtime/runtime-shadow-realm.cc
index 7db79cc409ea1d..9f408439302388 100644
--- a/deps/v8/src/runtime/runtime-shadow-realm.cc
+++ b/deps/v8/src/runtime/runtime-shadow-realm.cc
@@ -30,8 +30,9 @@ RUNTIME_FUNCTION(Runtime_ShadowRealmImportValue) {
   MaybeHandle<Script> referrer;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, inner_capability,
-      isolate->RunHostImportModuleDynamicallyCallback(referrer, specifier,
-                                                      import_assertions));
+      isolate->RunHostImportModuleDynamicallyCallback(
+          referrer, specifier, isolate->factory()->empty_fixed_array(),
+          import_assertions));
   // Check that the promise is created in the eval_context.
   DCHECK(
       inner_capability->GetCreationContext().ToHandleChecked().is_identical_to(
diff --git a/deps/v8/src/snapshot/code-serializer.cc b/deps/v8/src/snapshot/code-serializer.cc
index 95352299f8d871..e8363b8b0aa1bc 100644
--- a/deps/v8/src/snapshot/code-serializer.cc
+++ b/deps/v8/src/snapshot/code-serializer.cc
@@ -151,7 +151,6 @@ void CodeSerializer::SerializeObjectImpl(Handle<HeapObject> obj) {
   }
 
   if (InstanceTypeChecker::IsScript(instance_type)) {
-    Handle<FixedArray> host_options;
     Handle<Object> context_data;
     {
       DisallowGarbageCollection no_gc;
@@ -167,16 +166,11 @@ void CodeSerializer::SerializeObjectImpl(Handle<HeapObject> obj) {
         script_obj.set_context_data(roots.undefined_value());
       }
       context_data = handle(raw_context_data, isolate());
-      // We don't want to serialize host options to avoid serializing
-      // unnecessary object graph.
-      host_options = handle(script_obj.host_defined_options(), isolate());
-      script_obj.set_host_defined_options(roots.empty_fixed_array());
     }
     SerializeGeneric(obj);
     {
       DisallowGarbageCollection no_gc;
       Script script_obj = Script::cast(*obj);
-      script_obj.set_host_defined_options(*host_options);
       script_obj.set_context_data(*context_data);
     }
     return;
diff --git a/deps/v8/src/snapshot/snapshot.cc b/deps/v8/src/snapshot/snapshot.cc
index aa6e34a7e51184..3a26f2bb18b7da 100644
--- a/deps/v8/src/snapshot/snapshot.cc
+++ b/deps/v8/src/snapshot/snapshot.cc
@@ -728,7 +728,7 @@ bool RunExtraCode(v8::Isolate* isolate, v8::Local<v8::Context> context,
   }
   v8::Local<v8::String> resource_name =
       v8::String::NewFromUtf8(isolate, name).ToLocalChecked();
-  v8::ScriptOrigin origin(isolate, resource_name);
+  v8::ScriptOrigin origin(resource_name);
   v8::ScriptCompiler::Source source(source_string, origin);
   v8::Local<v8::Script> script;
   if (!v8::ScriptCompiler::Compile(context, &source).ToLocal(&script))
diff --git a/deps/v8/src/web-snapshot/web-snapshot.cc b/deps/v8/src/web-snapshot/web-snapshot.cc
index 3a8a97a8c5388f..4b36185bb3e687 100644
--- a/deps/v8/src/web-snapshot/web-snapshot.cc
+++ b/deps/v8/src/web-snapshot/web-snapshot.cc
@@ -2425,7 +2425,7 @@ bool WebSnapshotDeserializer::DeserializeScript() {
             NewStringType::kNormal, static_cast<int>(remaining_bytes))
             .ToLocalChecked();
 
-    ScriptOrigin origin(v8_isolate, Utils::ToLocal(script_name_));
+    ScriptOrigin origin(Utils::ToLocal(script_name_));
 
     ScriptCompiler::Source script_source(source, origin);
     Local<UnboundScript> script;
diff --git a/deps/v8/test/cctest/cctest.h b/deps/v8/test/cctest/cctest.h
index ceb2db40e28f49..da46658ee57cb5 100644
--- a/deps/v8/test/cctest/cctest.h
+++ b/deps/v8/test/cctest/cctest.h
@@ -442,7 +442,7 @@ static inline v8::Local<v8::Script> CompileWithOrigin(
     v8::Local<v8::String> source, v8::Local<v8::String> origin_url,
     bool is_shared_cross_origin) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  v8::ScriptOrigin origin(isolate, origin_url, 0, 0, is_shared_cross_origin);
+  v8::ScriptOrigin origin(origin_url, 0, 0, is_shared_cross_origin);
   v8::ScriptCompiler::Source script_source(source, origin);
   return v8::ScriptCompiler::Compile(isolate->GetCurrentContext(),
                                      &script_source)
@@ -519,8 +519,7 @@ static inline v8::Local<v8::Value> CompileRunWithOrigin(const char* source,
                                                         int column_number) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::ScriptOrigin origin(isolate, v8_str(origin_url), line_number,
-                          column_number);
+  v8::ScriptOrigin origin(v8_str(origin_url), line_number, column_number);
   v8::ScriptCompiler::Source script_source(v8_str(source), origin);
   return CompileRun(context, &script_source,
                     v8::ScriptCompiler::CompileOptions());
@@ -532,7 +531,7 @@ static inline v8::Local<v8::Value> CompileRunWithOrigin(
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::ScriptCompiler::Source script_source(
-      source, v8::ScriptOrigin(isolate, v8_str(origin_url)));
+      source, v8::ScriptOrigin(v8_str(origin_url)));
   return CompileRun(context, &script_source,
                     v8::ScriptCompiler::CompileOptions());
 }
diff --git a/deps/v8/test/cctest/test-api-stack-traces.cc b/deps/v8/test/cctest/test-api-stack-traces.cc
index 96a19018b8bf19..edb2b8ae8f788a 100644
--- a/deps/v8/test/cctest/test-api-stack-traces.cc
+++ b/deps/v8/test/cctest/test-api-stack-traces.cc
@@ -163,8 +163,7 @@ TEST(StackTrace) {
   const char* source = "function foo() { FAIL.FAIL; }; foo();";
   v8::Local<v8::String> src = v8_str(source);
   v8::Local<v8::String> origin = v8_str("stack-trace-test");
-  v8::ScriptCompiler::Source script_source(src,
-                                           v8::ScriptOrigin(isolate, origin));
+  v8::ScriptCompiler::Source script_source(src, v8::ScriptOrigin(origin));
   CHECK(v8::ScriptCompiler::CompileUnboundScript(context->GetIsolate(),
                                                  &script_source)
             .ToLocalChecked()
@@ -357,7 +356,7 @@ THREADED_TEST(CaptureStackTrace) {
 
   v8::Local<v8::String> overview_src = v8_str(overview_source);
   v8::ScriptCompiler::Source script_source(overview_src,
-                                           v8::ScriptOrigin(isolate, origin));
+                                           v8::ScriptOrigin(origin));
   v8::Local<Value> overview_result(
       v8::ScriptCompiler::CompileUnboundScript(isolate, &script_source)
           .ToLocalChecked()
@@ -369,7 +368,7 @@ THREADED_TEST(CaptureStackTrace) {
 
   v8::Local<v8::String> detailed_src = v8_str(detailed_source);
   // Make the script using a non-zero line and column offset.
-  v8::ScriptOrigin detailed_origin(isolate, origin, 3, 5);
+  v8::ScriptOrigin detailed_origin(origin, 3, 5);
   v8::ScriptCompiler::Source script_source2(detailed_src, detailed_origin);
   v8::Local<v8::UnboundScript> detailed_script(
       v8::ScriptCompiler::CompileUnboundScript(isolate, &script_source2)
@@ -383,7 +382,7 @@ THREADED_TEST(CaptureStackTrace) {
   v8::Local<v8::String> function_name_src =
       v8::String::NewFromUtf8Literal(isolate, function_name_source);
   v8::ScriptCompiler::Source script_source3(function_name_src,
-                                            v8::ScriptOrigin(isolate, origin));
+                                            v8::ScriptOrigin(origin));
   v8::Local<Value> function_name_result(
       v8::ScriptCompiler::CompileUnboundScript(isolate, &script_source3)
           .ToLocalChecked()
diff --git a/deps/v8/test/cctest/test-api.cc b/deps/v8/test/cctest/test-api.cc
index 5e13f3b4bae67f..b3f4045ac7daf6 100644
--- a/deps/v8/test/cctest/test-api.cc
+++ b/deps/v8/test/cctest/test-api.cc
@@ -2318,8 +2318,8 @@ THREADED_TEST(TestDataTypeChecks) {
     x.As<v8::Value>();
   }
 
-  v8::ScriptOrigin origin(isolate, v8_str(""), 0, 0, false, -1,
-                          Local<v8::Value>(), false, false, true);
+  v8::ScriptOrigin origin(v8_str(""), 0, 0, false, -1, Local<v8::Value>(),
+                          false, false, true);
   v8::ScriptCompiler::Source source(v8::String::NewFromUtf8Literal(isolate, ""),
                                     origin);
   v8::Local<v8::Data> module =
@@ -4651,8 +4651,8 @@ TEST(MessageHandler3) {
   CHECK(!message_received);
   isolate->AddMessageListener(check_message_3);
   LocalContext context;
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate, v8_str("6.75"), 1, 2,
-                                             true, -1, v8_str("7.40"), true);
+  v8::ScriptOrigin origin =
+      v8::ScriptOrigin(v8_str("6.75"), 1, 2, true, -1, v8_str("7.40"), true);
   v8::Local<v8::Script> script =
       Script::Compile(context.local(), v8_str("throw 'error'"), &origin)
           .ToLocalChecked();
@@ -4681,8 +4681,7 @@ TEST(MessageHandler4) {
   CHECK(!message_received);
   isolate->AddMessageListener(check_message_4);
   LocalContext context;
-  v8::ScriptOrigin origin =
-      v8::ScriptOrigin(isolate, v8_str("6.75"), 1, 2, false);
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("6.75"), 1, 2, false);
   v8::Local<v8::Script> script =
       Script::Compile(context.local(), v8_str("throw 'error'"), &origin)
           .ToLocalChecked();
@@ -4722,8 +4721,7 @@ TEST(MessageHandler5) {
   CHECK(!message_received);
   isolate->AddMessageListener(check_message_5a);
   LocalContext context;
-  v8::ScriptOrigin origin1 =
-      v8::ScriptOrigin(isolate, v8_str("6.75"), 1, 2, true);
+  v8::ScriptOrigin origin1 = v8::ScriptOrigin(v8_str("6.75"), 1, 2, true);
   v8::Local<v8::Script> script =
       Script::Compile(context.local(), v8_str("throw 'error'"), &origin1)
           .ToLocalChecked();
@@ -4734,8 +4732,7 @@ TEST(MessageHandler5) {
 
   message_received = false;
   isolate->AddMessageListener(check_message_5b);
-  v8::ScriptOrigin origin2 =
-      v8::ScriptOrigin(isolate, v8_str("6.75"), 1, 2, false);
+  v8::ScriptOrigin origin2 = v8::ScriptOrigin(v8_str("6.75"), 1, 2, false);
   script = Script::Compile(context.local(), v8_str("throw 'error'"), &origin2)
                .ToLocalChecked();
   CHECK(script->Run(context.local()).IsEmpty());
@@ -13970,13 +13967,13 @@ THREADED_TEST(TryCatchSourceInfo) {
   CheckTryCatchSourceInfo(script, resource_name, 0);
 
   resource_name = "test1.js";
-  v8::ScriptOrigin origin1(isolate, v8_str(resource_name), 0, 0);
+  v8::ScriptOrigin origin1(v8_str(resource_name), 0, 0);
   script =
       v8::Script::Compile(context.local(), source, &origin1).ToLocalChecked();
   CheckTryCatchSourceInfo(script, resource_name, 0);
 
   resource_name = "test2.js";
-  v8::ScriptOrigin origin2(isolate, v8_str(resource_name), 7, 0);
+  v8::ScriptOrigin origin2(v8_str(resource_name), 7, 0);
   script =
       v8::Script::Compile(context.local(), source, &origin2).ToLocalChecked();
   CheckTryCatchSourceInfo(script, resource_name, 7);
@@ -17210,9 +17207,9 @@ THREADED_TEST(ScriptOrigin) {
   Local<v8::Symbol> symbol(v8::Symbol::New(isolate));
   array->Set(isolate, 0, symbol);
 
-  v8::ScriptOrigin origin = v8::ScriptOrigin(
-      isolate, v8_str("test"), 1, 1, true, -1, v8_str("http://sourceMapUrl"),
-      true, false, false, array);
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"), 1, 1, true, -1,
+                                             v8_str("http://sourceMapUrl"),
+                                             true, false, false, array);
   v8::Local<v8::String> script = v8_str("function f() {}\n\nfunction g() {}");
   v8::Script::Compile(env.local(), script, &origin)
       .ToLocalChecked()
@@ -17231,10 +17228,6 @@ THREADED_TEST(ScriptOrigin) {
   CHECK(script_origin_f.Options().IsSharedCrossOrigin());
   CHECK(script_origin_f.Options().IsOpaque());
   printf("is name = %d\n", script_origin_f.SourceMapUrl()->IsUndefined());
-  CHECK(script_origin_f.GetHostDefinedOptions()
-            .As<v8::PrimitiveArray>()
-            ->Get(isolate, 0)
-            ->IsSymbol());
 
   CHECK_EQ(0, strcmp("http://sourceMapUrl",
                      *v8::String::Utf8Value(env->GetIsolate(),
@@ -17250,10 +17243,6 @@ THREADED_TEST(ScriptOrigin) {
   CHECK_EQ(0, strcmp("http://sourceMapUrl",
                      *v8::String::Utf8Value(env->GetIsolate(),
                                             script_origin_g.SourceMapUrl())));
-  CHECK(script_origin_g.GetHostDefinedOptions()
-            .As<v8::PrimitiveArray>()
-            ->Get(isolate, 0)
-            ->IsSymbol());
 }
 
 
@@ -17261,7 +17250,7 @@ THREADED_TEST(FunctionGetInferredName) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate, v8_str("test"), 0, 0);
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"), 0, 0);
   v8::Local<v8::String> script =
       v8_str("var foo = { bar : { baz : function() {}}}; var f = foo.bar.baz;");
   v8::Script::Compile(env.local(), script, &origin)
@@ -17325,7 +17314,7 @@ THREADED_TEST(FunctionGetDebugName) {
       "Object.defineProperty(j, 'name', { value: 'function.name' });"
       "var foo = { bar : { baz : (0, function() {})}}; var k = foo.bar.baz;"
       "var foo = { bar : { baz : function() {} }}; var l = foo.bar.baz;";
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate, v8_str("test"), 0, 0);
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"), 0, 0);
   v8::Script::Compile(env.local(), v8_str(code), &origin)
       .ToLocalChecked()
       ->Run(env.local())
@@ -17363,7 +17352,7 @@ THREADED_TEST(ScriptLineNumber) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate, v8_str("test"), 0, 0);
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"), 0, 0);
   v8::Local<v8::String> script = v8_str("function f() {}\n\nfunction g() {}");
   v8::Script::Compile(env.local(), script, &origin)
       .ToLocalChecked()
@@ -17382,7 +17371,7 @@ THREADED_TEST(ScriptColumnNumber) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate, v8_str("test"), 3, 2);
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"), 3, 2);
   v8::Local<v8::String> script =
       v8_str("function foo() {}\n\n     function bar() {}");
   v8::Script::Compile(env.local(), script, &origin)
@@ -17402,7 +17391,7 @@ THREADED_TEST(FunctionGetScriptId) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate, v8_str("test"), 3, 2);
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"), 3, 2);
   v8::Local<v8::String> scriptSource =
       v8_str("function foo() {}\n\n     function bar() {}");
   v8::Local<v8::Script> script(
@@ -17421,7 +17410,7 @@ THREADED_TEST(FunctionGetBoundFunction) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate, v8_str("test"));
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"));
   v8::Local<v8::String> script = v8_str(
       "var a = new Object();\n"
       "a.x = 1;\n"
@@ -22815,7 +22804,7 @@ TEST(ScriptNameAndLineNumber) {
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   const char* url = "http://www.foo.com/foo.js";
-  v8::ScriptOrigin origin(isolate, v8_str(url), 13, 0);
+  v8::ScriptOrigin origin(v8_str(url), 13, 0);
   v8::ScriptCompiler::Source script_source(v8_str("var foo;"), origin);
 
   Local<Script> script =
@@ -22833,7 +22822,7 @@ TEST(ScriptPositionInfo) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   v8::HandleScope scope(isolate);
   const char* url = "http://www.foo.com/foo.js";
-  v8::ScriptOrigin origin(isolate, v8_str(url), 13, 0);
+  v8::ScriptOrigin origin(v8_str(url), 13, 0);
   v8::ScriptCompiler::Source script_source(v8_str("var foo;\n"
                                                   "var bar;\n"
                                                   "var fisk = foo + bar;\n"),
@@ -22947,8 +22936,7 @@ void SourceURLHelper(v8::Isolate* isolate, const char* source_text,
     Local<v8::String> source_str = v8_str(source_text);
     // Set a different resource name with the case above to invalidate the
     // cache.
-    v8::ScriptOrigin origin(isolate,
-                            v8_str("module.js"),  // resource name
+    v8::ScriptOrigin origin(v8_str("module.js"),  // resource name
                             0,                    // line offset
                             0,                    // column offset
                             true,                 // is cross origin
@@ -23250,7 +23238,7 @@ void RunStreamingTest(const char** chunks, v8::ScriptType type,
   // Possible errors are only produced while compiling.
   CHECK(!try_catch.HasCaught());
 
-  v8::ScriptOrigin origin(isolate, v8_str("http://foo.com"), 0, 0, false, -1,
+  v8::ScriptOrigin origin(v8_str("http://foo.com"), 0, 0, false, -1,
                           v8::Local<v8::Value>(), false, false,
                           type == v8::ScriptType::kModule);
 
@@ -23574,7 +23562,7 @@ TEST(StreamingWithDebuggingEnabledLate) {
 
   CHECK(!try_catch.HasCaught());
 
-  v8::ScriptOrigin origin(isolate, v8_str("http://foo.com"));
+  v8::ScriptOrigin origin(v8_str("http://foo.com"));
   char* full_source = TestSourceStream::FullSourceString(chunks);
 
   EnableDebugger(isolate);
@@ -23689,7 +23677,7 @@ TEST(StreamingWithHarmonyScopes) {
   // independent way, so the error is not detected).
   CHECK(!try_catch.HasCaught());
 
-  v8::ScriptOrigin origin(isolate, v8_str("http://foo.com"));
+  v8::ScriptOrigin origin(v8_str("http://foo.com"));
   char* full_source = TestSourceStream::FullSourceString(chunks);
   v8::Local<Script> script =
       v8::ScriptCompiler::Compile(env.local(), &source, v8_str(full_source),
@@ -23713,7 +23701,7 @@ void StreamingWithIsolateScriptCache(bool run_gc) {
   v8::Isolate* isolate = CcTest::isolate();
   auto i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   v8::HandleScope scope(isolate);
-  v8::ScriptOrigin origin(isolate, v8_str("http://foo.com"), 0, 0, false, -1,
+  v8::ScriptOrigin origin(v8_str("http://foo.com"), 0, 0, false, -1,
                           v8::Local<v8::Value>(), false, false, false);
   v8::Local<Value> first_function_untyped;
   i::Handle<i::JSFunction> first_function;
@@ -23818,7 +23806,7 @@ TEST(CodeCache) {
     v8::Local<v8::Context> context = v8::Context::New(isolate1);
     v8::Context::Scope cscope(context);
     v8::Local<v8::String> source_string = v8_str(source);
-    v8::ScriptOrigin script_origin(isolate1, v8_str(origin));
+    v8::ScriptOrigin script_origin(v8_str(origin));
     v8::ScriptCompiler::Source script_source(source_string, script_origin);
     v8::ScriptCompiler::CompileOptions option =
         v8::ScriptCompiler::kNoCompileOptions;
@@ -23836,7 +23824,7 @@ TEST(CodeCache) {
     v8::Local<v8::Context> context = v8::Context::New(isolate2);
     v8::Context::Scope cscope(context);
     v8::Local<v8::String> source_string = v8_str(source);
-    v8::ScriptOrigin script_origin(isolate2, v8_str(origin));
+    v8::ScriptOrigin script_origin(v8_str(origin));
     v8::ScriptCompiler::Source script_source(source_string, script_origin,
                                              cache);
     v8::ScriptCompiler::CompileOptions option =
@@ -23894,8 +23882,8 @@ Local<Module> CompileAndInstantiateModule(v8::Isolate* isolate,
                                           const char* resource_name,
                                           const char* source) {
   Local<String> source_string = v8_str(source);
-  v8::ScriptOrigin script_origin(isolate, v8_str(resource_name), 0, 0, false,
-                                 -1, Local<v8::Value>(), false, false, true);
+  v8::ScriptOrigin script_origin(v8_str(resource_name), 0, 0, false, -1,
+                                 Local<v8::Value>(), false, false, true);
   v8::ScriptCompiler::Source script_compiler_source(source_string,
                                                     script_origin);
   Local<Module> module =
@@ -23923,8 +23911,8 @@ Local<Module> CompileAndInstantiateModuleFromCache(
     v8::Isolate* isolate, Local<Context> context, const char* resource_name,
     const char* source, v8::ScriptCompiler::CachedData* cache) {
   Local<String> source_string = v8_str(source);
-  v8::ScriptOrigin script_origin(isolate, v8_str(resource_name), 0, 0, false,
-                                 -1, Local<v8::Value>(), false, false, true);
+  v8::ScriptOrigin script_origin(v8_str(resource_name), 0, 0, false, -1,
+                                 Local<v8::Value>(), false, false, true);
   v8::ScriptCompiler::Source script_compiler_source(source_string,
                                                     script_origin, cache);
 
@@ -24292,8 +24280,8 @@ TEST(ImportFromSyntheticModule) {
   Local<String> source_text = v8_str(
       "import {test_export} from './synthetic.module'; "
       "(function() { globalThis.Result = test_export; })();");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -24323,8 +24311,8 @@ TEST(ImportFromSyntheticModuleThrow) {
   Local<String> source_text = v8_str(
       "import {test_export} from './synthetic.module';"
       "(function() { return test_export; })();");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -24354,8 +24342,8 @@ v8::MaybeLocal<Module> ModuleEvaluateTerminateExecutionResolveCallback(
 
   Local<String> url = v8_str("www.test.com");
   Local<String> source_text = v8_str("await Promise.resolve();");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -24394,8 +24382,8 @@ TEST(ModuleEvaluateTerminateExecution) {
   Local<String> source_text = v8_str(
       "terminate_execution();"
       "await Promise.resolve();");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -24435,8 +24423,8 @@ TEST(ModuleEvaluateImportTerminateExecution) {
       "import './synthetic.module';"
       "terminate_execution();"
       "await Promise.resolve();");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -24509,7 +24497,7 @@ TEST(CodeCacheModuleScriptMismatch) {
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope cscope(context);
 
-      v8::ScriptOrigin script_origin(isolate, v8_str(origin));
+      v8::ScriptOrigin script_origin(v8_str(origin));
       v8::ScriptCompiler::Source script_compiler_source(v8_str(source),
                                                         script_origin, cache);
 
@@ -24548,7 +24536,7 @@ TEST(CodeCacheScriptModuleMismatch) {
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope cscope(context);
       v8::Local<v8::String> source_string = v8_str(source);
-      v8::ScriptOrigin script_origin(isolate, v8_str(origin));
+      v8::ScriptOrigin script_origin(v8_str(origin));
       v8::ScriptCompiler::Source script_source(source_string, script_origin);
       v8::ScriptCompiler::CompileOptions option =
           v8::ScriptCompiler::kNoCompileOptions;
@@ -24569,7 +24557,7 @@ TEST(CodeCacheScriptModuleMismatch) {
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope cscope(context);
 
-      v8::ScriptOrigin script_origin(isolate, v8_str(origin), 0, 0, false, -1,
+      v8::ScriptOrigin script_origin(v8_str(origin), 0, 0, false, -1,
                                      Local<v8::Value>(), false, false, true);
       v8::ScriptCompiler::Source script_compiler_source(v8_str(source),
                                                         script_origin, cache);
@@ -24607,8 +24595,8 @@ TEST(InvalidCodeCacheDataInCompileModule) {
       new v8::ScriptCompiler::CachedData(data, length);
   CHECK(!cached_data->rejected);
 
-  v8::ScriptOrigin script_origin(isolate, origin, 0, 0, false, -1,
-                                 Local<v8::Value>(), false, false, true);
+  v8::ScriptOrigin script_origin(origin, 0, 0, false, -1, Local<v8::Value>(),
+                                 false, false, true);
   v8::ScriptCompiler::Source source(v8_str("42"), script_origin, cached_data);
   v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
 
@@ -24634,7 +24622,7 @@ void TestInvalidCacheData(v8::ScriptCompiler::CompileOptions option) {
   v8::ScriptCompiler::CachedData* cached_data =
       new v8::ScriptCompiler::CachedData(data, length);
   CHECK(!cached_data->rejected);
-  v8::ScriptOrigin origin(isolate, v8_str("origin"));
+  v8::ScriptOrigin origin(v8_str("origin"));
   v8::ScriptCompiler::Source source(v8_str("42"), origin, cached_data);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Script> script =
@@ -26036,10 +26024,9 @@ TEST(DynamicImport) {
   referrer->set_name(*url);
   i::Handle<i::FixedArray> options = i_isolate->factory()->NewFixedArray(
       kCustomHostDefinedOptionsLengthForTesting);
-  referrer->set_host_defined_options(*options);
   i::MaybeHandle<i::JSPromise> maybe_promise =
       i_isolate->RunHostImportModuleDynamicallyCallback(
-          referrer, specifier, i::MaybeHandle<i::Object>());
+          referrer, specifier, options, i::MaybeHandle<i::Object>());
   i::Handle<i::JSPromise> promise = maybe_promise.ToHandleChecked();
   isolate->PerformMicrotaskCheckpoint();
   CHECK(result->Equals(i::String::cast(promise->result())));
@@ -26123,10 +26110,9 @@ TEST(DynamicImportWithAssertions) {
   referrer->set_name(*url);
   i::Handle<i::FixedArray> options = i_isolate->factory()->NewFixedArray(
       kCustomHostDefinedOptionsLengthForTesting);
-  referrer->set_host_defined_options(*options);
   i::MaybeHandle<i::JSPromise> maybe_promise =
-      i_isolate->RunHostImportModuleDynamicallyCallback(referrer, specifier,
-                                                        i_import_assertions);
+      i_isolate->RunHostImportModuleDynamicallyCallback(
+          referrer, specifier, options, i_import_assertions);
   i::Handle<i::JSPromise> promise = maybe_promise.ToHandleChecked();
   isolate->PerformMicrotaskCheckpoint();
   CHECK(result->Equals(i::String::cast(promise->result())));
@@ -26150,8 +26136,8 @@ TEST(ImportMeta) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("globalThis.Result = import.meta;");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -26198,8 +26184,8 @@ TEST(ImportMetaThrowUnhandled) {
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text =
       v8_str("export default function() { return import.meta }");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -26241,8 +26227,8 @@ TEST(ImportMetaThrowHandled) {
         return false;
       }
       )javascript");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -26279,8 +26265,8 @@ TEST(CreateShadowRealmContextHostNotSupported) {
 
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("new ShadowRealm()");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, false);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, false);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Script> script =
       v8::ScriptCompiler::Compile(context.local(), &source).ToLocalChecked();
@@ -26308,8 +26294,8 @@ TEST(CreateShadowRealmContext) {
 
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("new ShadowRealm()");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, false);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, false);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Script> script =
       v8::ScriptCompiler::Compile(context.local(), &source).ToLocalChecked();
@@ -26337,8 +26323,8 @@ TEST(CreateShadowRealmContextThrow) {
 
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("new ShadowRealm()");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, false);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, false);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Script> script =
       v8::ScriptCompiler::Compile(context.local(), &source).ToLocalChecked();
@@ -26356,8 +26342,8 @@ TEST(GetModuleNamespace) {
 
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("export default 5; export const a = 10;");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -26383,8 +26369,8 @@ TEST(ModuleGetUnboundModuleScript) {
 
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("export default 5; export const a = 10;");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -26410,8 +26396,8 @@ TEST(ModuleScriptId) {
 
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("export default 5; export const a = 10;");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
@@ -26431,8 +26417,8 @@ TEST(ModuleIsSourceTextModule) {
 
   Local<String> url = v8_str("www.google.com");
   Local<String> source_text = v8_str("export default 5; export const a = 10;");
-  v8::ScriptOrigin origin(isolate, url, 0, 0, false, -1, Local<v8::Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(url, 0, 0, false, -1, Local<v8::Value>(), false,
+                          false, true);
   v8::ScriptCompiler::Source source(source_text, origin);
   Local<Module> module =
       v8::ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();
diff --git a/deps/v8/test/cctest/test-debug.cc b/deps/v8/test/cctest/test-debug.cc
index c3c8cef4659c65..6f2a1cd2a819ec 100644
--- a/deps/v8/test/cctest/test-debug.cc
+++ b/deps/v8/test/cctest/test-debug.cc
@@ -2893,8 +2893,7 @@ TEST(PauseInScript) {
   const char* src = "(function (evt) {})";
   const char* script_name = "StepInHandlerTest";
 
-  v8::ScriptOrigin origin(env->GetIsolate(),
-                          v8_str(env->GetIsolate(), script_name));
+  v8::ScriptOrigin origin(v8_str(env->GetIsolate(), script_name));
   v8::Local<v8::Script> script =
       v8::Script::Compile(context, v8_str(env->GetIsolate(), src), &origin)
           .ToLocalChecked();
@@ -3270,7 +3269,7 @@ TEST(DebugScriptLineEndsAreAscending) {
                                                "  debugger;\n"
                                                "}\n");
 
-  v8::ScriptOrigin origin1 = v8::ScriptOrigin(isolate, v8_str(isolate, "name"));
+  v8::ScriptOrigin origin1 = v8::ScriptOrigin(v8_str(isolate, "name"));
   v8::Local<v8::Script> script =
       v8::Script::Compile(env.local(), script_source, &origin1)
           .ToLocalChecked();
diff --git a/deps/v8/test/cctest/test-serialize.cc b/deps/v8/test/cctest/test-serialize.cc
index d9df36b85bfc0c..a6983b8d6f1ac7 100644
--- a/deps/v8/test/cctest/test-serialize.cc
+++ b/deps/v8/test/cctest/test-serialize.cc
@@ -1555,7 +1555,7 @@ v8::StartupData CreateCustomSnapshotWithKeep() {
       v8::Local<v8::String> source_str = v8_str(
           "function f() { return Math.abs(1); }\n"
           "function g() { return String.raw(1); }");
-      v8::ScriptOrigin origin(isolate, v8_str("test"));
+      v8::ScriptOrigin origin(v8_str("test"));
       v8::ScriptCompiler::Source source(source_str, origin);
       CompileRun(isolate->GetCurrentContext(), &source,
                  v8::ScriptCompiler::kEagerCompile);
@@ -1797,17 +1797,7 @@ TEST(CodeSerializerPromotedToCompilationCache) {
   Handle<String> src = isolate->factory()->NewStringFromAsciiChecked(source);
   AlignedCachedData* cache = nullptr;
 
-  Handle<FixedArray> default_host_defined_options =
-      isolate->factory()->NewFixedArray(2);
-  default_host_defined_options->set(0, Smi::FromInt(0));
-  const char* default_host_defined_option_1_string = "custom string";
-  Handle<String> default_host_defined_option_1 =
-      isolate->factory()->NewStringFromAsciiChecked(
-          default_host_defined_option_1_string);
-  default_host_defined_options->set(1, *default_host_defined_option_1);
-
   ScriptDetails default_script_details(src);
-  default_script_details.host_defined_options = default_host_defined_options;
   CompileScriptAndProduceCache(isolate, src, default_script_details, &cache,
                                v8::ScriptCompiler::kNoCompileOptions);
 
@@ -1820,8 +1810,6 @@ TEST(CodeSerializerPromotedToCompilationCache) {
 
   {
     ScriptDetails script_details(src);
-    script_details.host_defined_options =
-        default_script_details.host_defined_options;
     auto lookup_result = isolate->compilation_cache()->LookupScript(
         src, script_details, LanguageMode::kSloppy);
     CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *copy);
@@ -1830,14 +1818,6 @@ TEST(CodeSerializerPromotedToCompilationCache) {
   {
     // Lookup with strictly equal host_defined_options should succeed:
     ScriptDetails script_details(src);
-    Handle<FixedArray> host_defined_options =
-        isolate->factory()->NewFixedArray(2);
-    host_defined_options->set(0, default_host_defined_options->get(0));
-    Handle<String> host_defined_option_1 =
-        isolate->factory()->NewStringFromAsciiChecked(
-            default_host_defined_option_1_string);
-    host_defined_options->set(1, *host_defined_option_1);
-    script_details.host_defined_options = host_defined_options;
     auto lookup_result = isolate->compilation_cache()->LookupScript(
         src, script_details, LanguageMode::kSloppy);
     CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *copy);
@@ -1847,8 +1827,6 @@ TEST(CodeSerializerPromotedToCompilationCache) {
     // Lookup with different string with same contents should succeed:
     ScriptDetails script_details(
         isolate->factory()->NewStringFromAsciiChecked(source));
-    script_details.host_defined_options =
-        default_script_details.host_defined_options;
     auto lookup_result = isolate->compilation_cache()->LookupScript(
         src, script_details, LanguageMode::kSloppy);
     CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *copy);
@@ -1904,45 +1882,6 @@ TEST(CodeSerializerPromotedToCompilationCache) {
           lookup_result.toplevel_sfi().is_null());
   }
 
-  {
-    // Lookup with different host_defined_options should fail:
-    ScriptDetails script_details(src);
-    script_details.host_defined_options = isolate->factory()->NewFixedArray(5);
-    auto lookup_result = isolate->compilation_cache()->LookupScript(
-        src, script_details, LanguageMode::kSloppy);
-    CHECK(lookup_result.script().is_null() &&
-          lookup_result.toplevel_sfi().is_null());
-  }
-
-  // Compile the script again with different options.
-  ScriptDetails alternative_script_details(src);
-  Handle<SharedFunctionInfo> alternative_toplevel_sfi =
-      Compiler::GetSharedFunctionInfoForScript(
-          isolate, src, alternative_script_details,
-          ScriptCompiler::kNoCompileOptions, ScriptCompiler::kNoCacheNoReason,
-          NOT_NATIVES_CODE)
-          .ToHandleChecked();
-  CHECK_NE(*copy, *alternative_toplevel_sfi);
-
-  {
-    // The original script can still be found.
-    ScriptDetails script_details(src);
-    script_details.host_defined_options =
-        default_script_details.host_defined_options;
-    auto lookup_result = isolate->compilation_cache()->LookupScript(
-        src, script_details, LanguageMode::kSloppy);
-    CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *copy);
-  }
-
-  {
-    // The new script can also be found.
-    ScriptDetails script_details(src);
-    auto lookup_result = isolate->compilation_cache()->LookupScript(
-        src, script_details, LanguageMode::kSloppy);
-    CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(),
-             *alternative_toplevel_sfi);
-  }
-
   delete cache;
 }
 
@@ -2538,7 +2477,7 @@ v8::ScriptCompiler::CachedData* CompileRunAndProduceCache(
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(js_source);
-    v8::ScriptOrigin origin(isolate1, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin);
     v8::ScriptCompiler::CompileOptions options;
     switch (cacheType) {
@@ -2594,7 +2533,7 @@ TEST(CodeSerializerIsolates) {
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(js_source);
-    v8::ScriptOrigin origin(isolate2, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::Local<v8::UnboundScript> script;
     {
@@ -2640,7 +2579,7 @@ TEST(CodeSerializerIsolatesEager) {
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(js_source);
-    v8::ScriptOrigin origin(isolate2, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::Local<v8::UnboundScript> script;
     {
@@ -2683,7 +2622,7 @@ TEST(CodeSerializerAfterExecute) {
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(js_source);
-    v8::ScriptOrigin origin(isolate2, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::Local<v8::UnboundScript> script;
     {
@@ -2733,7 +2672,7 @@ TEST(CodeSerializerFlagChange) {
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(js_source);
-    v8::ScriptOrigin origin(isolate2, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::ScriptCompiler::CompileUnboundScript(
         isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache)
@@ -2763,7 +2702,7 @@ TEST(CodeSerializerBitFlip) {
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(js_source);
-    v8::ScriptOrigin origin(isolate2, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::ScriptCompiler::CompileUnboundScript(
         isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache)
@@ -2793,7 +2732,7 @@ TEST(CodeSerializerWithHarmonyScoping) {
     CompileRun(source2);
 
     v8::Local<v8::String> source_str = v8_str(source3);
-    v8::ScriptOrigin origin(isolate1, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin);
     v8::Local<v8::UnboundScript> script =
         v8::ScriptCompiler::CompileUnboundScript(
@@ -2824,7 +2763,7 @@ TEST(CodeSerializerWithHarmonyScoping) {
     CompileRun(source1);
 
     v8::Local<v8::String> source_str = v8_str(source3);
-    v8::ScriptOrigin origin(isolate2, v8_str("test"));
+    v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::Local<v8::UnboundScript> script;
     {
@@ -3658,8 +3597,7 @@ UNINITIALIZED_TEST(SnapshotCreatorAddData) {
       v8::Local<v8::Signature> signature =
           v8::Signature::New(isolate, v8::FunctionTemplate::New(isolate));
 
-      v8::ScriptOrigin origin(isolate, v8_str(""), {}, {}, {}, {}, {}, {}, {},
-                              true);
+      v8::ScriptOrigin origin(v8_str(""), {}, {}, {}, {}, {}, {}, {}, true);
       v8::ScriptCompiler::Source source(
           v8::String::NewFromUtf8Literal(
               isolate, "export let a = 42; globalThis.a = {};"),
diff --git a/deps/v8/test/inspector/isolate-data.cc b/deps/v8/test/inspector/isolate-data.cc
index a3bb4854b56942..cebe849e05aba7 100644
--- a/deps/v8/test/inspector/isolate-data.cc
+++ b/deps/v8/test/inspector/isolate-data.cc
@@ -449,8 +449,8 @@ void InspectorIsolateData::installAdditionalCommandLineAPI(
   CHECK(context->GetIsolate() == isolate());
   v8::HandleScope handle_scope(isolate());
   v8::Context::Scope context_scope(context);
-  v8::ScriptOrigin origin(isolate(), v8::String::NewFromUtf8Literal(
-                                         isolate(), "internal-console-api"));
+  v8::ScriptOrigin origin(
+      v8::String::NewFromUtf8Literal(isolate(), "internal-console-api"));
   v8::ScriptCompiler::Source scriptSource(
       additional_console_api_.Get(isolate()), origin);
   v8::MaybeLocal<v8::Script> script =
diff --git a/deps/v8/test/inspector/tasks.cc b/deps/v8/test/inspector/tasks.cc
index 13168f283982c5..fc76d9e18cd1cc 100644
--- a/deps/v8/test/inspector/tasks.cc
+++ b/deps/v8/test/inspector/tasks.cc
@@ -20,8 +20,8 @@ void ExecuteStringTask::Run(InspectorIsolateData* data) {
   v8::HandleScope handle_scope(data->isolate());
   v8::Local<v8::Context> context = data->GetDefaultContext(context_group_id_);
   v8::Context::Scope context_scope(context);
-  v8::ScriptOrigin origin(data->isolate(), ToV8String(data->isolate(), name_),
-                          line_offset_, column_offset_,
+  v8::ScriptOrigin origin(ToV8String(data->isolate(), name_), line_offset_,
+                          column_offset_,
                           /* resource_is_shared_cross_origin */ false,
                           /* script_id */ -1,
                           /* source_map_url */ v8::Local<v8::Value>(),
diff --git a/deps/v8/test/mjsunit/harmony/modules-import-16.mjs b/deps/v8/test/mjsunit/harmony/modules-import-16.mjs
index 92f87632604f80..cf1ed9723c04cf 100644
--- a/deps/v8/test/mjsunit/harmony/modules-import-16.mjs
+++ b/deps/v8/test/mjsunit/harmony/modules-import-16.mjs
@@ -8,7 +8,7 @@ globalThis.ran = false;
 globalThis.x = undefined;
 
 let body = "import('modules-skip-1.mjs').then(ns => { x = ns.life();" +
-    " ran = true;} ).catch(err => %AbortJS(err))"
+    " ran = true;} ).catch(err => %AbortJS(err.toString()))"
 let func = new Function(body);
 func();
 
@@ -18,7 +18,7 @@ assertTrue(globalThis.ran);
 
 globalThis.ran = false;
 body = "import('modules-skip-1.mjs').then(ns => { x = ns.life();" +
-    " ran = true;} ).catch(err => %AbortJS(err))"
+    " ran = true;} ).catch(err => %AbortJS(err.toString()))"
 eval("var func = new Function(body); func();");
 
 %PerformMicrotaskCheckpoint();
@@ -27,7 +27,7 @@ assertTrue(globalThis.ran);
 
 globalThis.ran = false;
 body = "eval(import('modules-skip-1.mjs').then(ns => { x = ns.life();" +
-    " ran = true;} ).catch(err => %AbortJS(err)))"
+    " ran = true;} ).catch(err => %AbortJS(err.toString())))"
 func = new Function(body);
 func();
 
diff --git a/deps/v8/test/mjsunit/mjsunit.status b/deps/v8/test/mjsunit/mjsunit.status
index 8f7a4f7a59452a..d4c8f74245b29d 100644
--- a/deps/v8/test/mjsunit/mjsunit.status
+++ b/deps/v8/test/mjsunit/mjsunit.status
@@ -125,6 +125,9 @@
   # OOM flakes in isolates tests because too many largish heaps are created.
   'asm/asm-heap': [PASS, NO_VARIANTS, ['isolates', SKIP]],
 
+  # https://crbug.com/1244145
+  "harmony/modules-import-16": [FAIL],
+
   # Slow tests.
   'array-functions-prototype-misc': [PASS, SLOW],
   'asm/embenchen/*': [PASS, SLOW, NO_VARIANTS],
diff --git a/deps/v8/test/test262/test262.status b/deps/v8/test/test262/test262.status
index 529aab96afd76d..4be6b1a1f5d5c5 100644
--- a/deps/v8/test/test262/test262.status
+++ b/deps/v8/test/test262/test262.status
@@ -636,6 +636,9 @@
   'language/statements/class/subclass/derived-class-return-override-finally-super-arrow': [FAIL],
   'language/statements/class/subclass/derived-class-return-override-for-of-arrow': [FAIL],
 
+  # https://crbug.com/1244145
+  'language/expressions/dynamic-import/usage-from-eval': [FAIL],
+
   # https://bugs.chromium.org/p/v8/issues/detail?id=12524
   'built-ins/Date/prototype/setHours/arg-coercion-order': [FAIL],
   'built-ins/Date/prototype/setMinutes/arg-coercion-order': [FAIL],
diff --git a/deps/v8/test/unittests/api/deserialize-unittest.cc b/deps/v8/test/unittests/api/deserialize-unittest.cc
index f649beb26fca43..c94a2531c3f1cf 100644
--- a/deps/v8/test/unittests/api/deserialize-unittest.cc
+++ b/deps/v8/test/unittests/api/deserialize-unittest.cc
@@ -407,7 +407,7 @@ class MergeDeserializedCodeTest : public DeserializeTest {
     std::unique_ptr<v8::ScriptCompiler::CachedData> cached_data;
     IsolateAndContextScope scope(this);
     i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate());
-    ScriptOrigin default_origin(isolate(), NewString(""));
+    ScriptOrigin default_origin(NewString(""));
 
     i::Handle<i::WeakFixedArray> original_objects =
         i_isolate->factory()->NewWeakFixedArray(kScriptObjectsCount);
@@ -639,7 +639,7 @@ TEST_F(MergeDeserializedCodeTest, MergeWithNoFollowUpWork) {
   std::unique_ptr<v8::ScriptCompiler::CachedData> cached_data;
   IsolateAndContextScope scope(this);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate());
-  ScriptOrigin default_origin(isolate(), NewString(""));
+  ScriptOrigin default_origin(NewString(""));
 
   constexpr char kSourceCode[] = "function f() {}";
   Local<Script> original_script;
diff --git a/deps/v8/test/unittests/api/v8-script-unittest.cc b/deps/v8/test/unittests/api/v8-script-unittest.cc
index 98040cf6626e11..5739d0e5bacdc6 100644
--- a/deps/v8/test/unittests/api/v8-script-unittest.cc
+++ b/deps/v8/test/unittests/api/v8-script-unittest.cc
@@ -33,8 +33,8 @@ v8::MaybeLocal<Module> ResolveToTopLevelAwait(Local<Context> context,
                                               Local<FixedArray> assertions,
                                               Local<Module> referrer) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  v8::ScriptOrigin origin(isolate, specifier, 0, 0, false, -1, Local<Value>(),
-                          false, false, true);
+  v8::ScriptOrigin origin(specifier, 0, 0, false, -1, Local<Value>(), false,
+                          false, true);
 
   String::Utf8Value specifier_string(isolate, specifier);
   std::string source_string =
@@ -68,7 +68,7 @@ class ScriptTest : public TestWithContext {
     v8::Local<v8::Context> context = v8::Context::New(isolate());
     v8::Context::Scope cscope(context);
 
-    v8::ScriptOrigin origin(isolate(), NewString("root.mjs"), 0, 0, false, -1,
+    v8::ScriptOrigin origin(NewString("root.mjs"), 0, 0, false, -1,
                             Local<Value>(), false, false, true);
     v8::ScriptCompiler::Source source(NewString(source_str), origin);
     Local<Module> root =
@@ -111,7 +111,7 @@ class ScriptTest : public TestWithContext {
 
 TEST_F(ScriptTest, UnboundScriptPosition) {
   const char* url = "http://www.foo.com/foo.js";
-  v8::ScriptOrigin origin(isolate(), NewString(url), 13, 0);
+  v8::ScriptOrigin origin(NewString(url), 13, 0);
   v8::ScriptCompiler::Source script_source(NewString("var foo;"), origin);
 
   Local<Script> script =
diff --git a/deps/v8/test/unittests/compiler/compiler-unittest.cc b/deps/v8/test/unittests/compiler/compiler-unittest.cc
index abef44976cfe3b..dc1b75b4025427 100644
--- a/deps/v8/test/unittests/compiler/compiler-unittest.cc
+++ b/deps/v8/test/unittests/compiler/compiler-unittest.cc
@@ -253,7 +253,7 @@ TEST_F(CompilerTest, Regression236) {
 
 TEST_F(CompilerTest, GetScriptLineNumber) {
   v8::HandleScope scope(isolate());
-  v8::ScriptOrigin origin = v8::ScriptOrigin(isolate(), NewString("test"));
+  v8::ScriptOrigin origin = v8::ScriptOrigin(NewString("test"));
   const char function_f[] = "function f() {}";
   const int max_rows = 1000;
   const int buffer_size = max_rows + sizeof(function_f);
@@ -606,7 +606,7 @@ TEST_F(CompilerTest, CompileFunctionQuirks) {
 
 TEST_F(CompilerTest, CompileFunctionScriptOrigin) {
   v8::HandleScope scope(isolate());
-  v8::ScriptOrigin origin(isolate(), NewString("test"), 22, 41);
+  v8::ScriptOrigin origin(NewString("test"), 22, 41);
   v8::ScriptCompiler::Source script_source(NewString("throw new Error()"),
                                            origin);
   v8::Local<v8::Function> fun =
@@ -648,7 +648,7 @@ TEST_F(CompilerTest, CompileFunctionFunctionToString) {
 
     // Regression test for v8:6190
     {
-      v8::ScriptOrigin origin(isolate(), NewString("test"), 22, 41);
+      v8::ScriptOrigin origin(NewString("test"), 22, 41);
       v8::ScriptCompiler::Source script_source(NewString("return event"),
                                                origin);
 
@@ -674,7 +674,7 @@ TEST_F(CompilerTest, CompileFunctionFunctionToString) {
 
     // With no parameters:
     {
-      v8::ScriptOrigin origin(isolate(), NewString("test"), 17, 31);
+      v8::ScriptOrigin origin(NewString("test"), 17, 31);
       v8::ScriptCompiler::Source script_source(NewString("return 0"), origin);
 
       v8::TryCatch try_catch(isolate());
@@ -697,7 +697,7 @@ TEST_F(CompilerTest, CompileFunctionFunctionToString) {
 
     // With a name:
     {
-      v8::ScriptOrigin origin(isolate(), NewString("test"), 17, 31);
+      v8::ScriptOrigin origin(NewString("test"), 17, 31);
       v8::ScriptCompiler::Source script_source(NewString("return 0"), origin);
 
       v8::TryCatch try_catch(isolate());
@@ -914,7 +914,7 @@ TEST_F(CompilerTest, ProfilerEnabledDuringBackgroundCompile) {
   v8::Local<v8::Script> script =
       v8::ScriptCompiler::Compile(isolate()->GetCurrentContext(),
                                   &streamed_source, NewString(source),
-                                  v8::ScriptOrigin(isolate(), NewString("foo")))
+                                  v8::ScriptOrigin(NewString("foo")))
           .ToLocalChecked();
 
   i::Handle<i::Object> obj = Utils::OpenHandle(*script);
diff --git a/deps/v8/test/unittests/interpreter/bytecode-expectations-printer.cc b/deps/v8/test/unittests/interpreter/bytecode-expectations-printer.cc
index bec63500b30c1b..358d358c2dcc67 100644
--- a/deps/v8/test/unittests/interpreter/bytecode-expectations-printer.cc
+++ b/deps/v8/test/unittests/interpreter/bytecode-expectations-printer.cc
@@ -72,8 +72,8 @@ v8::Local<v8::Script> BytecodeExpectationsPrinter::CompileScript(
 
 v8::Local<v8::Module> BytecodeExpectationsPrinter::CompileModule(
     const char* program) const {
-  ScriptOrigin origin(isolate_, Local<v8::Value>(), 0, 0, false, -1,
-                      Local<v8::Value>(), false, false, true);
+  ScriptOrigin origin(Local<v8::Value>(), 0, 0, false, -1, Local<v8::Value>(),
+                      false, false, true);
   v8::ScriptCompiler::Source source(V8StringFromUTF8(program), origin);
   return v8::ScriptCompiler::CompileModule(isolate_, &source).ToLocalChecked();
 }
diff --git a/deps/v8/test/unittests/logging/log-unittest.cc b/deps/v8/test/unittests/logging/log-unittest.cc
index 764064c40df85d..cefb0b13257f81 100644
--- a/deps/v8/test/unittests/logging/log-unittest.cc
+++ b/deps/v8/test/unittests/logging/log-unittest.cc
@@ -636,7 +636,7 @@ TEST_F(LogInterpretedFramesNativeStackWithSerializationTest,
       v8::Local<v8::String> source = NewString(
           "function eyecatcher() { return a * a; } return eyecatcher();");
       v8::Local<v8::String> arg_str = NewString("a");
-      v8::ScriptOrigin origin(isolate, NewString("filename"));
+      v8::ScriptOrigin origin(NewString("filename"));
 
       i::DisallowCompilation* no_compile_expected =
           has_cache ? new i::DisallowCompilation(
@@ -765,7 +765,7 @@ TEST_F(LogExternalLogEventListenerInnerFunctionTest,
     code_event_handler.Enable();
 
     v8::Local<v8::String> source_string = NewString(source_cstring);
-    v8::ScriptOrigin origin(isolate1, NewString("test"));
+    v8::ScriptOrigin origin(NewString("test"));
     v8::ScriptCompiler::Source source(source_string, origin);
     v8::Local<v8::UnboundScript> script =
         v8::ScriptCompiler::CompileUnboundScript(isolate1, &source)
@@ -791,7 +791,7 @@ TEST_F(LogExternalLogEventListenerInnerFunctionTest,
     code_event_handler.Enable();
 
     v8::Local<v8::String> source_string = NewString(source_cstring);
-    v8::ScriptOrigin origin(isolate2, NewString("test"));
+    v8::ScriptOrigin origin(NewString("test"));
     v8::ScriptCompiler::Source source(source_string, origin, cache);
     {
       i::DisallowCompilation no_compile_expected(
diff --git a/deps/v8/test/unittests/objects/modules-unittest.cc b/deps/v8/test/unittests/objects/modules-unittest.cc
index d3ac95a3e352dc..05431c397f0571 100644
--- a/deps/v8/test/unittests/objects/modules-unittest.cc
+++ b/deps/v8/test/unittests/objects/modules-unittest.cc
@@ -29,8 +29,8 @@ using v8::String;
 using v8::Value;
 
 ScriptOrigin ModuleOrigin(Local<v8::Value> resource_name, Isolate* isolate) {
-  ScriptOrigin origin(isolate, resource_name, 0, 0, false, -1,
-                      Local<v8::Value>(), false, false, true);
+  ScriptOrigin origin(resource_name, 0, 0, false, -1, Local<v8::Value>(), false,
+                      false, true);
   return origin;
 }
 
diff --git a/deps/v8/test/unittests/test-utils.h b/deps/v8/test/unittests/test-utils.h
index 56e4f4538b6f18..d5300e1299fcd9 100644
--- a/deps/v8/test/unittests/test-utils.h
+++ b/deps/v8/test/unittests/test-utils.h
@@ -180,7 +180,7 @@ class WithIsolateScopeMixin : public TMixin {
                                   Local<String> origin_url,
                                   bool is_shared_cross_origin) {
     Isolate* isolate = Isolate::GetCurrent();
-    ScriptOrigin origin(isolate, origin_url, 0, 0, is_shared_cross_origin);
+    ScriptOrigin origin(origin_url, 0, 0, is_shared_cross_origin);
     ScriptCompiler::Source script_source(source, origin);
     return ScriptCompiler::Compile(isolate->GetCurrentContext(), &script_source)
         .ToLocalChecked();
diff --git a/lib/internal/modules/esm/create_dynamic_module.js b/lib/internal/modules/esm/create_dynamic_module.js
index f7c20083b6c918..f63e6c430959bc 100644
--- a/lib/internal/modules/esm/create_dynamic_module.js
+++ b/lib/internal/modules/esm/create_dynamic_module.js
@@ -35,7 +35,7 @@ ${ArrayPrototypeJoin(ArrayPrototypeMap(imports, createImport), '\n')}
 ${ArrayPrototypeJoin(ArrayPrototypeMap(exports, createExport), '\n')}
 import.meta.done();
 `;
-  const { ModuleWrap, callbackMap } = internalBinding('module_wrap');
+  const { ModuleWrap, moduleMetaSym } = internalBinding('module_wrap');
   const m = new ModuleWrap(`${url}`, undefined, source, 0, 0);
 
   const readyfns = new SafeSet();
@@ -47,7 +47,7 @@ import.meta.done();
   if (imports.length)
     reflect.imports = ObjectCreate(null);
 
-  callbackMap.set(m, {
+  m[moduleMetaSym] = {
     initializeImportMeta: (meta, wrap) => {
       meta.exports = reflect.exports;
       if (reflect.imports)
@@ -61,7 +61,7 @@ import.meta.done();
         }
       };
     },
-  });
+  };
 
   return {
     module: m,
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index e4d320ebc39cce..29431ccaa63f7d 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -362,13 +362,13 @@ class ESMLoader {
     url = pathToFileURL(`${process.cwd()}/[eval${++this.evalIndex}]`).href
   ) {
     const evalInstance = (url) => {
-      const { ModuleWrap, callbackMap } = internalBinding('module_wrap');
+      const { ModuleWrap, moduleMetaSym } = internalBinding('module_wrap');
       const module = new ModuleWrap(url, undefined, source, 0, 0);
-      callbackMap.set(module, {
+      module[moduleMetaSym] = {
         importModuleDynamically: (specifier, { url }, importAssertions) => {
           return this.import(specifier, url, importAssertions);
         }
-      });
+      };
 
       return module;
     };
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 6f25b2e67ab776..8850b773d83da6 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -117,10 +117,8 @@ translators.set('module', async function moduleStrategy(url, source, isMain) {
   maybeCacheSourceMap(url, source);
   debug(`Translating StandardModule ${url}`);
   const module = new ModuleWrap(url, undefined, source, 0, 0);
-  moduleWrap.callbackMap.set(module, {
-    initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
-    importModuleDynamically,
-  });
+  module[moduleWrap.moduleMetaSym].initializeImportMeta = (meta, wrap) => this.importMetaInitialize(meta, { url });
+  module[moduleWrap.moduleMetaSym].importModuleDynamically = importModuleDynamically;
   return module;
 });
 
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 473cea48cafe64..666b165b307fd0 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -18,9 +18,9 @@ const {
 } = require('internal/vm/module');
 
 exports.initializeImportMetaObject = function(wrap, meta) {
-  const { callbackMap } = internalBinding('module_wrap');
-  if (callbackMap.has(wrap)) {
-    const { initializeImportMeta } = callbackMap.get(wrap);
+  const { moduleMetaSym } = internalBinding('module_wrap');
+  if (wrap[moduleMetaSym]) {
+    const { initializeImportMeta } = wrap[moduleMetaSym];
     if (initializeImportMeta !== undefined) {
       initializeImportMeta(meta, getModuleFromWrap(wrap) || wrap);
     }
@@ -29,9 +29,9 @@ exports.initializeImportMetaObject = function(wrap, meta) {
 
 exports.importModuleDynamicallyCallback =
 async function importModuleDynamicallyCallback(wrap, specifier, assertions) {
-  const { callbackMap } = internalBinding('module_wrap');
-  if (callbackMap.has(wrap)) {
-    const { importModuleDynamically } = callbackMap.get(wrap);
+  const { moduleMetaSym } = internalBinding('module_wrap');
+  if (wrap[moduleMetaSym]) {
+    const { importModuleDynamically } = wrap[moduleMetaSym];
     if (importModuleDynamically !== undefined) {
       return importModuleDynamically(
         specifier, getModuleFromWrap(wrap) || wrap, assertions);
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 5ef59d9d9f3178..5287f447363d0f 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -571,9 +571,6 @@ function initializeCJSLoader() {
 }
 
 function initializeESMLoader() {
-  // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
-  internalBinding('module_wrap').callbackMap = new SafeWeakMap();
-
   if (getEmbedderOptions().shouldNotRegisterESMLoader) return;
 
   const {
diff --git a/lib/internal/vm.js b/lib/internal/vm.js
index 32bcdf06234b67..718b8a1b0623db 100644
--- a/lib/internal/vm.js
+++ b/lib/internal/vm.js
@@ -96,12 +96,12 @@ function internalCompileFunction(code, params, options) {
                      'options.importModuleDynamically');
     const { importModuleDynamicallyWrap } =
       require('internal/vm/module');
-    const { callbackMap } = internalBinding('module_wrap');
+    const { moduleMetaSym } = internalBinding('module_wrap');
     const wrapped = importModuleDynamicallyWrap(importModuleDynamically);
     const func = result.function;
-    callbackMap.set(result.cacheKey, {
+    result.cacheKey[moduleMetaSym] = {
       importModuleDynamically: (s, _k, i) => wrapped(s, func, i),
-    });
+    };
   }
 
   return result;
diff --git a/lib/internal/vm/module.js b/lib/internal/vm/module.js
index 7e0131c7db2872..dc6fa437b5bb55 100644
--- a/lib/internal/vm/module.js
+++ b/lib/internal/vm/module.js
@@ -126,12 +126,10 @@ class Module {
                                    options.lineOffset, options.columnOffset,
                                    options.cachedData);
 
-      binding.callbackMap.set(this[kWrap], {
-        initializeImportMeta: options.initializeImportMeta,
-        importModuleDynamically: options.importModuleDynamically ?
+      this[kWrap][binding.moduleMetaSym].initializeImportMeta = options.initializeImportMeta;
+      this[kWrap][binding.moduleMetaSym].importModuleDynamically = options.importModuleDynamically ?
           importModuleDynamicallyWrap(options.importModuleDynamically) :
-          undefined,
-      });
+          undefined;
     } else {
       assert(syntheticEvaluationSteps);
       this[kWrap] = new ModuleWrap(identifier, context,
diff --git a/lib/vm.js b/lib/vm.js
index ec91c8a2651775..b99c4e48fd94c6 100644
--- a/lib/vm.js
+++ b/lib/vm.js
@@ -113,11 +113,11 @@ class Script extends ContextifyScript {
                        'options.importModuleDynamically');
       const { importModuleDynamicallyWrap } =
         require('internal/vm/module');
-      const { callbackMap } = internalBinding('module_wrap');
-      callbackMap.set(this, {
+      const { moduleMetaSym } = internalBinding('module_wrap');
+      this[moduleMetaSym] = {
         importModuleDynamically:
           importModuleDynamicallyWrap(importModuleDynamically),
-      });
+      };
     }
   }
 
diff --git a/src/env-inl.h b/src/env-inl.h
index a512d175a29cfe..5fea11e199d996 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -389,16 +389,6 @@ inline AliasedInt32Array& Environment::stream_base_state() {
   return stream_base_state_;
 }
 
-inline uint32_t Environment::get_next_module_id() {
-  return module_id_counter_++;
-}
-inline uint32_t Environment::get_next_script_id() {
-  return script_id_counter_++;
-}
-inline uint32_t Environment::get_next_function_id() {
-  return function_id_counter_++;
-}
-
 ShouldNotAbortOnUncaughtScope::ShouldNotAbortOnUncaughtScope(
     Environment* env)
     : env_(env) {
diff --git a/src/env.h b/src/env.h
index 396416b42ae348..56f78f4f8bf506 100644
--- a/src/env.h
+++ b/src/env.h
@@ -723,14 +723,6 @@ class Environment : public MemoryRetainer {
   std::vector<std::string> builtins_in_snapshot;
 
   std::unordered_multimap<int, loader::ModuleWrap*> hash_to_module_map;
-  std::unordered_map<uint32_t, loader::ModuleWrap*> id_to_module_map;
-  std::unordered_map<uint32_t, contextify::ContextifyScript*>
-      id_to_script_map;
-  std::unordered_map<uint32_t, contextify::CompiledFnEntry*> id_to_function_map;
-
-  inline uint32_t get_next_module_id();
-  inline uint32_t get_next_script_id();
-  inline uint32_t get_next_function_id();
 
   EnabledDebugList* enabled_debug_list() { return &enabled_debug_list_; }
 
@@ -1054,10 +1046,6 @@ class Environment : public MemoryRetainer {
   uint32_t heap_snapshot_near_heap_limit_ = 0;
   bool heapsnapshot_near_heap_limit_callback_added_ = false;
 
-  uint32_t module_id_counter_ = 0;
-  uint32_t script_id_counter_ = 0;
-  uint32_t function_id_counter_ = 0;
-
   AliasedInt32Array exit_info_;
 
   AliasedUint32Array should_abort_on_uncaught_toggle_;
diff --git a/src/env_properties.h b/src/env_properties.h
index 89d2b11af83cca..dc7a4aabc90cf8 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -36,6 +36,7 @@
   V(messaging_transfer_symbol, "messaging_transfer_symbol")                    \
   V(messaging_clone_symbol, "messaging_clone_symbol")                          \
   V(messaging_transfer_list_symbol, "messaging_transfer_list_symbol")          \
+  V(module_meta_symbol, "module_meta_symbol")                                  \
   V(oninit_symbol, "oninit")                                                   \
   V(owner_symbol, "owner_symbol")                                              \
   V(onpskexchange_symbol, "onpskexchange")                                     \
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index f4557ee9915c65..db7303962af43d 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -55,22 +55,20 @@ ModuleWrap::ModuleWrap(Environment* env,
                        Local<Object> object,
                        Local<Module> module,
                        Local<String> url)
-  : BaseObject(env, object),
-    module_(env->isolate(), module),
-    id_(env->get_next_module_id()) {
-  env->id_to_module_map.emplace(id_, this);
-
+    : BaseObject(env, object),
+      module_(env->isolate(), module),
+      identity_hash_(module->GetIdentityHash()) {
   Local<Value> undefined = Undefined(env->isolate());
   object->SetInternalField(kURLSlot, url);
   object->SetInternalField(kSyntheticEvaluationStepsSlot, undefined);
   object->SetInternalField(kContextObjectSlot, undefined);
+
+  module_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
 }
 
 ModuleWrap::~ModuleWrap() {
   HandleScope scope(env()->isolate());
-  Local<Module> module = module_.Get(env()->isolate());
-  env()->id_to_module_map.erase(id_);
-  auto range = env()->hash_to_module_map.equal_range(module->GetIdentityHash());
+  auto range = env()->hash_to_module_map.equal_range(identity_hash_);
   for (auto it = range.first; it != range.second; ++it) {
     if (it->second == this) {
       env()->hash_to_module_map.erase(it);
@@ -79,6 +77,12 @@ ModuleWrap::~ModuleWrap() {
   }
 }
 
+// static
+void ModuleWrap::WeakCallback(const v8::WeakCallbackInfo<ModuleWrap>& data) {
+  ModuleWrap* wrap = data.GetParameter();
+  delete wrap;
+}
+
 Local<Context> ModuleWrap::context() const {
   Local<Value> obj = object()->GetInternalField(kContextObjectSlot);
   if (obj.IsEmpty()) return {};
@@ -96,14 +100,6 @@ ModuleWrap* ModuleWrap::GetFromModule(Environment* env,
   return nullptr;
 }
 
-ModuleWrap* ModuleWrap::GetFromID(Environment* env, uint32_t id) {
-  auto module_wrap_it = env->id_to_module_map.find(id);
-  if (module_wrap_it == env->id_to_module_map.end()) {
-    return nullptr;
-  }
-  return module_wrap_it->second;
-}
-
 // new ModuleWrap(url, context, source, lineOffset, columnOffset)
 // new ModuleWrap(url, context, exportNames, syntheticExecutionFunction)
 void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
@@ -146,11 +142,6 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
     column_offset = args[4].As<Int32>()->Value();
   }
 
-  Local<PrimitiveArray> host_defined_options =
-      PrimitiveArray::New(isolate, HostDefinedOptions::kLength);
-  host_defined_options->Set(isolate, HostDefinedOptions::kType,
-                            Number::New(isolate, ScriptType::kModule));
-
   ShouldNotAbortOnUncaughtScope no_abort_scope(env);
   TryCatchScope try_catch(env);
 
@@ -186,17 +177,16 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
       }
 
       Local<String> source_text = args[2].As<String>();
-      ScriptOrigin origin(isolate,
-                          url,
+      ScriptOrigin origin(url,
                           line_offset,
                           column_offset,
-                          true,                             // is cross origin
-                          -1,                               // script id
-                          Local<Value>(),                   // source map URL
-                          false,                            // is opaque (?)
-                          false,                            // is WASM
-                          true,                             // is ES Module
-                          host_defined_options);
+                          true,            // is cross origin
+                          -1,              // script id
+                          Local<Value>(),  // source map URL
+                          false,           // is opaque (?)
+                          false,           // is WASM
+                          true,            // is ES Module
+                          that);           // host defined options
       ScriptCompiler::Source source(source_text, origin, cached_data);
       ScriptCompiler::CompileOptions options;
       if (source.GetCachedData() == nullptr) {
@@ -245,9 +235,8 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
 
   env->hash_to_module_map.emplace(module->GetIdentityHash(), obj);
 
-  host_defined_options->Set(isolate, HostDefinedOptions::kID,
-                            Number::New(isolate, obj->id()));
-
+  that->Set(context, env->module_meta_symbol(), Object::New(isolate))
+      .FromJust();
   that->SetIntegrityLevel(context, IntegrityLevel::kFrozen);
   args.GetReturnValue().Set(that);
 }
@@ -568,42 +557,21 @@ static MaybeLocal<Promise> ImportModuleDynamically(
   Local<Function> import_callback =
     env->host_import_module_dynamically_callback();
 
-  Local<FixedArray> options = host_defined_options.As<FixedArray>();
-  if (options->Length() != HostDefinedOptions::kLength) {
+  Local<Value> object;
+  if (host_defined_options->IsValue()) {
+    object = host_defined_options.As<Value>();
+  } else {
     Local<Promise::Resolver> resolver;
     if (!Promise::Resolver::New(context).ToLocal(&resolver)) return {};
     resolver
-        ->Reject(context,
-                 v8::Exception::TypeError(FIXED_ONE_BYTE_STRING(
-                     context->GetIsolate(), "Invalid host defined options")))
+        ->Reject(
+            context,
+            ERR_INVALID_SCRIPT_CONTEXT(
+                isolate, "Invalid script context initiating dynamic import"))
         .ToChecked();
     return handle_scope.Escape(resolver->GetPromise());
   }
 
-  Local<Value> object;
-
-  int type = options->Get(context, HostDefinedOptions::kType)
-                 .As<Number>()
-                 ->Int32Value(context)
-                 .ToChecked();
-  uint32_t id = options->Get(context, HostDefinedOptions::kID)
-                    .As<Number>()
-                    ->Uint32Value(context)
-                    .ToChecked();
-  if (type == ScriptType::kScript) {
-    contextify::ContextifyScript* wrap = env->id_to_script_map.find(id)->second;
-    object = wrap->object();
-  } else if (type == ScriptType::kModule) {
-    ModuleWrap* wrap = ModuleWrap::GetFromID(env, id);
-    object = wrap->object();
-  } else if (type == ScriptType::kFunction) {
-    auto it = env->id_to_function_map.find(id);
-    CHECK_NE(it, env->id_to_function_map.end());
-    object = it->second->object();
-  } else {
-    UNREACHABLE();
-  }
-
   Local<Object> assertions =
     createImportAssertionContainer(env, isolate, import_assertions);
 
@@ -809,6 +777,12 @@ void ModuleWrap::Initialize(Local<Object> target,
     V(kEvaluated);
     V(kErrored);
 #undef V
+
+    target
+        ->Set(context,
+              FIXED_ONE_BYTE_STRING(env->isolate(), "moduleMetaSym"),
+              env->module_meta_symbol())
+        .FromJust();
 }
 
 }  // namespace loader
diff --git a/src/module_wrap.h b/src/module_wrap.h
index 58b233d036515c..44f1a026b4142e 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -53,9 +53,7 @@ class ModuleWrap : public BaseObject {
     tracker->TrackField("resolve_cache", resolve_cache_);
   }
 
-  inline uint32_t id() { return id_; }
   v8::Local<v8::Context> context() const;
-  static ModuleWrap* GetFromID(node::Environment*, uint32_t id);
 
   SET_MEMORY_INFO_NAME(ModuleWrap)
   SET_SELF_SIZE(ModuleWrap)
@@ -100,12 +98,14 @@ class ModuleWrap : public BaseObject {
       v8::Local<v8::Module> referrer);
   static ModuleWrap* GetFromModule(node::Environment*, v8::Local<v8::Module>);
 
+  static void WeakCallback(const v8::WeakCallbackInfo<ModuleWrap>& data);
+
   v8::Global<v8::Module> module_;
+  int identity_hash_;
   std::unordered_map<std::string, v8::Global<v8::Promise>> resolve_cache_;
   contextify::ContextifyContext* contextify_context_ = nullptr;
   bool synthetic_ = false;
   bool linked_ = false;
-  uint32_t id_;
 };
 
 }  // namespace loader
diff --git a/src/node_builtins.cc b/src/node_builtins.cc
index 768e248fc9f171..ae72ba6bc61385 100644
--- a/src/node_builtins.cc
+++ b/src/node_builtins.cc
@@ -280,7 +280,7 @@ MaybeLocal<Function> BuiltinLoader::LookupAndCompileInternal(
   std::string filename_s = std::string("node:") + id;
   Local<String> filename =
       OneByteString(isolate, filename_s.c_str(), filename_s.size());
-  ScriptOrigin origin(isolate, filename, 0, 0, true);
+  ScriptOrigin origin(filename, 0, 0, true);
 
   ScriptCompiler::CachedData* cached_data = nullptr;
   {
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index 45c5b33b634a22..de114ee6232e42 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -42,6 +42,7 @@ using v8::ArrayBufferView;
 using v8::Boolean;
 using v8::Context;
 using v8::EscapableHandleScope;
+using v8::FixedArray;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -813,24 +814,15 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
         data + cached_data_buf->ByteOffset(), cached_data_buf->ByteLength());
   }
 
-  Local<PrimitiveArray> host_defined_options =
-      PrimitiveArray::New(isolate, loader::HostDefinedOptions::kLength);
-  host_defined_options->Set(isolate, loader::HostDefinedOptions::kType,
-                            Number::New(isolate, loader::ScriptType::kScript));
-  host_defined_options->Set(isolate, loader::HostDefinedOptions::kID,
-                            Number::New(isolate, contextify_script->id()));
-
-  ScriptOrigin origin(isolate,
-                      filename,
-                      line_offset,                          // line offset
-                      column_offset,                        // column offset
-                      true,                                 // is cross origin
-                      -1,                                   // script id
-                      Local<Value>(),                       // source map URL
-                      false,                                // is opaque (?)
-                      false,                                // is WASM
-                      false,                                // is ES Module
-                      host_defined_options);
+  ScriptOrigin origin(filename,
+                      line_offset,     // line offset
+                      column_offset,   // column offset
+                      true,            // is cross origin
+                      -1,              // script id
+                      Local<Value>(),  // source map URL
+                      false,           // is opaque (?)
+                      false,           // is WASM
+                      false);          // is ES Module
   ScriptCompiler::Source source(code, origin, cached_data);
   ScriptCompiler::CompileOptions compile_options =
       ScriptCompiler::kNoCompileOptions;
@@ -967,7 +959,8 @@ void ContextifyScript::RunInContext(const FunctionCallbackInfo<Value>& args) {
               break_on_sigint,
               break_on_first_line,
               microtask_queue,
-              args);
+              args,
+              args.Holder());
 }
 
 bool ContextifyScript::EvalMachine(Local<Context> context,
@@ -977,7 +970,8 @@ bool ContextifyScript::EvalMachine(Local<Context> context,
                                    const bool break_on_sigint,
                                    const bool break_on_first_line,
                                    std::shared_ptr<MicrotaskQueue> mtask_queue,
-                                   const FunctionCallbackInfo<Value>& args) {
+                                   const FunctionCallbackInfo<Value>& args,
+                                   v8::Local<v8::Data> host_defined_options) {
   Context::Scope context_scope(context);
 
   if (!env->can_call_into_js())
@@ -1007,7 +1001,7 @@ bool ContextifyScript::EvalMachine(Local<Context> context,
   bool timed_out = false;
   bool received_signal = false;
   auto run = [&]() {
-    MaybeLocal<Value> result = script->Run(context);
+    MaybeLocal<Value> result = script->Run(context, host_defined_options);
     if (!result.IsEmpty() && mtask_queue)
       mtask_queue->PerformCheckpoint(env->isolate());
     return result;
@@ -1062,19 +1056,12 @@ bool ContextifyScript::EvalMachine(Local<Context> context,
   return true;
 }
 
-
 ContextifyScript::ContextifyScript(Environment* env, Local<Object> object)
-    : BaseObject(env, object),
-      id_(env->get_next_script_id()) {
+    : BaseObject(env, object) {
   MakeWeak();
-  env->id_to_script_map.emplace(id_, this);
-}
-
-
-ContextifyScript::~ContextifyScript() {
-  env()->id_to_script_map.erase(id_);
 }
 
+ContextifyScript::~ContextifyScript() {}
 
 void ContextifyContext::CompileFunction(
     const FunctionCallbackInfo<Value>& args) {
@@ -1144,30 +1131,22 @@ void ContextifyContext::CompileFunction(
       data + cached_data_buf->ByteOffset(), cached_data_buf->ByteLength());
   }
 
-  // Get the function id
-  uint32_t id = env->get_next_function_id();
-
-  // Set host_defined_options
-  Local<PrimitiveArray> host_defined_options =
-      PrimitiveArray::New(isolate, loader::HostDefinedOptions::kLength);
-  host_defined_options->Set(
-      isolate,
-      loader::HostDefinedOptions::kType,
-      Number::New(isolate, loader::ScriptType::kFunction));
-  host_defined_options->Set(
-      isolate, loader::HostDefinedOptions::kID, Number::New(isolate, id));
-
-  ScriptOrigin origin(isolate,
-                      filename,
-                      line_offset,       // line offset
-                      column_offset,     // column offset
-                      true,              // is cross origin
-                      -1,                // script id
-                      Local<Value>(),    // source map URL
-                      false,             // is opaque (?)
-                      false,             // is WASM
-                      false,             // is ES Module
-                      host_defined_options);
+  Local<Object> cache_key;
+  if (!env->compiled_fn_entry_template()->NewInstance(context).ToLocal(
+          &cache_key)) {
+    return;
+  }
+
+  ScriptOrigin origin(filename,
+                      line_offset,     // line offset
+                      column_offset,   // column offset
+                      true,            // is cross origin
+                      -1,              // script id
+                      Local<Value>(),  // source map URL
+                      false,           // is opaque (?)
+                      false,           // is WASM
+                      false,           // is ES Module
+                      cache_key);      // host defined options
 
   ScriptCompiler::Source source(code, origin, cached_data);
   ScriptCompiler::CompileOptions options;
@@ -1221,13 +1200,8 @@ void ContextifyContext::CompileFunction(
     return;
   }
 
-  Local<Object> cache_key;
-  if (!env->compiled_fn_entry_template()->NewInstance(
-           context).ToLocal(&cache_key)) {
-    return;
-  }
-  CompiledFnEntry* entry = new CompiledFnEntry(env, cache_key, id, fn);
-  env->id_to_function_map.emplace(id, entry);
+  // CompiledFnEntry is bound to the fn.
+  USE(new CompiledFnEntry(env, cache_key, fn));
 
   Local<Object> result = Object::New(isolate);
   if (result->Set(parsing_context, env->function_string(), fn).IsNothing())
@@ -1277,14 +1251,12 @@ void CompiledFnEntry::WeakCallback(
 
 CompiledFnEntry::CompiledFnEntry(Environment* env,
                                  Local<Object> object,
-                                 uint32_t id,
                                  Local<Function> fn)
-    : BaseObject(env, object), id_(id), fn_(env->isolate(), fn) {
+    : BaseObject(env, object), fn_(env->isolate(), fn) {
   fn_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
 }
 
 CompiledFnEntry::~CompiledFnEntry() {
-  env()->id_to_function_map.erase(id_);
   fn_.ClearWeak();
 }
 
diff --git a/src/node_contextify.h b/src/node_contextify.h
index 87440169503fbd..7da4c91c397ebb 100644
--- a/src/node_contextify.h
+++ b/src/node_contextify.h
@@ -169,13 +169,11 @@ class ContextifyScript : public BaseObject {
                           const bool break_on_sigint,
                           const bool break_on_first_line,
                           std::shared_ptr<v8::MicrotaskQueue> microtask_queue,
-                          const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  inline uint32_t id() { return id_; }
+                          const v8::FunctionCallbackInfo<v8::Value>& args,
+                          v8::Local<v8::Data> host_defined_options);
 
  private:
   v8::Global<v8::UnboundScript> script_;
-  uint32_t id_;
 };
 
 class CompiledFnEntry final : public BaseObject {
@@ -186,14 +184,12 @@ class CompiledFnEntry final : public BaseObject {
 
   CompiledFnEntry(Environment* env,
                   v8::Local<v8::Object> object,
-                  uint32_t id,
                   v8::Local<v8::Function> fn);
   ~CompiledFnEntry();
 
   bool IsNotIndicativeOfMemoryLeakAtExit() const override { return true; }
 
  private:
-  uint32_t id_;
   v8::Global<v8::Function> fn_;
 
   static void WeakCallback(const v8::WeakCallbackInfo<CompiledFnEntry>& data);
diff --git a/src/node_errors.h b/src/node_errors.h
index 706464acc87b5c..2a5bf980dea5db 100644
--- a/src/node_errors.h
+++ b/src/node_errors.h
@@ -68,6 +68,7 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
   V(ERR_INVALID_ARG_TYPE, TypeError)                                           \
   V(ERR_INVALID_OBJECT_DEFINE_PROPERTY, TypeError)                             \
   V(ERR_INVALID_MODULE, Error)                                                 \
+  V(ERR_INVALID_SCRIPT_CONTEXT, TypeError)                                     \
   V(ERR_INVALID_THIS, TypeError)                                               \
   V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                    \
   V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                       \
diff --git a/src/node_snapshotable.cc b/src/node_snapshotable.cc
index 4f56d7cca1c42a..43461c0b518767 100644
--- a/src/node_snapshotable.cc
+++ b/src/node_snapshotable.cc
@@ -1438,7 +1438,7 @@ void CompileSerializeMain(const FunctionCallbackInfo<Value>& args) {
   Local<String> source = args[1].As<String>();
   Isolate* isolate = args.GetIsolate();
   Local<Context> context = isolate->GetCurrentContext();
-  ScriptOrigin origin(isolate, filename, 0, 0, true);
+  ScriptOrigin origin(filename, 0, 0, true);
   // TODO(joyeecheung): do we need all of these? Maybe we would want a less
   // internal version of them.
   std::vector<Local<String>> parameters = {
diff --git a/test/es-module/test-esm-makejobcallback.mjs b/test/es-module/test-esm-makejobcallback.mjs
new file mode 100644
index 00000000000000..9b6dd406574a13
--- /dev/null
+++ b/test/es-module/test-esm-makejobcallback.mjs
@@ -0,0 +1,14 @@
+'use strict';
+
+// This verifies that the [[HostDefined]] is empty as defined by
+// https://tc39.es/ecma262/#sec-hostmakejobcallback.
+
+import assert from 'assert';
+
+await assert.rejects(
+  Promise.resolve(`import("../fixtures/empty.js")`).then(eval),
+  {
+    name: 'TypeError',
+    code: 'ERR_INVALID_SCRIPT_CONTEXT',
+  },
+);
diff --git a/test/parallel/test-vm-module-dynamic-import-weak-referee.js b/test/parallel/test-vm-module-dynamic-import-weak-referee.js
new file mode 100644
index 00000000000000..a7ee04cf5561f2
--- /dev/null
+++ b/test/parallel/test-vm-module-dynamic-import-weak-referee.js
@@ -0,0 +1,38 @@
+'use strict';
+
+// Flags: --experimental-vm-modules --expose-gc
+
+const common = require('../common');
+
+const assert = require('assert');
+const { Script, SourceTextModule } = require('vm');
+
+test();
+async function test() {
+  const foo = new SourceTextModule('export const a = 1;');
+  await foo.link(common.mustNotCall());
+  await foo.evaluate();
+
+  {
+    const s = new Script(`
+      globalThis.result = new Promise(resolve => {
+        setTimeout(() => {
+          gc(); // gc the vm.Script instance, causing executing 'import' in microtask a segment fault
+          resolve(import("foo"));
+        }, 1);
+      });
+    `, {
+      importModuleDynamically: common.mustCall((specifier, wrap) => {
+        assert.strictEqual(specifier, 'foo');
+        assert.strictEqual(wrap, s);
+        return foo;
+      }),
+    });
+
+    s.runInThisContext();
+    assert.ok(globalThis.result);
+  }
+  global.gc();
+  assert.strictEqual(foo.namespace, await globalThis.result);
+  delete global.result;
+}