diff --git a/deps/v8/include/v8-version.h b/deps/v8/include/v8-version.h
index e8ca1b5b46fa72..4904bcb6615a45 100644
--- a/deps/v8/include/v8-version.h
+++ b/deps/v8/include/v8-version.h
@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 12
 #define V8_MINOR_VERSION 8
 #define V8_BUILD_NUMBER 374
-#define V8_PATCH_LEVEL 22
+#define V8_PATCH_LEVEL 31
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/deps/v8/src/ast/ast-function-literal-id-reindexer.cc b/deps/v8/src/ast/ast-function-literal-id-reindexer.cc
index c0892994528850..7c5030d090c7ea 100644
--- a/deps/v8/src/ast/ast-function-literal-id-reindexer.cc
+++ b/deps/v8/src/ast/ast-function-literal-id-reindexer.cc
@@ -31,13 +31,6 @@ void AstFunctionLiteralIdReindexer::VisitFunctionLiteral(FunctionLiteral* lit) {
   lit->set_function_literal_id(lit->function_literal_id() + delta_);
 }
 
-void AstFunctionLiteralIdReindexer::VisitCall(Call* expr) {
-  AstTraversalVisitor::VisitCall(expr);
-  if (expr->is_possibly_eval()) {
-    expr->adjust_eval_scope_info_index(delta_);
-  }
-}
-
 void AstFunctionLiteralIdReindexer::VisitClassLiteral(ClassLiteral* expr) {
   // Manually visit the class literal so that we can change the property walk.
   // This should be kept in-sync with AstTraversalVisitor::VisitClassLiteral.
diff --git a/deps/v8/src/ast/ast-function-literal-id-reindexer.h b/deps/v8/src/ast/ast-function-literal-id-reindexer.h
index f7a41e0a9a5314..21eaeafd20273f 100644
--- a/deps/v8/src/ast/ast-function-literal-id-reindexer.h
+++ b/deps/v8/src/ast/ast-function-literal-id-reindexer.h
@@ -30,7 +30,6 @@ class AstFunctionLiteralIdReindexer final
   // AstTraversalVisitor implementation.
   void VisitFunctionLiteral(FunctionLiteral* lit);
   void VisitClassLiteral(ClassLiteral* lit);
-  void VisitCall(Call* lit);
 
  private:
   int delta_;
diff --git a/deps/v8/src/ast/ast.h b/deps/v8/src/ast/ast.h
index 53976fed46997b..5c1004c99a05c3 100644
--- a/deps/v8/src/ast/ast.h
+++ b/deps/v8/src/ast/ast.h
@@ -1731,7 +1731,7 @@ class CallBase : public Expression {
 class Call final : public CallBase {
  public:
   bool is_possibly_eval() const {
-    return EvalScopeInfoIndexField::decode(bit_field_) > 0;
+    return IsPossiblyEvalField::decode(bit_field_);
   }
 
   bool is_tagged_template() const {
@@ -1742,15 +1742,6 @@ class Call final : public CallBase {
     return IsOptionalChainLinkField::decode(bit_field_);
   }
 
-  uint32_t eval_scope_info_index() const {
-    return EvalScopeInfoIndexField::decode(bit_field_);
-  }
-
-  void adjust_eval_scope_info_index(int delta) {
-    bit_field_ = EvalScopeInfoIndexField::update(
-        bit_field_, eval_scope_info_index() + delta);
-  }
-
   enum CallType {
     GLOBAL_CALL,
     WITH_CALL,
@@ -1766,6 +1757,11 @@ class Call final : public CallBase {
     OTHER_CALL,
   };
 
+  enum PossiblyEval {
+    IS_POSSIBLY_EVAL,
+    NOT_EVAL,
+  };
+
   // Helpers to determine how to handle the call.
   CallType GetCallType() const;
 
@@ -1777,26 +1773,26 @@ class Call final : public CallBase {
 
   Call(Zone* zone, Expression* expression,
        const ScopedPtrList<Expression>& arguments, int pos, bool has_spread,
-       int eval_scope_info_index, bool optional_chain)
+       PossiblyEval possibly_eval, bool optional_chain)
       : CallBase(zone, kCall, expression, arguments, pos, has_spread) {
-    bit_field_ |= IsTaggedTemplateField::encode(false) |
-                  IsOptionalChainLinkField::encode(optional_chain) |
-                  EvalScopeInfoIndexField::encode(eval_scope_info_index);
-    DCHECK_EQ(eval_scope_info_index > 0, is_possibly_eval());
+    bit_field_ |=
+        IsPossiblyEvalField::encode(possibly_eval == IS_POSSIBLY_EVAL) |
+        IsTaggedTemplateField::encode(false) |
+        IsOptionalChainLinkField::encode(optional_chain);
   }
 
   Call(Zone* zone, Expression* expression,
        const ScopedPtrList<Expression>& arguments, int pos,
        TaggedTemplateTag tag)
       : CallBase(zone, kCall, expression, arguments, pos, false) {
-    bit_field_ |= IsTaggedTemplateField::encode(true) |
-                  IsOptionalChainLinkField::encode(false) |
-                  EvalScopeInfoIndexField::encode(0);
+    bit_field_ |= IsPossiblyEvalField::encode(false) |
+                  IsTaggedTemplateField::encode(true) |
+                  IsOptionalChainLinkField::encode(false);
   }
 
-  using IsTaggedTemplateField = CallBase::NextBitField<bool, 1>;
+  using IsPossiblyEvalField = CallBase::NextBitField<bool, 1>;
+  using IsTaggedTemplateField = IsPossiblyEvalField::Next<bool, 1>;
   using IsOptionalChainLinkField = IsTaggedTemplateField::Next<bool, 1>;
-  using EvalScopeInfoIndexField = IsOptionalChainLinkField::Next<uint32_t, 20>;
 };
 
 class CallNew final : public CallBase {
@@ -3188,11 +3184,12 @@ class AstNodeFactory final {
 
   Call* NewCall(Expression* expression,
                 const ScopedPtrList<Expression>& arguments, int pos,
-                bool has_spread, int eval_scope_info_index = 0,
+                bool has_spread,
+                Call::PossiblyEval possibly_eval = Call::NOT_EVAL,
                 bool optional_chain = false) {
-    DCHECK_IMPLIES(eval_scope_info_index > 0, !optional_chain);
+    DCHECK_IMPLIES(possibly_eval == Call::IS_POSSIBLY_EVAL, !optional_chain);
     return zone_->New<Call>(zone_, expression, arguments, pos, has_spread,
-                            eval_scope_info_index, optional_chain);
+                            possibly_eval, optional_chain);
   }
 
   SuperCallForwardArgs* NewSuperCallForwardArgs(SuperCallReference* expression,
diff --git a/deps/v8/src/ast/scopes.cc b/deps/v8/src/ast/scopes.cc
index e2b2405aaae8fb..109ce824b57f51 100644
--- a/deps/v8/src/ast/scopes.cc
+++ b/deps/v8/src/ast/scopes.cc
@@ -2607,23 +2607,6 @@ void ModuleScope::AllocateModuleVariables() {
   }
 }
 
-// Needs to be kept in sync with ScopeInfo::UniqueIdInScript.
-int Scope::UniqueIdInScript() const {
-  // Script scopes start "before" the script to avoid clashing with a scope that
-  // starts on character 0.
-  if (is_script_scope() || scope_type() == EVAL_SCOPE ||
-      scope_type() == MODULE_SCOPE) {
-    return -1;
-  }
-  if (is_declaration_scope()) {
-    // Default constructors have the same start position as their parent class
-    // scope. Use the next char position to distinguish this scope.
-    return start_position() +
-           IsDefaultConstructor(AsDeclarationScope()->function_kind());
-  }
-  return start_position();
-}
-
 void Scope::AllocateVariablesRecursively() {
   this->ForEach([](Scope* scope) -> Iteration {
     DCHECK(!scope->already_resolved_);
@@ -2675,63 +2658,33 @@ void Scope::AllocateVariablesRecursively() {
 }
 
 template <typename IsolateT>
-void Scope::AllocateScopeInfosRecursively(
-    IsolateT* isolate, MaybeHandle<ScopeInfo> outer_scope,
-    std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse) {
+void Scope::AllocateScopeInfosRecursively(IsolateT* isolate,
+                                          MaybeHandle<ScopeInfo> outer_scope) {
   DCHECK(scope_info_.is_null());
   MaybeHandle<ScopeInfo> next_outer_scope = outer_scope;
 
-  auto it = scope_infos_to_reuse.find(UniqueIdInScript());
-  if (it != scope_infos_to_reuse.end()) {
-    scope_info_ = it->second;
-    CHECK(NeedsContext());
-    // The ScopeInfo chain mirrors the context chain, so we only link to the
-    // next outer scope that needs a context.
-    next_outer_scope = scope_info_;
-    DCHECK(!scope_info_.is_null());
-    DCHECK(!is_hidden_catch_scope());
-    CHECK_EQ(scope_info_->scope_type(), scope_type_);
-    CHECK_EQ(scope_info_->ContextLength(), num_heap_slots_);
-#ifdef DEBUG
-    // Consume the scope info.
-    it->second = {};
-#endif
-  } else if (NeedsScopeInfo()) {
-#ifdef DEBUG
-    // Mark this ID as being used. Skip hidden scopes because they are
-    // synthetic, unreusable, but hard to make unique.
-    if (v8_flags.reuse_scope_infos && !is_hidden_catch_scope()) {
-      scope_infos_to_reuse[UniqueIdInScript()] = {};
-    }
-#endif
+  if (NeedsScopeInfo()) {
     scope_info_ = ScopeInfo::Create(isolate, zone(), this, outer_scope);
-    DCHECK_EQ(UniqueIdInScript(), scope_info_->UniqueIdInScript());
-    // The ScopeInfo chain mirrors the context chain, so we only link to the
-    // next outer scope that needs a context.
+    // The ScopeInfo chain should mirror the context chain, so we only link to
+    // the next outer scope that needs a context.
     if (NeedsContext()) next_outer_scope = scope_info_;
   }
 
   // Allocate ScopeInfos for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
-    DCHECK_GT(scope->UniqueIdInScript(), UniqueIdInScript());
-    DCHECK_IMPLIES(scope->sibling_, scope->sibling_->UniqueIdInScript() !=
-                                        scope->UniqueIdInScript());
     if (!scope->is_function_scope() ||
         scope->AsDeclarationScope()->ShouldEagerCompile()) {
-      scope->AllocateScopeInfosRecursively(isolate, next_outer_scope,
-                                           scope_infos_to_reuse);
+      scope->AllocateScopeInfosRecursively(isolate, next_outer_scope);
     }
   }
 }
 
 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
-    AllocateScopeInfosRecursively<Isolate>(
-        Isolate* isolate, MaybeHandle<ScopeInfo> outer_scope,
-        std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse);
+    AllocateScopeInfosRecursively<Isolate>(Isolate* isolate,
+                                           MaybeHandle<ScopeInfo> outer_scope);
 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
     AllocateScopeInfosRecursively<LocalIsolate>(
-        LocalIsolate* isolate, MaybeHandle<ScopeInfo> outer_scope,
-        std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse);
+        LocalIsolate* isolate, MaybeHandle<ScopeInfo> outer_scope);
 
 void DeclarationScope::RecalcPrivateNameContextChain() {
   // The outermost scope in a class heritage expression is marked to skip the
@@ -2776,9 +2729,7 @@ void DeclarationScope::RecordNeedsPrivateNameContextChainRecalc() {
 
 // static
 template <typename IsolateT>
-void DeclarationScope::AllocateScopeInfos(ParseInfo* info,
-                                          Handle<Script> script,
-                                          IsolateT* isolate) {
+void DeclarationScope::AllocateScopeInfos(ParseInfo* info, IsolateT* isolate) {
   DeclarationScope* scope = info->literal()->scope();
 
   // No one else should have allocated a scope info for this scope yet.
@@ -2793,49 +2744,7 @@ void DeclarationScope::AllocateScopeInfos(ParseInfo* info,
   if (scope->needs_private_name_context_chain_recalc()) {
     scope->RecalcPrivateNameContextChain();
   }
-
-  Tagged<WeakFixedArray> infos = script->infos();
-  std::unordered_map<int, Handle<ScopeInfo>> scope_infos_to_reuse;
-  if (v8_flags.reuse_scope_infos && infos->length() != 0) {
-    Tagged<SharedFunctionInfo> sfi = *info->literal()->shared_function_info();
-    Tagged<ScopeInfo> outer = sfi->HasOuterScopeInfo()
-                                  ? sfi->GetOuterScopeInfo()
-                                  : Tagged<ScopeInfo>();
-    // Look at all the existing inner functions (they are numbered id+1 until
-    // max_id+1) to reattach their outer scope infos to corresponding scopes.
-    for (int i = info->literal()->function_literal_id() + 1;
-         i < info->max_info_id() + 1; ++i) {
-      Tagged<MaybeObject> maybe_info = infos->get(i);
-      if (maybe_info.IsWeak()) {
-        Tagged<Object> info = maybe_info.GetHeapObjectAssumeWeak();
-        Tagged<ScopeInfo> scope_info;
-        if (Is<SharedFunctionInfo>(info)) {
-          Tagged<SharedFunctionInfo> sfi = Cast<SharedFunctionInfo>(info);
-          // Reuse outer scope infos. Don't look at sfi->scope_info() because
-          // that might be empty if the sfi isn't compiled yet.
-          if (!sfi->HasOuterScopeInfo()) continue;
-          scope_info = sfi->GetOuterScopeInfo();
-        } else {
-          scope_info = Cast<ScopeInfo>(info);
-        }
-        while (true) {
-          if (scope_info == outer) break;
-          int id = scope_info->UniqueIdInScript();
-          auto it = scope_infos_to_reuse.find(id);
-          if (it != scope_infos_to_reuse.end()) {
-            CHECK_EQ(*it->second, scope_info);
-            break;
-          }
-          scope_infos_to_reuse[id] = handle(scope_info, isolate);
-          if (!scope_info->HasOuterScopeInfo()) break;
-          scope_info = scope_info->OuterScopeInfo();
-        }
-      }
-    }
-  }
-
-  scope->AllocateScopeInfosRecursively(isolate, outer_scope,
-                                       scope_infos_to_reuse);
+  scope->AllocateScopeInfosRecursively(isolate, outer_scope);
 
   // The debugger expects all shared function infos to contain a scope info.
   // Since the top-most scope will end up in a shared function info, make sure
@@ -2854,9 +2763,9 @@ void DeclarationScope::AllocateScopeInfos(ParseInfo* info,
 }
 
 template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
-    ParseInfo* info, Handle<Script> script, Isolate* isolate);
+    ParseInfo* info, Isolate* isolate);
 template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
-    ParseInfo* info, Handle<Script> script, LocalIsolate* isolate);
+    ParseInfo* info, LocalIsolate* isolate);
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
diff --git a/deps/v8/src/ast/scopes.h b/deps/v8/src/ast/scopes.h
index a59c13d039337c..421da0d20241eb 100644
--- a/deps/v8/src/ast/scopes.h
+++ b/deps/v8/src/ast/scopes.h
@@ -101,11 +101,6 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
   }
 #endif
 
-  // An ID that uniquely identifies this scope within the script. Inner scopes
-  // have a higher ID than their outer scopes. ScopeInfo created from a scope
-  // has the same ID as the scope.
-  int UniqueIdInScript() const;
-
   DeclarationScope* AsDeclarationScope();
   const DeclarationScope* AsDeclarationScope() const;
   ModuleScope* AsModuleScope();
@@ -339,10 +334,6 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
   bool is_hidden() const { return is_hidden_; }
   void set_is_hidden() { is_hidden_ = true; }
 
-  bool is_hidden_catch_scope() const {
-    return is_hidden() && scope_type() == CATCH_SCOPE;
-  }
-
   void ForceContextAllocationForParameters() {
     DCHECK(!already_resolved_);
     force_context_allocation_for_parameters_ = true;
@@ -728,9 +719,11 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
   void AllocateVariablesRecursively();
 
   template <typename IsolateT>
-  void AllocateScopeInfosRecursively(
-      IsolateT* isolate, MaybeHandle<ScopeInfo> outer_scope,
-      std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse);
+  void AllocateScopeInfosRecursively(IsolateT* isolate,
+                                     MaybeHandle<ScopeInfo> outer_scope);
+
+  void AllocateDebuggerScopeInfos(Isolate* isolate,
+                                  MaybeHandle<ScopeInfo> outer_scope);
 
   // Construct a scope based on the scope info.
   Scope(Zone* zone, ScopeType type, AstValueFactory* ast_value_factory,
@@ -830,6 +823,10 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
 
   bool must_use_preparsed_scope_data_ : 1;
 
+  // True if this is a script scope that originated from
+  // DebugEvaluate::GlobalREPL().
+  bool is_repl_mode_scope_ : 1;
+
   // True if this is a deserialized scope which caches its lookups on another
   // Scope's variable map. This will be true for every scope above the first
   // non-eval declaration scope above the compilation entry point, e.g. for
@@ -1164,7 +1161,6 @@ class V8_EXPORT_PRIVATE DeclarationScope : public Scope {
   // Does nothing if ScopeInfo is already allocated.
   template <typename IsolateT>
   V8_EXPORT_PRIVATE static void AllocateScopeInfos(ParseInfo* info,
-                                                   Handle<Script> script,
                                                    IsolateT* isolate);
 
   // Determine if we can use lazy compilation for this scope.
diff --git a/deps/v8/src/builtins/builtins-function.cc b/deps/v8/src/builtins/builtins-function.cc
index 1b1a4f1a9420d4..1dcf9ad3716ad1 100644
--- a/deps/v8/src/builtins/builtins-function.cc
+++ b/deps/v8/src/builtins/builtins-function.cc
@@ -84,10 +84,11 @@ MaybeHandle<Object> CreateDynamicFunction(Isolate* isolate,
   // come from here.
   Handle<JSFunction> function;
   {
-    ASSIGN_RETURN_ON_EXCEPTION(isolate, function,
-                               Compiler::GetFunctionFromString(
-                                   handle(target->native_context(), isolate),
-                                   source, parameters_end_pos, is_code_like));
+    ASSIGN_RETURN_ON_EXCEPTION(
+        isolate, function,
+        Compiler::GetFunctionFromString(
+            handle(target->native_context(), isolate), source,
+            ONLY_SINGLE_FUNCTION_LITERAL, parameters_end_pos, is_code_like));
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate, result,
diff --git a/deps/v8/src/codegen/background-merge-task.h b/deps/v8/src/codegen/background-merge-task.h
index 533fbcc3e92804..97e034d61e0c04 100644
--- a/deps/v8/src/codegen/background-merge-task.h
+++ b/deps/v8/src/codegen/background-merge-task.h
@@ -73,7 +73,7 @@ class V8_EXPORT_PRIVATE BackgroundMergeTask {
   // SharedFunctionInfo in the cached script. The main thread must:
   // 1. Check whether the cached script gained corresponding SharedFunctionInfos
   //    for any of these, and if so, redo the merge.
-  // 2. Update the cached script's infos list to refer to these.
+  // 2. Update the cached script's shared_function_infos list to refer to these.
   std::vector<Handle<SharedFunctionInfo>> used_new_sfis_;
 
   // SharedFunctionInfos from the cached script which were not compiled, with
diff --git a/deps/v8/src/codegen/compiler.cc b/deps/v8/src/codegen/compiler.cc
index 0a95368d3b904e..9f038a88a3a938 100644
--- a/deps/v8/src/codegen/compiler.cc
+++ b/deps/v8/src/codegen/compiler.cc
@@ -753,16 +753,20 @@ void InstallUnoptimizedCode(UnoptimizedCompilationInfo* compilation_info,
 }
 
 template <typename IsolateT>
-void EnsureInfosArrayOnScript(DirectHandle<Script> script,
-                              ParseInfo* parse_info, IsolateT* isolate) {
+void EnsureSharedFunctionInfosArrayOnScript(DirectHandle<Script> script,
+                                            ParseInfo* parse_info,
+                                            IsolateT* isolate) {
   DCHECK(parse_info->flags().is_toplevel());
-  if (script->infos()->length() > 0) {
-    DCHECK_EQ(script->infos()->length(), parse_info->max_info_id() + 1);
+  if (script->shared_function_info_count() > 0) {
+    DCHECK_LE(script->shared_function_info_count(),
+              script->shared_function_infos()->length());
+    DCHECK_EQ(script->shared_function_info_count(),
+              parse_info->max_function_literal_id() + 1);
     return;
   }
   DirectHandle<WeakFixedArray> infos(isolate->factory()->NewWeakFixedArray(
-      parse_info->max_info_id() + 1, AllocationType::kOld));
-  script->set_infos(*infos);
+      parse_info->max_function_literal_id() + 1, AllocationType::kOld));
+  script->set_shared_function_infos(*infos);
 }
 
 void UpdateSharedFunctionFlagsAfterCompilation(FunctionLiteral* literal) {
@@ -861,7 +865,7 @@ bool IterativelyExecuteAndFinalizeUnoptimizedCompilationJobs(
         finalize_unoptimized_compilation_data_list,
     DeferredFinalizationJobDataList*
         jobs_to_retry_finalization_on_main_thread) {
-  DeclarationScope::AllocateScopeInfos(parse_info, script, isolate);
+  DeclarationScope::AllocateScopeInfos(parse_info, isolate);
 
   std::vector<FunctionLiteral*> functions_to_compile;
   functions_to_compile.push_back(parse_info->literal());
@@ -1524,7 +1528,7 @@ void CompileAllWithBaseline(Isolate* isolate,
 template <typename IsolateT>
 Handle<SharedFunctionInfo> CreateTopLevelSharedFunctionInfo(
     ParseInfo* parse_info, Handle<Script> script, IsolateT* isolate) {
-  EnsureInfosArrayOnScript(script, parse_info, isolate);
+  EnsureSharedFunctionInfosArrayOnScript(script, parse_info, isolate);
   DCHECK_EQ(kNoSourcePosition,
             parse_info->literal()->function_token_position());
   return isolate->factory()->NewSharedFunctionInfoForLiteral(
@@ -1534,7 +1538,7 @@ Handle<SharedFunctionInfo> CreateTopLevelSharedFunctionInfo(
 Handle<SharedFunctionInfo> GetOrCreateTopLevelSharedFunctionInfo(
     ParseInfo* parse_info, Handle<Script> script, Isolate* isolate,
     IsCompiledScope* is_compiled_scope) {
-  EnsureInfosArrayOnScript(script, parse_info, isolate);
+  EnsureSharedFunctionInfosArrayOnScript(script, parse_info, isolate);
   MaybeHandle<SharedFunctionInfo> maybe_shared =
       Script::FindSharedFunctionInfo(script, isolate, parse_info->literal());
   if (Handle<SharedFunctionInfo> shared; maybe_shared.ToHandle(&shared)) {
@@ -1746,10 +1750,9 @@ namespace {
 #ifdef ENABLE_SLOW_DCHECKS
 
 // A class which traverses the object graph for a newly compiled Script and
-// ensures that it contains pointers to Scripts, ScopeInfos and
-// SharedFunctionInfos only at the expected locations. Any failure in this
-// visitor indicates a case that is probably not handled correctly in
-// BackgroundMergeTask.
+// ensures that it contains pointers to Scripts and SharedFunctionInfos only at
+// the expected locations. Any failure in this visitor indicates a case that is
+// probably not handled correctly in BackgroundMergeTask.
 class MergeAssumptionChecker final : public ObjectVisitor {
  public:
   explicit MergeAssumptionChecker(PtrComprCageBase cage_base)
@@ -1761,14 +1764,15 @@ class MergeAssumptionChecker final : public ObjectVisitor {
       std::pair<Tagged<HeapObject>, ObjectKind> pair = to_visit_.top();
       to_visit_.pop();
       Tagged<HeapObject> current = pair.first;
-      // The Script's infos list and the constant pools for all
+      // The Script's shared_function_infos list and the constant pools for all
       // BytecodeArrays are expected to contain pointers to SharedFunctionInfos.
       // However, the type of those objects (FixedArray or WeakFixedArray)
       // doesn't have enough information to indicate their usage, so we enqueue
       // those objects here rather than during VisitPointers.
       if (IsScript(current)) {
-        Tagged<HeapObject> infos = Cast<Script>(current)->infos();
-        QueueVisit(infos, kScriptInfosList);
+        Tagged<HeapObject> sfis =
+            Cast<Script>(current)->shared_function_infos();
+        QueueVisit(sfis, kScriptSfiList);
       } else if (IsBytecodeArray(current)) {
         Tagged<HeapObject> constants =
             Cast<BytecodeArray>(current)->constant_pool();
@@ -1796,11 +1800,7 @@ class MergeAssumptionChecker final : public ObjectVisitor {
       if (maybe_obj.GetHeapObject(&obj)) {
         if (IsSharedFunctionInfo(obj)) {
           CHECK((current_object_kind_ == kConstantPool && !is_weak) ||
-                (current_object_kind_ == kScriptInfosList && is_weak));
-        } else if (IsScopeInfo(obj)) {
-          CHECK((current_object_kind_ == kConstantPool && !is_weak) ||
-                (current_object_kind_ == kNormalObject && !is_weak) ||
-                (current_object_kind_ == kScriptInfosList && is_weak));
+                (current_object_kind_ == kScriptSfiList && is_weak));
         } else if (IsScript(obj)) {
           CHECK(IsSharedFunctionInfo(host) &&
                 current == MaybeObjectSlot(host.address() +
@@ -1836,7 +1836,7 @@ class MergeAssumptionChecker final : public ObjectVisitor {
   enum ObjectKind {
     kNormalObject,
     kConstantPool,
-    kScriptInfosList,
+    kScriptSfiList,
   };
 
   // If the object hasn't yet been added to the worklist, add it. Subsequent
@@ -2010,79 +2010,32 @@ void BackgroundCompileTask::Run(
 class ConstantPoolPointerForwarder {
  public:
   explicit ConstantPoolPointerForwarder(PtrComprCageBase cage_base,
-                                        LocalHeap* local_heap,
-                                        DirectHandle<Script> old_script)
-      : cage_base_(cage_base),
-        local_heap_(local_heap),
-        old_script_(old_script) {}
+                                        LocalHeap* local_heap)
+      : cage_base_(cage_base), local_heap_(local_heap) {}
 
   void AddBytecodeArray(Tagged<BytecodeArray> bytecode_array) {
     CHECK(IsBytecodeArray(bytecode_array));
-    bytecode_arrays_to_update_.emplace_back(bytecode_array, local_heap_);
+    bytecode_arrays_to_update_.push_back(handle(bytecode_array, local_heap_));
   }
 
-  void RecordScopeInfos(Tagged<MaybeObject> maybe_old_info) {
-    Tagged<ScopeInfo> scope_info;
-    Tagged<HeapObject> info = maybe_old_info.GetHeapObjectAssumeWeak();
-    if (Is<SharedFunctionInfo>(info)) {
-      Tagged<SharedFunctionInfo> old_sfi = Cast<SharedFunctionInfo>(info);
-      if (!old_sfi->HasOuterScopeInfo()) return;
-      scope_info = old_sfi->GetOuterScopeInfo();
-    } else {
-      scope_info = Cast<ScopeInfo>(info);
-    }
-    while (true) {
-      if (scope_infos_to_update_.find(scope_info->UniqueIdInScript()) !=
-          scope_infos_to_update_.end()) {
-        return;
-      }
-      scope_infos_to_update_[scope_info->UniqueIdInScript()] =
-          handle(scope_info, local_heap_);
-      if (!scope_info->HasOuterScopeInfo()) break;
-      scope_info = scope_info->OuterScopeInfo();
-    }
+  void Forward(Tagged<SharedFunctionInfo> from, Tagged<SharedFunctionInfo> to) {
+    forwarding_table_[from->function_literal_id()] = handle(to, local_heap_);
   }
 
   // Runs the update after the setup functions above specified the work to do.
   void IterateAndForwardPointers() {
     DCHECK(HasAnythingToForward());
-    for (Handle<BytecodeArray> entry : bytecode_arrays_to_update_) {
+    for (DirectHandle<BytecodeArray> bytecode_array :
+         bytecode_arrays_to_update_) {
       local_heap_->Safepoint();
       DisallowGarbageCollection no_gc;
-      IterateConstantPool(entry->constant_pool());
+      IterateConstantPool(bytecode_array->constant_pool());
     }
   }
 
-  void set_has_shared_function_info_to_forward() {
-    has_shared_function_info_to_forward_ = true;
-  }
-
-  bool HasAnythingToForward() const {
-    return has_shared_function_info_to_forward_ ||
-           !scope_infos_to_update_.empty();
-  }
-
-  void UpdateOuterScopeInfo(Tagged<SharedFunctionInfo> sfi) {
-    if (!sfi->HasOuterScopeInfo()) return;
-    Tagged<ScopeInfo> outer_info = sfi->GetOuterScopeInfo();
-    auto it = scope_infos_to_update_.find(outer_info->UniqueIdInScript());
-    if (it == scope_infos_to_update_.end()) return;
-    if (outer_info == *it->second) return;
-    VerifyScopeInfo(outer_info, *it->second);
-    if (sfi->is_compiled()) {
-      sfi->scope_info()->set_outer_scope_info(*it->second);
-    } else {
-      sfi->set_raw_outer_scope_info_or_feedback_metadata(*it->second);
-    }
-  }
+  bool HasAnythingToForward() const { return !forwarding_table_.empty(); }
 
  private:
-  void VerifyScopeInfo(Tagged<ScopeInfo> scope_info,
-                       Tagged<ScopeInfo> replacement) {
-    CHECK_EQ(replacement->EndPosition(), scope_info->EndPosition());
-    CHECK_EQ(replacement->scope_type(), scope_info->scope_type());
-    CHECK_EQ(replacement->ContextLength(), scope_info->ContextLength());
-  }
   template <typename TArray>
   void IterateConstantPoolEntry(Tagged<TArray> constant_pool, int i) {
     Tagged<Object> obj = constant_pool->get(i);
@@ -2093,48 +2046,12 @@ class ConstantPoolPointerForwarder {
       // are acyclic and never more than a few layers deep, so recursion is
       // fine here.
       IterateConstantPoolNestedArray(Cast<FixedArray>(heap_obj));
-    } else if (has_shared_function_info_to_forward_ &&
-               IsSharedFunctionInfo(heap_obj, cage_base_)) {
-      VisitSharedFunctionInfo(constant_pool, i,
-                              Cast<SharedFunctionInfo>(heap_obj));
-    } else if (!scope_infos_to_update_.empty() &&
-               IsScopeInfo(heap_obj, cage_base_)) {
-      VisitScopeInfo(constant_pool, i, Cast<ScopeInfo>(heap_obj));
-    }
-  }
-
-  template <typename TArray>
-  void VisitSharedFunctionInfo(Tagged<TArray> constant_pool, int i,
-                               Tagged<SharedFunctionInfo> sfi) {
-    Tagged<MaybeObject> maybe_old_sfi =
-        old_script_->infos()->get(sfi->function_literal_id());
-    if (maybe_old_sfi.IsWeak()) {
-      constant_pool->set(
-          i, Cast<SharedFunctionInfo>(maybe_old_sfi.GetHeapObjectAssumeWeak()));
-    }
-  }
-
-  template <typename TArray>
-  void VisitScopeInfo(Tagged<TArray> constant_pool, int i,
-                      Tagged<ScopeInfo> scope_info) {
-    auto it = scope_infos_to_update_.find(scope_info->UniqueIdInScript());
-    // Try to replace the scope info itself with an already existing version.
-    if (it != scope_infos_to_update_.end()) {
-      if (scope_info != *it->second) {
-        VerifyScopeInfo(scope_info, *it->second);
+    } else if (IsSharedFunctionInfo(heap_obj, cage_base_)) {
+      auto it = forwarding_table_.find(
+          Cast<SharedFunctionInfo>(heap_obj)->function_literal_id());
+      if (it != forwarding_table_.end()) {
         constant_pool->set(i, *it->second);
       }
-    } else if (scope_info->HasOuterScopeInfo()) {
-      // If we didn't find a match, but we have an outer scope info, try to
-      // replace the outer scope info with an already existing outer scope
-      // info. We only need to look at the direct outer scope info since we'll
-      // process all scope infos that are created by this compilation task.
-      Tagged<ScopeInfo> outer = scope_info->OuterScopeInfo();
-      it = scope_infos_to_update_.find(outer->UniqueIdInScript());
-      if (it != scope_infos_to_update_.end() && outer != *it->second) {
-        VerifyScopeInfo(outer, *it->second);
-        scope_info->set_outer_scope_info(*it->second);
-      }
     }
   }
 
@@ -2152,12 +2069,12 @@ class ConstantPoolPointerForwarder {
 
   PtrComprCageBase cage_base_;
   LocalHeap* local_heap_;
-  DirectHandle<Script> old_script_;
   std::vector<Handle<BytecodeArray>> bytecode_arrays_to_update_;
 
-  // Indicates whether we have any shared function info to forward.
-  bool has_shared_function_info_to_forward_ = false;
-  std::unordered_map<int, Handle<ScopeInfo>> scope_infos_to_update_;
+  // If any SharedFunctionInfo is found in constant pools with a function
+  // literal ID matching one of these keys, then that entry should be updated
+  // to point to the corresponding value.
+  std::unordered_map<int, Handle<SharedFunctionInfo>> forwarding_table_;
 };
 
 void BackgroundMergeTask::SetUpOnMainThread(Isolate* isolate,
@@ -2206,13 +2123,14 @@ void BackgroundMergeTask::BeginMergeInBackground(
   LocalHeap* local_heap = isolate->heap();
   local_heap->AttachPersistentHandles(std::move(persistent_handles_));
   LocalHandleScope handle_scope(local_heap);
+  ConstantPoolPointerForwarder forwarder(isolate, local_heap);
+
   DirectHandle<Script> old_script = cached_script_.ToHandleChecked();
-  ConstantPoolPointerForwarder forwarder(isolate, local_heap, old_script);
 
   {
     DisallowGarbageCollection no_gc;
     Tagged<MaybeObject> maybe_old_toplevel_sfi =
-        old_script->infos()->get(kFunctionLiteralIdTopLevel);
+        old_script->shared_function_infos()->get(kFunctionLiteralIdTopLevel);
     if (maybe_old_toplevel_sfi.IsWeak()) {
       Tagged<SharedFunctionInfo> old_toplevel_sfi = Cast<SharedFunctionInfo>(
           maybe_old_toplevel_sfi.GetHeapObjectAssumeWeak());
@@ -2223,42 +2141,42 @@ void BackgroundMergeTask::BeginMergeInBackground(
 
   // Iterate the SFI lists on both Scripts to set up the forwarding table and
   // follow-up worklists for the main thread.
-  CHECK_EQ(old_script->infos()->length(), new_script->infos()->length());
-  for (int i = 0; i < old_script->infos()->length(); ++i) {
+  CHECK_EQ(old_script->shared_function_infos()->length(),
+           new_script->shared_function_infos()->length());
+  for (int i = 0; i < old_script->shared_function_infos()->length(); ++i) {
     DisallowGarbageCollection no_gc;
-    Tagged<MaybeObject> maybe_new_sfi = new_script->infos()->get(i);
-    Tagged<MaybeObject> maybe_old_info = old_script->infos()->get(i);
-    // We might have scope infos in the table if it's deserialized from a code
-    // cache.
-    if (maybe_new_sfi.IsWeak() &&
-        Is<SharedFunctionInfo>(maybe_new_sfi.GetHeapObjectAssumeWeak())) {
+    Tagged<MaybeObject> maybe_new_sfi =
+        new_script->shared_function_infos()->get(i);
+    if (maybe_new_sfi.IsWeak()) {
       Tagged<SharedFunctionInfo> new_sfi =
           Cast<SharedFunctionInfo>(maybe_new_sfi.GetHeapObjectAssumeWeak());
-      if (maybe_old_info.IsWeak()) {
-        forwarder.set_has_shared_function_info_to_forward();
+      Tagged<MaybeObject> maybe_old_sfi =
+          old_script->shared_function_infos()->get(i);
+      if (maybe_old_sfi.IsWeak()) {
         // The old script and the new script both have SharedFunctionInfos for
         // this function literal.
         Tagged<SharedFunctionInfo> old_sfi =
-            Cast<SharedFunctionInfo>(maybe_old_info.GetHeapObjectAssumeWeak());
-        if (old_sfi->HasBytecodeArray()) {
-          // Reset the old SFI's bytecode age so that it won't likely get
-          // flushed right away. This operation might be racing against
-          // concurrent modification by another thread, but such a race is not
-          // catastrophic.
-          old_sfi->set_age(0);
-          // Make sure we'll keep the old sfi alive so it'll be installed in the
-          // new bytecode by the forwarder.
-          local_heap->NewPersistentHandle(old_sfi);
-        } else if (new_sfi->HasBytecodeArray()) {
-          // Also push the old_sfi to make sure it stays alive / isn't replaced.
-          new_compiled_data_for_cached_sfis_.push_back(
-              {local_heap->NewPersistentHandle(old_sfi),
-               local_heap->NewPersistentHandle(new_sfi)});
-          forwarder.AddBytecodeArray(new_sfi->GetBytecodeArray(isolate));
+            Cast<SharedFunctionInfo>(maybe_old_sfi.GetHeapObjectAssumeWeak());
+        forwarder.Forward(new_sfi, old_sfi);
+        if (new_sfi->HasBytecodeArray()) {
+          if (old_sfi->HasBytecodeArray()) {
+            // Reset the old SFI's bytecode age so that it won't likely get
+            // flushed right away. This operation might be racing against
+            // concurrent modification by another thread, but such a race is not
+            // catastrophic.
+            old_sfi->set_age(0);
+          } else {
+            // The old SFI can use the compiled data from the new SFI.
+            new_compiled_data_for_cached_sfis_.push_back(
+                {local_heap->NewPersistentHandle(old_sfi),
+                 local_heap->NewPersistentHandle(new_sfi)});
+            forwarder.AddBytecodeArray(new_sfi->GetBytecodeArray(isolate));
+          }
         }
       } else {
         // The old script didn't have a SharedFunctionInfo for this function
         // literal, so it can use the new SharedFunctionInfo.
+        DCHECK_EQ(i, new_sfi->function_literal_id());
         new_sfi->set_script(*old_script, kReleaseStore);
         used_new_sfis_.push_back(local_heap->NewPersistentHandle(new_sfi));
         if (new_sfi->HasBytecodeArray()) {
@@ -2266,33 +2184,26 @@ void BackgroundMergeTask::BeginMergeInBackground(
         }
       }
     }
-
-    if (maybe_old_info.IsWeak()) {
-      forwarder.RecordScopeInfos(maybe_old_info);
-      // If the old script has a SFI, point to it from the new script to
-      // indicate we've already seen it and we'll reuse it if necessary (if
-      // newly compiled bytecode points to it).
-      new_script->infos()->set(i, maybe_old_info);
-    }
   }
 
+  persistent_handles_ = local_heap->DetachPersistentHandles();
+
   if (forwarder.HasAnythingToForward()) {
-    for (DirectHandle<SharedFunctionInfo> new_sfi : used_new_sfis_) {
-      forwarder.UpdateOuterScopeInfo(*new_sfi);
-    }
     forwarder.IterateAndForwardPointers();
   }
-  persistent_handles_ = local_heap->DetachPersistentHandles();
+
   state_ = kPendingForegroundWork;
 }
+
 Handle<SharedFunctionInfo> BackgroundMergeTask::CompleteMergeInForeground(
     Isolate* isolate, DirectHandle<Script> new_script) {
   DCHECK_EQ(state_, kPendingForegroundWork);
 
   HandleScope handle_scope(isolate);
+  ConstantPoolPointerForwarder forwarder(isolate,
+                                         isolate->main_thread_local_heap());
+
   DirectHandle<Script> old_script = cached_script_.ToHandleChecked();
-  ConstantPoolPointerForwarder forwarder(
-      isolate, isolate->main_thread_local_heap(), old_script);
 
   for (const auto& new_compiled_data : new_compiled_data_for_cached_sfis_) {
     if (!new_compiled_data.cached_sfi->is_compiled() &&
@@ -2310,24 +2221,22 @@ Handle<SharedFunctionInfo> BackgroundMergeTask::CompleteMergeInForeground(
                                              isolate);
     }
   }
-
-  for (int i = 0; i < old_script->infos()->length(); ++i) {
-    Tagged<MaybeObject> maybe_old_info = old_script->infos()->get(i);
-    Tagged<MaybeObject> maybe_new_info = new_script->infos()->get(i);
-    if (maybe_new_info == maybe_old_info) continue;
+  for (DirectHandle<SharedFunctionInfo> new_sfi : used_new_sfis_) {
     DisallowGarbageCollection no_gc;
-    if (maybe_old_info.IsWeak()) {
-      // The old script's SFI didn't exist during the background work, but does
-      // now. This means a re-merge is necessary. Potential references to the
-      // new script's SFI need to be updated to point to the cached script's SFI
-      // instead. The cached script's SFI's outer scope infos need to be used by
-      // the new script's outer SFIs.
-      if (Is<SharedFunctionInfo>(maybe_old_info.GetHeapObjectAssumeWeak())) {
-        forwarder.set_has_shared_function_info_to_forward();
-      }
-      forwarder.RecordScopeInfos(maybe_old_info);
+    DCHECK_GE(new_sfi->function_literal_id(), 0);
+    Tagged<MaybeObject> maybe_old_sfi =
+        old_script->shared_function_infos()->get(
+            new_sfi->function_literal_id());
+    if (maybe_old_sfi.IsWeak()) {
+      // The old script's SFI didn't exist during the background work, but
+      // does now. This means a re-merge is necessary so that any pointers to
+      // the new script's SFI are updated to point to the old script's SFI.
+      Tagged<SharedFunctionInfo> old_sfi =
+          Cast<SharedFunctionInfo>(maybe_old_sfi.GetHeapObjectAssumeWeak());
+      forwarder.Forward(*new_sfi, old_sfi);
     } else {
-      old_script->infos()->set(i, maybe_new_info);
+      old_script->shared_function_infos()->set(new_sfi->function_literal_id(),
+                                               MakeWeak(*new_sfi));
     }
   }
 
@@ -2336,7 +2245,6 @@ Handle<SharedFunctionInfo> BackgroundMergeTask::CompleteMergeInForeground(
   // pools is required.
   if (forwarder.HasAnythingToForward()) {
     for (DirectHandle<SharedFunctionInfo> new_sfi : used_new_sfis_) {
-      forwarder.UpdateOuterScopeInfo(*new_sfi);
       if (new_sfi->HasBytecodeArray(isolate)) {
         forwarder.AddBytecodeArray(new_sfi->GetBytecodeArray(isolate));
       }
@@ -2351,7 +2259,7 @@ Handle<SharedFunctionInfo> BackgroundMergeTask::CompleteMergeInForeground(
   }
 
   Tagged<MaybeObject> maybe_toplevel_sfi =
-      old_script->infos()->get(kFunctionLiteralIdTopLevel);
+      old_script->shared_function_infos()->get(kFunctionLiteralIdTopLevel);
   CHECK(maybe_toplevel_sfi.IsWeak());
   Handle<SharedFunctionInfo> result = handle(
       Cast<SharedFunctionInfo>(maybe_toplevel_sfi.GetHeapObjectAssumeWeak()),
@@ -2976,7 +2884,8 @@ MaybeHandle<SharedFunctionInfo> Compiler::CompileForLiveEdit(
 MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
     Handle<String> source, Handle<SharedFunctionInfo> outer_info,
     Handle<Context> context, LanguageMode language_mode,
-    ParseRestriction restriction, int parameters_end_pos, int eval_position,
+    ParseRestriction restriction, int parameters_end_pos,
+    int eval_scope_position, int eval_position,
     ParsingWhileDebugging parsing_while_debugging) {
   Isolate* isolate = context->GetIsolate();
 
@@ -2985,20 +2894,19 @@ MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
   //   Function("", "function anonymous(\n/**/) {\n}");
   // from adding an entry that falsely approves this invalid invocation:
   //   Function("\n/**/) {\nfunction anonymous(", "}");
-  // The actual eval_position for indirect eval and CreateDynamicFunction
+  // The actual eval_scope_position for indirect eval and CreateDynamicFunction
   // is unused (just 0), which means it's an available field to use to indicate
   // this separation. But to make sure we're not causing other false hits, we
   // negate the scope position.
-  int eval_cache_position = eval_position;
   if (restriction == ONLY_SINGLE_FUNCTION_LITERAL &&
       parameters_end_pos != kNoSourcePosition) {
-    // use the parameters_end_pos as the eval_position in the eval cache.
-    DCHECK_EQ(eval_position, kNoSourcePosition);
-    eval_cache_position = -parameters_end_pos;
+    // use the parameters_end_pos as the eval_scope_position in the eval cache.
+    DCHECK_EQ(eval_scope_position, 0);
+    eval_scope_position = -parameters_end_pos;
   }
   CompilationCache* compilation_cache = isolate->compilation_cache();
   InfoCellPair eval_result = compilation_cache->LookupEval(
-      source, outer_info, context, language_mode, eval_cache_position);
+      source, outer_info, context, language_mode, eval_scope_position);
   Handle<FeedbackCell> feedback_cell;
   if (eval_result.has_feedback_cell()) {
     feedback_cell = handle(eval_result.feedback_cell(), isolate);
@@ -3084,7 +2992,7 @@ MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
         Handle<FeedbackCell> new_feedback_cell(result->raw_feedback_cell(),
                                                isolate);
         compilation_cache->PutEval(source, outer_info, context, shared_info,
-                                   new_feedback_cell, eval_cache_position);
+                                   new_feedback_cell, eval_scope_position);
       }
     }
   } else {
@@ -3100,7 +3008,7 @@ MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
       Handle<FeedbackCell> new_feedback_cell(result->raw_feedback_cell(),
                                              isolate);
       compilation_cache->PutEval(source, outer_info, context, shared_info,
-                                 new_feedback_cell, eval_cache_position);
+                                 new_feedback_cell, eval_scope_position);
     }
   }
   DCHECK(is_compiled_scope.is_compiled());
@@ -3239,24 +3147,25 @@ MaybeHandle<JSFunction> Compiler::GetFunctionFromValidatedString(
   }
 
   // Compile source string in the native context.
+  int eval_scope_position = 0;
   int eval_position = kNoSourcePosition;
   Handle<SharedFunctionInfo> outer_info(
       native_context->empty_function()->shared(), isolate);
-  return Compiler::GetFunctionFromEval(
-      source.ToHandleChecked(), outer_info, native_context,
-      LanguageMode::kSloppy, restriction, parameters_end_pos, eval_position);
+  return Compiler::GetFunctionFromEval(source.ToHandleChecked(), outer_info,
+                                       native_context, LanguageMode::kSloppy,
+                                       restriction, parameters_end_pos,
+                                       eval_scope_position, eval_position);
 }
 
 // static
 MaybeHandle<JSFunction> Compiler::GetFunctionFromString(
     Handle<NativeContext> context, Handle<Object> source,
-    int parameters_end_pos, bool is_code_like) {
+    ParseRestriction restriction, int parameters_end_pos, bool is_code_like) {
   Isolate* const isolate = context->GetIsolate();
   MaybeHandle<String> validated_source =
       ValidateDynamicCompilationSource(isolate, context, source, is_code_like)
           .first;
-  return GetFunctionFromValidatedString(context, validated_source,
-                                        ONLY_SINGLE_FUNCTION_LITERAL,
+  return GetFunctionFromValidatedString(context, validated_source, restriction,
                                         parameters_end_pos);
 }
 
diff --git a/deps/v8/src/codegen/compiler.h b/deps/v8/src/codegen/compiler.h
index 2f7e1ff5781103..7fe0eb319413fe 100644
--- a/deps/v8/src/codegen/compiler.h
+++ b/deps/v8/src/codegen/compiler.h
@@ -159,7 +159,8 @@ class V8_EXPORT_PRIVATE Compiler : public AllStatic {
   V8_WARN_UNUSED_RESULT static MaybeHandle<JSFunction> GetFunctionFromEval(
       Handle<String> source, Handle<SharedFunctionInfo> outer_info,
       Handle<Context> context, LanguageMode language_mode,
-      ParseRestriction restriction, int parameters_end_pos, int eval_position,
+      ParseRestriction restriction, int parameters_end_pos,
+      int eval_scope_position, int eval_position,
       ParsingWhileDebugging parsing_while_debugging =
           ParsingWhileDebugging::kNo);
 
@@ -174,7 +175,7 @@ class V8_EXPORT_PRIVATE Compiler : public AllStatic {
   // Create a (bound) function for a String source within a context for eval.
   V8_WARN_UNUSED_RESULT static MaybeHandle<JSFunction> GetFunctionFromString(
       Handle<NativeContext> context, Handle<i::Object> source,
-      int parameters_end_pos, bool is_code_like);
+      ParseRestriction restriction, int parameters_end_pos, bool is_code_like);
 
   // Decompose GetFunctionFromString into two functions, to allow callers to
   // deal seperately with a case of object not handled by the embedder.
diff --git a/deps/v8/src/common/globals.h b/deps/v8/src/common/globals.h
index 9664111689be1a..4f09e54971c866 100644
--- a/deps/v8/src/common/globals.h
+++ b/deps/v8/src/common/globals.h
@@ -2586,7 +2586,7 @@ enum class StubCallMode {
 
 enum class NeedsContext { kYes, kNo };
 
-constexpr int kInvalidInfoId = -1;
+constexpr int kFunctionLiteralIdInvalid = -1;
 constexpr int kFunctionLiteralIdTopLevel = 0;
 
 constexpr int kSwissNameDictionaryInitialCapacity = 4;
diff --git a/deps/v8/src/d8/d8.cc b/deps/v8/src/d8/d8.cc
index 6101c651a0a2d3..1c37e97a380175 100644
--- a/deps/v8/src/d8/d8.cc
+++ b/deps/v8/src/d8/d8.cc
@@ -1268,17 +1268,10 @@ struct DynamicImportData {
 };
 
 namespace {
-struct ModuleResolutionData {
-  ModuleResolutionData(Isolate* isolate_, Local<Value> module_namespace_,
-                       Local<Promise::Resolver> resolver_)
-      : isolate(isolate_) {
-    module_namespace.Reset(isolate, module_namespace_);
-    resolver.Reset(isolate, resolver_);
-  }
 
-  Isolate* isolate;
-  Global<Value> module_namespace;
-  Global<Promise::Resolver> resolver;
+enum ModuleResolutionDataIndex : uint32_t {
+  kResolver = 0,
+  kNamespace = 1,
 };
 
 }  // namespace
@@ -1286,16 +1279,19 @@ struct ModuleResolutionData {
 void Shell::ModuleResolutionSuccessCallback(
     const FunctionCallbackInfo<Value>& info) {
   DCHECK(i::ValidateCallbackInfo(info));
-  std::unique_ptr<ModuleResolutionData> module_resolution_data(
-      static_cast<ModuleResolutionData*>(
-          info.Data().As<v8::External>()->Value()));
-  Isolate* isolate(module_resolution_data->isolate);
+  Isolate* isolate(info.GetIsolate());
   HandleScope handle_scope(isolate);
+  Local<Array> module_resolution_data(info.Data().As<Array>());
+  Local<Context> context(isolate->GetCurrentContext());
 
   Local<Promise::Resolver> resolver(
-      module_resolution_data->resolver.Get(isolate));
+      module_resolution_data->Get(context, ModuleResolutionDataIndex::kResolver)
+          .ToLocalChecked()
+          .As<Promise::Resolver>());
   Local<Value> module_namespace(
-      module_resolution_data->module_namespace.Get(isolate));
+      module_resolution_data
+          ->Get(context, ModuleResolutionDataIndex::kNamespace)
+          .ToLocalChecked());
 
   PerIsolateData* data = PerIsolateData::Get(isolate);
   Local<Context> realm = data->realms_[data->realm_current_].Get(isolate);
@@ -1307,14 +1303,15 @@ void Shell::ModuleResolutionSuccessCallback(
 void Shell::ModuleResolutionFailureCallback(
     const FunctionCallbackInfo<Value>& info) {
   DCHECK(i::ValidateCallbackInfo(info));
-  std::unique_ptr<ModuleResolutionData> module_resolution_data(
-      static_cast<ModuleResolutionData*>(
-          info.Data().As<v8::External>()->Value()));
-  Isolate* isolate(module_resolution_data->isolate);
+  Isolate* isolate(info.GetIsolate());
   HandleScope handle_scope(isolate);
+  Local<Array> module_resolution_data(info.Data().As<Array>());
+  Local<Context> context(isolate->GetCurrentContext());
 
   Local<Promise::Resolver> resolver(
-      module_resolution_data->resolver.Get(isolate));
+      module_resolution_data->Get(context, ModuleResolutionDataIndex::kResolver)
+          .ToLocalChecked()
+          .As<Promise::Resolver>());
 
   PerIsolateData* data = PerIsolateData::Get(isolate);
   Local<Context> realm = data->realms_[data->realm_current_].Get(isolate);
@@ -1492,15 +1489,20 @@ void Shell::DoHostImportModuleDynamically(void* import_data) {
   Local<Promise> result_promise = result.As<Promise>();
 
   // Setup callbacks, and then chain them to the result promise.
-  // ModuleResolutionData will be deleted by the callbacks.
-  auto module_resolution_data =
-      new ModuleResolutionData(isolate, module_namespace, resolver);
-  Local<v8::External> edata = External::New(isolate, module_resolution_data);
+  Local<Array> module_resolution_data = v8::Array::New(isolate);
+  module_resolution_data
+      ->Set(realm, ModuleResolutionDataIndex::kResolver, resolver)
+      .ToChecked();
+  module_resolution_data
+      ->Set(realm, ModuleResolutionDataIndex::kNamespace, module_namespace)
+      .ToChecked();
   Local<Function> callback_success;
-  CHECK(Function::New(realm, ModuleResolutionSuccessCallback, edata)
+  CHECK(Function::New(realm, ModuleResolutionSuccessCallback,
+                      module_resolution_data)
             .ToLocal(&callback_success));
   Local<Function> callback_failure;
-  CHECK(Function::New(realm, ModuleResolutionFailureCallback, edata)
+  CHECK(Function::New(realm, ModuleResolutionFailureCallback,
+                      module_resolution_data)
             .ToLocal(&callback_failure));
   result_promise->Then(realm, callback_success, callback_failure)
       .ToLocalChecked();
diff --git a/deps/v8/src/debug/debug-evaluate.cc b/deps/v8/src/debug/debug-evaluate.cc
index bee4229c47a4c3..981244e2f45561 100644
--- a/deps/v8/src/debug/debug-evaluate.cc
+++ b/deps/v8/src/debug/debug-evaluate.cc
@@ -175,10 +175,10 @@ MaybeHandle<Object> DebugEvaluate::Evaluate(
   Handle<JSFunction> eval_fun;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, eval_fun,
-      Compiler::GetFunctionFromEval(source, outer_info, context,
-                                    LanguageMode::kSloppy, NO_PARSE_RESTRICTION,
-                                    kNoSourcePosition, kNoSourcePosition,
-                                    ParsingWhileDebugging::kYes));
+      Compiler::GetFunctionFromEval(
+          source, outer_info, context, LanguageMode::kSloppy,
+          NO_PARSE_RESTRICTION, kNoSourcePosition, kNoSourcePosition,
+          kNoSourcePosition, ParsingWhileDebugging::kYes));
 
   Handle<Object> result;
   bool success = false;
diff --git a/deps/v8/src/debug/debug.cc b/deps/v8/src/debug/debug.cc
index c2da62779fcf92..7bf033c91fe80b 100644
--- a/deps/v8/src/debug/debug.cc
+++ b/deps/v8/src/debug/debug.cc
@@ -2149,7 +2149,7 @@ bool Debug::FindSharedFunctionInfosIntersectingRange(
     }
 
     if (!triedTopLevelCompile && !candidateSubsumesRange &&
-        script->infos()->length() > 0) {
+        script->shared_function_info_count() > 0) {
       MaybeHandle<SharedFunctionInfo> shared =
           GetTopLevelWithRecompile(script, &triedTopLevelCompile);
       if (shared.is_null()) return false;
@@ -2184,9 +2184,10 @@ bool Debug::FindSharedFunctionInfosIntersectingRange(
 
 MaybeHandle<SharedFunctionInfo> Debug::GetTopLevelWithRecompile(
     Handle<Script> script, bool* did_compile) {
-  DCHECK_LE(kFunctionLiteralIdTopLevel, script->infos()->length());
-  Tagged<MaybeObject> maybeToplevel =
-      script->infos()->get(kFunctionLiteralIdTopLevel);
+  DCHECK_LE(kFunctionLiteralIdTopLevel, script->shared_function_info_count());
+  DCHECK_LE(script->shared_function_info_count(),
+            script->shared_function_infos()->length());
+  Tagged<MaybeObject> maybeToplevel = script->shared_function_infos()->get(0);
   Tagged<HeapObject> heap_object;
   const bool topLevelInfoExists =
       maybeToplevel.GetHeapObject(&heap_object) && !IsUndefined(heap_object);
diff --git a/deps/v8/src/debug/liveedit.cc b/deps/v8/src/debug/liveedit.cc
index a902fe3e10e42f..c476998ac10b79 100644
--- a/deps/v8/src/debug/liveedit.cc
+++ b/deps/v8/src/debug/liveedit.cc
@@ -924,8 +924,8 @@ void LiveEdit::PatchScript(Isolate* isolate, Handle<Script> script,
 
     sfi->set_script(*new_script, kReleaseStore);
     sfi->set_function_literal_id(mapping.second->function_literal_id());
-    new_script->infos()->set(mapping.second->function_literal_id(),
-                             MakeWeak(*sfi));
+    new_script->shared_function_infos()->set(
+        mapping.second->function_literal_id(), MakeWeak(*sfi));
     DCHECK_EQ(sfi->function_literal_id(),
               mapping.second->function_literal_id());
 
@@ -1016,8 +1016,9 @@ void LiveEdit::PatchScript(Isolate* isolate, Handle<Script> script,
       // Grab that function id from the new script's SFI list, which should have
       // already been updated in in the unchanged pass.
       Tagged<SharedFunctionInfo> old_unchanged_inner_sfi =
-          Cast<SharedFunctionInfo>(
-              new_script->infos()->get(unchanged_it->second).GetHeapObject());
+          Cast<SharedFunctionInfo>(new_script->shared_function_infos()
+                                       ->get(unchanged_it->second)
+                                       .GetHeapObject());
       if (old_unchanged_inner_sfi == inner_sfi) continue;
       DCHECK_NE(old_unchanged_inner_sfi, inner_sfi);
       // Now some sanity checks. Make sure that the unchanged SFI has already
@@ -1058,7 +1059,7 @@ void LiveEdit::PatchScript(Isolate* isolate, Handle<Script> script,
         Tagged<SharedFunctionInfo> inner_sfi =
             Cast<SharedFunctionInfo>(constants->get(i));
         DCHECK_EQ(inner_sfi->script(), *new_script);
-        DCHECK_EQ(inner_sfi, new_script->infos()
+        DCHECK_EQ(inner_sfi, new_script->shared_function_infos()
                                  ->get(inner_sfi->function_literal_id())
                                  .GetHeapObject());
       }
diff --git a/deps/v8/src/diagnostics/objects-debug.cc b/deps/v8/src/diagnostics/objects-debug.cc
index 819bb45834b4a7..e7180831829fba 100644
--- a/deps/v8/src/diagnostics/objects-debug.cc
+++ b/deps/v8/src/diagnostics/objects-debug.cc
@@ -2397,13 +2397,12 @@ void Script::ScriptVerify(Isolate* isolate) {
 #else   // V8_ENABLE_WEBASSEMBLY
   CHECK(CanHaveLineEnds());
 #endif  // V8_ENABLE_WEBASSEMBLY
-  for (int i = 0; i < infos()->length(); ++i) {
-    Tagged<MaybeObject> maybe_object = infos()->get(i);
+  for (int i = 0; i < shared_function_info_count(); ++i) {
+    Tagged<MaybeObject> maybe_object = shared_function_infos()->get(i);
     Tagged<HeapObject> heap_object;
-    CHECK(!maybe_object.GetHeapObjectIfWeak(isolate, &heap_object) ||
+    CHECK(maybe_object.IsWeak() || maybe_object.IsCleared() ||
           (maybe_object.GetHeapObjectIfStrong(&heap_object) &&
-           IsUndefined(heap_object, isolate)) ||
-          Is<SharedFunctionInfo>(heap_object) || Is<ScopeInfo>(heap_object));
+           IsUndefined(heap_object, isolate)));
   }
 }
 
diff --git a/deps/v8/src/diagnostics/objects-printer.cc b/deps/v8/src/diagnostics/objects-printer.cc
index 0124198dd87e60..68262ec5caf101 100644
--- a/deps/v8/src/diagnostics/objects-printer.cc
+++ b/deps/v8/src/diagnostics/objects-printer.cc
@@ -2862,7 +2862,7 @@ void Script::ScriptPrint(std::ostream& os) {
     }
     os << "\n - eval from position: " << eval_from_position();
   }
-  os << "\n - infos: " << Brief(infos());
+  os << "\n - shared function infos: " << Brief(shared_function_infos());
   os << "\n";
 }
 
diff --git a/deps/v8/src/execution/isolate.cc b/deps/v8/src/execution/isolate.cc
index 922d7281615384..37e2763e8e94e3 100644
--- a/deps/v8/src/execution/isolate.cc
+++ b/deps/v8/src/execution/isolate.cc
@@ -2085,6 +2085,14 @@ Tagged<Object> Isolate::UnwindAndFindHandler() {
     return exception;
   };
 
+#if V8_ENABLE_WEBASSEMBLY
+  Tagged<Object> maybe_continuation = root(RootIndex::kActiveContinuation);
+  Tagged<WasmContinuationObject> continuation;
+  if (!IsUndefined(maybe_continuation)) {
+    continuation = Cast<WasmContinuationObject>(maybe_continuation);
+  }
+#endif
+
   // Special handling of termination exceptions, uncatchable by JavaScript and
   // Wasm code, we unwind the handlers until the top ENTRY handler is found.
   bool catchable_by_js = is_catchable_by_javascript(exception);
@@ -2103,15 +2111,25 @@ Tagged<Object> Isolate::UnwindAndFindHandler() {
   for (StackFrameIterator iter(this);; iter.Advance(), visited_frames++) {
 #if V8_ENABLE_WEBASSEMBLY
     if (iter.frame()->type() == StackFrame::STACK_SWITCH) {
-      Tagged<Code> code =
-          builtins()->code(Builtin::kWasmReturnPromiseOnSuspendAsm);
-      HandlerTable table(code);
-      Address instruction_start =
-          code->InstructionStart(this, iter.frame()->pc());
-      int handler_offset = table.LookupReturn(0);
-      return FoundHandler(Context(), instruction_start, handler_offset,
-                          kNullAddress, iter.frame()->sp(), iter.frame()->fp(),
-                          visited_frames);
+      if (catchable_by_js) {
+        Tagged<Code> code =
+            builtins()->code(Builtin::kWasmReturnPromiseOnSuspendAsm);
+        HandlerTable table(code);
+        Address instruction_start =
+            code->InstructionStart(this, iter.frame()->pc());
+        int handler_offset = table.LookupReturn(0);
+        return FoundHandler(Context(), instruction_start, handler_offset,
+                            kNullAddress, iter.frame()->sp(),
+                            iter.frame()->fp(), visited_frames);
+      } else {
+        // We reached the base of the wasm stack. Follow the chain of
+        // continuations to find the parent stack and reset the iterator.
+        DCHECK(!continuation.is_null());
+        continuation = Cast<WasmContinuationObject>(continuation->parent());
+        wasm::StackMemory* stack =
+            reinterpret_cast<wasm::StackMemory*>(continuation->stack());
+        iter.Reset(thread_local_top(), stack);
+      }
     }
 #endif
     // Handler must exist.
diff --git a/deps/v8/src/flags/flag-definitions.h b/deps/v8/src/flags/flag-definitions.h
index f8f0feaaef6565..1f964409e06979 100644
--- a/deps/v8/src/flags/flag-definitions.h
+++ b/deps/v8/src/flags/flag-definitions.h
@@ -996,11 +996,6 @@ DEFINE_BOOL(trace_track_allocation_sites, false,
 DEFINE_BOOL(trace_migration, false, "trace object migration")
 DEFINE_BOOL(trace_generalization, false, "trace map generalization")
 
-DEFINE_BOOL(reuse_scope_infos, false,
-            "reuse scope infos from previous compiles")
-
-DEFINE_IMPLICATION(fuzzing, reuse_scope_infos)
-
 // Flags for Sparkplug
 #undef FLAG
 #if V8_ENABLE_SPARKPLUG
diff --git a/deps/v8/src/heap/factory-base.cc b/deps/v8/src/heap/factory-base.cc
index 18336bae626cc4..024d7f0115eb7b 100644
--- a/deps/v8/src/heap/factory-base.cc
+++ b/deps/v8/src/heap/factory-base.cc
@@ -443,7 +443,8 @@ Handle<Script> FactoryBase<Impl>::NewScriptWithId(
     raw->set_eval_from_shared_or_wrapped_arguments(roots.undefined_value(),
                                                    SKIP_WRITE_BARRIER);
     raw->set_eval_from_position(0);
-    raw->set_infos(roots.empty_weak_fixed_array(), SKIP_WRITE_BARRIER);
+    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);
diff --git a/deps/v8/src/heap/factory.cc b/deps/v8/src/heap/factory.cc
index 5aba656b043139..88dd00a80185f7 100644
--- a/deps/v8/src/heap/factory.cc
+++ b/deps/v8/src/heap/factory.cc
@@ -1543,7 +1543,8 @@ Handle<Script> Factory::CloneScript(DirectHandle<Script> script,
     new_script->set_line_ends(Smi::zero());
     new_script->set_eval_from_shared_or_wrapped_arguments(
         script->eval_from_shared_or_wrapped_arguments());
-    new_script->set_infos(*empty_weak_fixed_array(), SKIP_WRITE_BARRIER);
+    new_script->set_shared_function_infos(*empty_weak_fixed_array(),
+                                          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());
diff --git a/deps/v8/src/heap/incremental-marking.cc b/deps/v8/src/heap/incremental-marking.cc
index 68280352016e7e..c5ceb8857dab07 100644
--- a/deps/v8/src/heap/incremental-marking.cc
+++ b/deps/v8/src/heap/incremental-marking.cc
@@ -494,6 +494,68 @@ void IncrementalMarking::UpdateMarkingWorklistAfterScavenge() {
   weak_objects_->UpdateAfterScavenge();
 }
 
+void IncrementalMarking::UpdateExternalPointerTableAfterScavenge() {
+#ifdef V8_COMPRESS_POINTERS
+  if (!IsMajorMarking()) return;
+  DCHECK(!v8_flags.separate_gc_phases);
+
+  heap_->isolate()->external_pointer_table().UpdateAllEvacuationEntries(
+      heap_->young_external_pointer_space(), [](Address old_handle_location) {
+        // 1) Resolve object start from the marking bitmap. Note that it's safe
+        //    since there is no black allocation for the young space (and hence
+        //    no range or page marking).
+        // 2) Get a relocated object from the forwaring reference stored in the
+        //    map.
+        // 3) Compute offset from the original object start to the handle
+        //    location.
+        // 4) Compute and return the new handle location.
+        //
+        // Please note that instead of updating the evacuation entries, we
+        // could simply clobber them all, which would still work, but limit
+        // compaction to some extent. We can reconsider this in the future, if
+        // relying on the marking bitmap becomes an issue (e.g. with inlined
+        // mark-bits).
+        const MemoryChunk* chunk =
+            MemoryChunk::FromAddress(old_handle_location);
+        if (!chunk->InYoungGeneration()) {
+          return old_handle_location;
+        }
+        // TODO(358485426): Check that the page is not black.
+
+        Address base = MarkingBitmap::FindPreviousValidObject(
+            static_cast<const PageMetadata*>(chunk->Metadata()),
+            old_handle_location);
+        Tagged<HeapObject> object(HeapObject::FromAddress(base));
+
+        MapWord map_word = object->map_word(kRelaxedLoad);
+        if (!map_word.IsForwardingAddress()) {
+      // There may be objects in the EPT that do not exist anymore. If these
+      // objects are dead at scavenging time, their marking deque entries will
+      // not point to forwarding addresses. Hence, we can discard them.
+#if DEBUG
+          // Check that the handle did reside inside the original dead object.
+          const int object_size = object->Size();
+          // Map slots can never contain external pointers.
+          DCHECK_LT(object.address(), old_handle_location);
+          DCHECK_LT(old_handle_location, object.address() + object_size);
+#endif  // DEBUG
+          return kNullAddress;
+        }
+
+        Tagged<HeapObject> moved_object = map_word.ToForwardingAddress(object);
+#if DEBUG
+        const int object_size = moved_object->Size();
+        // Map slots can never contain external pointers.
+        DCHECK_LT(object.address(), old_handle_location);
+        DCHECK_LT(old_handle_location, object.address() + object_size);
+#endif  // DEBUG
+
+        const ptrdiff_t handle_offset = old_handle_location - base;
+        return moved_object.address() + handle_offset;
+      });
+#endif  // V8_COMPRESS_POINTERS
+}
+
 void IncrementalMarking::UpdateMarkedBytesAfterScavenge(
     size_t dead_bytes_in_new_space) {
   if (!IsMajorMarking()) return;
diff --git a/deps/v8/src/heap/incremental-marking.h b/deps/v8/src/heap/incremental-marking.h
index 4c6a322396d958..0f21c5fa8a42af 100644
--- a/deps/v8/src/heap/incremental-marking.h
+++ b/deps/v8/src/heap/incremental-marking.h
@@ -102,6 +102,7 @@ class V8_EXPORT_PRIVATE IncrementalMarking final {
   bool Stop();
 
   void UpdateMarkingWorklistAfterScavenge();
+  void UpdateExternalPointerTableAfterScavenge();
   void UpdateMarkedBytesAfterScavenge(size_t dead_bytes_in_new_space);
 
   // Performs incremental marking step and finalizes marking if complete.
diff --git a/deps/v8/src/heap/object-stats.cc b/deps/v8/src/heap/object-stats.cc
index 2c6b72442bee9e..ed3d3fa5408488 100644
--- a/deps/v8/src/heap/object-stats.cc
+++ b/deps/v8/src/heap/object-stats.cc
@@ -929,8 +929,9 @@ void ObjectStatsCollectorImpl::RecordVirtualMapDetails(Tagged<Map> map) {
 
 void ObjectStatsCollectorImpl::RecordVirtualScriptDetails(
     Tagged<Script> script) {
-  RecordSimpleVirtualObjectStats(script, script->infos(),
-                                 ObjectStats::SCRIPT_INFOS_TYPE);
+  RecordSimpleVirtualObjectStats(
+      script, script->shared_function_infos(),
+      ObjectStats::SCRIPT_SHARED_FUNCTION_INFOS_TYPE);
 
   // Log the size of external source code.
   Tagged<Object> raw_source = script->source();
diff --git a/deps/v8/src/heap/object-stats.h b/deps/v8/src/heap/object-stats.h
index 569cca0904a921..9c121a61230b5f 100644
--- a/deps/v8/src/heap/object-stats.h
+++ b/deps/v8/src/heap/object-stats.h
@@ -70,7 +70,7 @@
   V(RELOC_INFO_TYPE)                             \
   V(RETAINED_MAPS_TYPE)                          \
   V(SCRIPT_LIST_TYPE)                            \
-  V(SCRIPT_INFOS_TYPE)                           \
+  V(SCRIPT_SHARED_FUNCTION_INFOS_TYPE)           \
   V(SCRIPT_SOURCE_EXTERNAL_ONE_BYTE_TYPE)        \
   V(SCRIPT_SOURCE_EXTERNAL_TWO_BYTE_TYPE)        \
   V(SCRIPT_SOURCE_NON_EXTERNAL_ONE_BYTE_TYPE)    \
diff --git a/deps/v8/src/heap/scavenger.cc b/deps/v8/src/heap/scavenger.cc
index 021e77e64ea79e..6eb032809bba62 100644
--- a/deps/v8/src/heap/scavenger.cc
+++ b/deps/v8/src/heap/scavenger.cc
@@ -506,6 +506,7 @@ void ScavengerCollector::CollectGarbage() {
         &Heap::UpdateYoungReferenceInExternalStringTableEntry);
 
     heap_->incremental_marking()->UpdateMarkingWorklistAfterScavenge();
+    heap_->incremental_marking()->UpdateExternalPointerTableAfterScavenge();
 
     if (V8_UNLIKELY(v8_flags.always_use_string_forwarding_table)) {
       isolate_->string_forwarding_table()->UpdateAfterYoungEvacuation();
diff --git a/deps/v8/src/init/bootstrapper.cc b/deps/v8/src/init/bootstrapper.cc
index 569d765413fbdd..4abbab6e9ed295 100644
--- a/deps/v8/src/init/bootstrapper.cc
+++ b/deps/v8/src/init/bootstrapper.cc
@@ -771,7 +771,7 @@ Handle<JSFunction> Genesis::CreateEmptyFunction() {
   DirectHandle<Script> script = factory()->NewScript(source);
   script->set_type(Script::Type::kNative);
   DirectHandle<WeakFixedArray> infos = factory()->NewWeakFixedArray(2);
-  script->set_infos(*infos);
+  script->set_shared_function_infos(*infos);
   ReadOnlyRoots roots{isolate()};
   Tagged<SharedFunctionInfo> sfi = empty_function->shared();
   sfi->set_raw_scope_info(roots.empty_function_scope_info());
diff --git a/deps/v8/src/interpreter/bytecode-generator.cc b/deps/v8/src/interpreter/bytecode-generator.cc
index 86f6c8bfdabb4f..05d48601ec63c7 100644
--- a/deps/v8/src/interpreter/bytecode-generator.cc
+++ b/deps/v8/src/interpreter/bytecode-generator.cc
@@ -6291,7 +6291,7 @@ void BytecodeGenerator::VisitCall(Call* expr) {
         .MoveRegister(Register::function_closure(), runtime_call_args[2])
         .LoadLiteral(Smi::FromEnum(language_mode()))
         .StoreAccumulatorInRegister(runtime_call_args[3])
-        .LoadLiteral(Smi::FromInt(expr->eval_scope_info_index()))
+        .LoadLiteral(Smi::FromInt(current_scope()->start_position()))
         .StoreAccumulatorInRegister(runtime_call_args[4])
         .LoadLiteral(Smi::FromInt(expr->position()))
         .StoreAccumulatorInRegister(runtime_call_args[5]);
diff --git a/deps/v8/src/interpreter/interpreter.cc b/deps/v8/src/interpreter/interpreter.cc
index 1473e6e17f1530..2f9a612d293d69 100644
--- a/deps/v8/src/interpreter/interpreter.cc
+++ b/deps/v8/src/interpreter/interpreter.cc
@@ -212,7 +212,7 @@ void InterpreterCompilationJob::CheckAndPrintBytecodeMismatch(
   int first_mismatch = generator()->CheckBytecodeMatches(*bytecode);
   if (first_mismatch >= 0) {
     parse_info()->ast_value_factory()->Internalize(isolate);
-    DeclarationScope::AllocateScopeInfos(parse_info(), script, isolate);
+    DeclarationScope::AllocateScopeInfos(parse_info(), isolate);
 
     DirectHandle<BytecodeArray> new_bytecode =
         generator()->FinalizeBytecode(isolate, script);
diff --git a/deps/v8/src/maglev/maglev-graph-builder.cc b/deps/v8/src/maglev/maglev-graph-builder.cc
index 0c45bcff87610b..1fcd1967638671 100644
--- a/deps/v8/src/maglev/maglev-graph-builder.cc
+++ b/deps/v8/src/maglev/maglev-graph-builder.cc
@@ -4063,7 +4063,10 @@ AllocationBlock* GetAllocation(ValueNode* object) {
 bool MaglevGraphBuilder::CanElideWriteBarrier(ValueNode* object,
                                               ValueNode* value) {
   if (value->Is<RootConstant>()) return true;
-  if (CheckType(value, NodeType::kSmi)) return true;
+  if (CheckType(value, NodeType::kSmi)) {
+    RecordUseReprHintIfPhi(value, UseRepresentation::kTagged);
+    return true;
+  }
 
   // No need for a write barrier if both object and value are part of the same
   // folded young allocation.
@@ -9689,7 +9692,8 @@ ReduceResult MaglevGraphBuilder::TryReduceConstructArrayConstructor(
 
 ReduceResult MaglevGraphBuilder::TryReduceConstructBuiltin(
     compiler::JSFunctionRef builtin,
-    compiler::SharedFunctionInfoRef shared_function_info, CallArguments& args) {
+    compiler::SharedFunctionInfoRef shared_function_info, ValueNode* target,
+    CallArguments& args) {
   // TODO(victorgomes): specialize more known constants builtin targets.
   switch (shared_function_info.builtin_id()) {
     case Builtin::kArrayConstructor: {
@@ -9700,6 +9704,7 @@ ReduceResult MaglevGraphBuilder::TryReduceConstructBuiltin(
       // If no value is passed, we can immediately lower to a simple
       // constructor.
       if (args.count() == 0) {
+        RETURN_IF_ABORT(BuildCheckValue(target, builtin));
         ValueNode* result = BuildInlinedAllocation(CreateJSConstructor(builtin),
                                                    AllocationType::kYoung);
         // TODO(leszeks): Don't eagerly clear the raw allocation, have the
@@ -9829,8 +9834,8 @@ ReduceResult MaglevGraphBuilder::TryReduceConstruct(
   }
 
   if (shared_function_info.HasBuiltinId()) {
-    RETURN_IF_DONE(
-        TryReduceConstructBuiltin(function, shared_function_info, args));
+    RETURN_IF_DONE(TryReduceConstructBuiltin(function, shared_function_info,
+                                             target, args));
   }
 
   if (shared_function_info.construct_as_builtin()) {
diff --git a/deps/v8/src/maglev/maglev-graph-builder.h b/deps/v8/src/maglev/maglev-graph-builder.h
index 7e1175612cf6d8..0630eac649d6d6 100644
--- a/deps/v8/src/maglev/maglev-graph-builder.h
+++ b/deps/v8/src/maglev/maglev-graph-builder.h
@@ -2008,7 +2008,7 @@ class MaglevGraphBuilder {
       compiler::OptionalAllocationSiteRef maybe_allocation_site = {});
   ReduceResult TryReduceConstructBuiltin(
       compiler::JSFunctionRef builtin,
-      compiler::SharedFunctionInfoRef shared_function_info,
+      compiler::SharedFunctionInfoRef shared_function_info, ValueNode* target,
       CallArguments& args);
   ReduceResult TryReduceConstructGeneric(
       compiler::JSFunctionRef function,
diff --git a/deps/v8/src/objects/module.cc b/deps/v8/src/objects/module.cc
index 3d97fc2370bd49..f39d1616aea0c7 100644
--- a/deps/v8/src/objects/module.cc
+++ b/deps/v8/src/objects/module.cc
@@ -218,7 +218,7 @@ bool Module::Instantiate(Isolate* isolate, Handle<Module> module,
     return false;
   }
   DCHECK(module->status() == kLinked || module->status() == kEvaluated ||
-         module->status() == kErrored);
+         module->status() == kEvaluatingAsync || module->status() == kErrored);
   DCHECK(stack.empty());
   return true;
 }
diff --git a/deps/v8/src/objects/objects.cc b/deps/v8/src/objects/objects.cc
index 2bb9803cfa8b5f..10ec0775ce3242 100644
--- a/deps/v8/src/objects/objects.cc
+++ b/deps/v8/src/objects/objects.cc
@@ -4602,13 +4602,14 @@ MaybeHandle<SharedFunctionInfo> Script::FindSharedFunctionInfo(
     FunctionLiteral* function_literal) {
   DCHECK(function_literal->shared_function_info().is_null());
   int function_literal_id = function_literal->function_literal_id();
-  CHECK_NE(function_literal_id, kInvalidInfoId);
+  CHECK_NE(function_literal_id, kFunctionLiteralIdInvalid);
   // If this check fails, the problem is most probably the function id
   // renumbering done by AstFunctionLiteralIdReindexer; in particular, that
   // AstTraversalVisitor doesn't recurse properly in the construct which
   // triggers the mismatch.
-  CHECK_LT(function_literal_id, script->infos()->length());
-  Tagged<MaybeObject> shared = script->infos()->get(function_literal_id);
+  CHECK_LT(function_literal_id, script->shared_function_info_count());
+  Tagged<MaybeObject> shared =
+      script->shared_function_infos()->get(function_literal_id);
   Tagged<HeapObject> heap_object;
   if (!shared.GetHeapObject(&heap_object) ||
       IsUndefined(heap_object, isolate)) {
diff --git a/deps/v8/src/objects/scope-info.cc b/deps/v8/src/objects/scope-info.cc
index 95c9e2a2bf4b3d..a334e8af05a8cb 100644
--- a/deps/v8/src/objects/scope-info.cc
+++ b/deps/v8/src/objects/scope-info.cc
@@ -464,8 +464,7 @@ Handle<ScopeInfo> ScopeInfo::CreateForWithScope(
   DCHECK_EQ(index, scope_info->InferredFunctionNameIndex());
   DCHECK(index == scope_info->OuterScopeInfoIndex());
   if (has_outer_scope_info) {
-    Tagged<ScopeInfo> outer = *outer_scope.ToHandleChecked();
-    scope_info->set(index++, outer);
+    scope_info->set(index++, *outer_scope.ToHandleChecked());
   }
   DCHECK_EQ(index, scope_info->length());
   DCHECK_EQ(0, scope_info->ParameterCount());
@@ -726,19 +725,6 @@ int ScopeInfo::ContextLength() const {
          (function_name_context_slot ? 1 : 0);
 }
 
-// Needs to be kept in sync with Scope::UniqueIdInScript.
-int ScopeInfo::UniqueIdInScript() const {
-  // Script scopes start "before" the script to avoid clashing with a scope that
-  // starts on character 0.
-  if (is_script_scope() || scope_type() == EVAL_SCOPE ||
-      scope_type() == MODULE_SCOPE) {
-    return -1;
-  }
-  // Default constructors have the same start position as their parent class
-  // scope. Use the next char position to distinguish this scope.
-  return StartPosition() + IsDefaultConstructor(function_kind());
-}
-
 bool ScopeInfo::HasContextExtensionSlot() const {
   return HasContextExtensionSlotBit::decode(Flags());
 }
diff --git a/deps/v8/src/objects/scope-info.h b/deps/v8/src/objects/scope-info.h
index c79b588dc62053..56d50e63a27e06 100644
--- a/deps/v8/src/objects/scope-info.h
+++ b/deps/v8/src/objects/scope-info.h
@@ -138,8 +138,6 @@ class ScopeInfo : public TorqueGeneratedScopeInfo<ScopeInfo, HeapObject> {
   int EndPosition() const;
   void SetPositionInfo(int start, int end);
 
-  int UniqueIdInScript() const;
-
   Tagged<SourceTextModuleInfo> ModuleDescriptorInfo() const;
 
   // Return true if the local names are inlined in the scope info object.
diff --git a/deps/v8/src/objects/script-inl.h b/deps/v8/src/objects/script-inl.h
index 030498dab9fafd..4ea86c9a994b85 100644
--- a/deps/v8/src/objects/script-inl.h
+++ b/deps/v8/src/objects/script-inl.h
@@ -32,7 +32,7 @@ ACCESSORS_CHECKED(Script, wasm_breakpoint_infos, Tagged<FixedArray>,
 ACCESSORS_CHECKED(Script, wasm_managed_native_module, Tagged<Object>,
                   kEvalFromPositionOffset, this->type() == Type::kWasm)
 ACCESSORS_CHECKED(Script, wasm_weak_instance_list, Tagged<WeakArrayList>,
-                  kInfosOffset, this->type() == Type::kWasm)
+                  kSharedFunctionInfosOffset, this->type() == Type::kWasm)
 #define CHECK_SCRIPT_NOT_WASM this->type() != Type::kWasm
 #else
 #define CHECK_SCRIPT_NOT_WASM true
@@ -87,21 +87,26 @@ Tagged<FixedArray> Script::wrapped_arguments() const {
   return Cast<FixedArray>(eval_from_shared_or_wrapped_arguments());
 }
 
-DEF_GETTER(Script, infos, Tagged<WeakFixedArray>) {
+DEF_GETTER(Script, shared_function_infos, Tagged<WeakFixedArray>) {
 #if V8_ENABLE_WEBASSEMBLY
   if (type() == Type::kWasm) {
     return ReadOnlyRoots(GetHeap()).empty_weak_fixed_array();
   }
 #endif  // V8_ENABLE_WEBASSEMBLY
-  return TaggedField<WeakFixedArray, kInfosOffset>::load(*this);
+  return TaggedField<WeakFixedArray, kSharedFunctionInfosOffset>::load(*this);
 }
 
-void Script::set_infos(Tagged<WeakFixedArray> value, WriteBarrierMode mode) {
+void Script::set_shared_function_infos(Tagged<WeakFixedArray> value,
+                                       WriteBarrierMode mode) {
 #if V8_ENABLE_WEBASSEMBLY
   DCHECK_NE(Type::kWasm, type());
 #endif  // V8_ENABLE_WEBASSEMBLY
-  TaggedField<WeakFixedArray, kInfosOffset>::store(*this, value);
-  CONDITIONAL_WRITE_BARRIER(*this, kInfosOffset, value, mode);
+  TaggedField<WeakFixedArray, kSharedFunctionInfosOffset>::store(*this, value);
+  CONDITIONAL_WRITE_BARRIER(*this, kSharedFunctionInfosOffset, value, mode);
+}
+
+int Script::shared_function_info_count() const {
+  return shared_function_infos()->length();
 }
 
 #if V8_ENABLE_WEBASSEMBLY
diff --git a/deps/v8/src/objects/script.h b/deps/v8/src/objects/script.h
index 58428612d60941..6f666e5013040e 100644
--- a/deps/v8/src/objects/script.h
+++ b/deps/v8/src/objects/script.h
@@ -83,9 +83,11 @@ class Script : public TorqueGeneratedScript<Script, Struct> {
   // code from which eval was called, as negative integer.
   DECL_INT_ACCESSORS(eval_from_position)
 
-  // [infos]: weak fixed array containing all shared function infos and scope
-  // infos for eval created from this script.
-  DECL_ACCESSORS(infos, Tagged<WeakFixedArray>)
+  // [shared_function_infos]: weak fixed array containing all shared
+  // function infos created from this script.
+  DECL_ACCESSORS(shared_function_infos, Tagged<WeakFixedArray>)
+
+  inline int shared_function_info_count() const;
 
 #if V8_ENABLE_WEBASSEMBLY
   // [wasm_breakpoint_infos]: the list of {BreakPointInfo} objects describing
diff --git a/deps/v8/src/objects/script.tq b/deps/v8/src/objects/script.tq
index cb4335031081c5..10b61fe483f74e 100644
--- a/deps/v8/src/objects/script.tq
+++ b/deps/v8/src/objects/script.tq
@@ -47,7 +47,7 @@ extern class Script extends Struct {
   eval_from_shared_or_wrapped_arguments: SharedFunctionInfo|FixedArray|
       Undefined;
   eval_from_position: Smi|Foreign;  // Smi or Managed<wasm::NativeModule>
-  infos: WeakFixedArray|WeakArrayList;
+  shared_function_infos: WeakFixedArray|WeakArrayList;
 
   // [compiled_lazy_function_positions]: ArrayList containing SMIs marking
   // the start positions of lazy functions which got compiled.
diff --git a/deps/v8/src/objects/shared-function-info-inl.h b/deps/v8/src/objects/shared-function-info-inl.h
index b777731f8e14a0..2f4bf56b1ea572 100644
--- a/deps/v8/src/objects/shared-function-info-inl.h
+++ b/deps/v8/src/objects/shared-function-info-inl.h
@@ -584,16 +584,9 @@ void SharedFunctionInfo::SetScopeInfo(Tagged<ScopeInfo> scope_info,
     name = Cast<UnionOf<Smi, String>>(name_or_scope_info);
   }
   DCHECK(IsString(name) || name == kNoSharedNameSentinel);
-  // ScopeInfo can get promoted to read-only space. Now that we reuse them after
-  // flushing bytecode, we'll actually reinstall read-only scopeinfos on
-  // SharedFunctionInfos if they required a context. The read-only scopeinfos
-  // should already be fully initialized though, and hence will already have the
-  // right FunctionName (and InferredName if relevant).
-  if (scope_info->FunctionName() != name) {
-    scope_info->SetFunctionName(name);
-  }
-  if (HasInferredName() && inferred_name()->length() != 0 &&
-      scope_info->InferredFunctionName() != inferred_name()) {
+  // Only set the function name for function scopes.
+  scope_info->SetFunctionName(name);
+  if (HasInferredName() && inferred_name()->length() != 0) {
     scope_info->SetInferredFunctionName(inferred_name());
   }
   set_name_or_scope_info(scope_info, kReleaseStore, mode);
diff --git a/deps/v8/src/objects/shared-function-info.cc b/deps/v8/src/objects/shared-function-info.cc
index bbc9d3cd950446..fffd2a6076ac2d 100644
--- a/deps/v8/src/objects/shared-function-info.cc
+++ b/deps/v8/src/objects/shared-function-info.cc
@@ -50,7 +50,7 @@ void SharedFunctionInfo::Init(ReadOnlyRoots ro_roots, int unique_id) {
   set_raw_outer_scope_info_or_feedback_metadata(ro_roots.the_hole_value(),
                                                 SKIP_WRITE_BARRIER);
   set_script(ro_roots.undefined_value(), kReleaseStore, SKIP_WRITE_BARRIER);
-  set_function_literal_id(kInvalidInfoId);
+  set_function_literal_id(kFunctionLiteralIdInvalid);
   set_unique_id(unique_id);
 
   // Set integer fields (smi or int, depending on the architecture).
@@ -140,17 +140,17 @@ Tagged<Code> SharedFunctionInfo::GetCode(Isolate* isolate) const {
 
 SharedFunctionInfo::ScriptIterator::ScriptIterator(Isolate* isolate,
                                                    Tagged<Script> script)
-    : ScriptIterator(handle(script->infos(), isolate)) {}
+    : ScriptIterator(handle(script->shared_function_infos(), isolate)) {}
 
-SharedFunctionInfo::ScriptIterator::ScriptIterator(Handle<WeakFixedArray> infos)
-    : infos_(infos), index_(0) {}
+SharedFunctionInfo::ScriptIterator::ScriptIterator(
+    Handle<WeakFixedArray> shared_function_infos)
+    : shared_function_infos_(shared_function_infos), index_(0) {}
 
 Tagged<SharedFunctionInfo> SharedFunctionInfo::ScriptIterator::Next() {
-  while (index_ < infos_->length()) {
-    Tagged<MaybeObject> raw = infos_->get(index_++);
+  while (index_ < shared_function_infos_->length()) {
+    Tagged<MaybeObject> raw = shared_function_infos_->get(index_++);
     Tagged<HeapObject> heap_object;
-    if (!raw.GetHeapObject(&heap_object) ||
-        !IsSharedFunctionInfo(heap_object)) {
+    if (!raw.GetHeapObject(&heap_object) || IsUndefined(heap_object)) {
       continue;
     }
     return Cast<SharedFunctionInfo>(heap_object);
@@ -160,7 +160,7 @@ Tagged<SharedFunctionInfo> SharedFunctionInfo::ScriptIterator::Next() {
 
 void SharedFunctionInfo::ScriptIterator::Reset(Isolate* isolate,
                                                Tagged<Script> script) {
-  infos_ = handle(script->infos(), isolate);
+  shared_function_infos_ = handle(script->shared_function_infos(), isolate);
   index_ = 0;
 }
 
@@ -183,7 +183,7 @@ void SharedFunctionInfo::SetScript(ReadOnlyRoots roots,
   if (IsScript(script_object)) {
     DCHECK(!IsScript(script()));
     Tagged<Script> script = Cast<Script>(script_object);
-    Tagged<WeakFixedArray> list = script->infos();
+    Tagged<WeakFixedArray> list = script->shared_function_infos();
 #ifdef DEBUG
     DCHECK_LT(function_literal_id, list->length());
     Tagged<MaybeObject> maybe_object = list->get(function_literal_id);
@@ -201,12 +201,14 @@ void SharedFunctionInfo::SetScript(ReadOnlyRoots roots,
 
     // Due to liveedit, it might happen that the old_script doesn't know
     // about the SharedFunctionInfo, so we have to guard against that.
-    Tagged<WeakFixedArray> infos = old_script->infos();
+    Tagged<WeakFixedArray> infos = old_script->shared_function_infos();
     if (function_literal_id < infos->length()) {
-      Tagged<MaybeObject> raw = old_script->infos()->get(function_literal_id);
+      Tagged<MaybeObject> raw =
+          old_script->shared_function_infos()->get(function_literal_id);
       Tagged<HeapObject> heap_object;
       if (raw.GetHeapObjectIfWeak(&heap_object) && heap_object == *this) {
-        old_script->infos()->set(function_literal_id, roots.undefined_value());
+        old_script->shared_function_infos()->set(function_literal_id,
+                                                 roots.undefined_value());
       }
     }
   }
diff --git a/deps/v8/src/objects/shared-function-info.h b/deps/v8/src/objects/shared-function-info.h
index b8d6a915b4adca..ec3138b5baf8a3 100644
--- a/deps/v8/src/objects/shared-function-info.h
+++ b/deps/v8/src/objects/shared-function-info.h
@@ -758,7 +758,7 @@ class SharedFunctionInfo
   class ScriptIterator {
    public:
     V8_EXPORT_PRIVATE ScriptIterator(Isolate* isolate, Tagged<Script> script);
-    explicit ScriptIterator(Handle<WeakFixedArray> infos);
+    explicit ScriptIterator(Handle<WeakFixedArray> shared_function_infos);
     ScriptIterator(const ScriptIterator&) = delete;
     ScriptIterator& operator=(const ScriptIterator&) = delete;
     V8_EXPORT_PRIVATE Tagged<SharedFunctionInfo> Next();
@@ -768,7 +768,7 @@ class SharedFunctionInfo
     void Reset(Isolate* isolate, Tagged<Script> script);
 
    private:
-    Handle<WeakFixedArray> infos_;
+    Handle<WeakFixedArray> shared_function_infos_;
     int index_;
   };
 
diff --git a/deps/v8/src/objects/source-text-module.cc b/deps/v8/src/objects/source-text-module.cc
index 35e336ee8bf525..db7d66c9ed9b86 100644
--- a/deps/v8/src/objects/source-text-module.cc
+++ b/deps/v8/src/objects/source-text-module.cc
@@ -682,8 +682,8 @@ void SourceTextModule::GatherAvailableAncestors(
 
       // a. If execList does not contain m and
       //    m.[[CycleRoot]].[[EvaluationError]] is empty, then
-      if (exec_list->find(m) == exec_list->end() &&
-          m->GetCycleRoot(isolate)->status() != kErrored) {
+      if (m->GetCycleRoot(isolate)->status() != kErrored &&
+          exec_list->find(m) == exec_list->end()) {
         // i. Assert: m.[[Status]] is EVALUATING-ASYNC.
         // ii. Assert: m.[[EvaluationError]] is empty.
         DCHECK_EQ(m->status(), kEvaluatingAsync);
@@ -769,7 +769,8 @@ bool SourceTextModule::MaybeHandleEvaluationException(
 // ES#sec-moduleevaluation
 MaybeHandle<Object> SourceTextModule::Evaluate(
     Isolate* isolate, Handle<SourceTextModule> module) {
-  CHECK(module->status() == kLinked || module->status() == kEvaluated);
+  CHECK(module->status() == kLinked || module->status() == kEvaluatingAsync ||
+        module->status() == kEvaluated);
 
   // 5. Let stack be a new empty List.
   Zone zone(isolate->allocator(), ZONE_NAME);
diff --git a/deps/v8/src/parsing/parse-info.cc b/deps/v8/src/parsing/parse-info.cc
index c08f4aaceab83a..2924e4df6193e9 100644
--- a/deps/v8/src/parsing/parse-info.cc
+++ b/deps/v8/src/parsing/parse-info.cc
@@ -198,7 +198,7 @@ ParseInfo::ParseInfo(const UnoptimizedCompileFlags flags,
       script_scope_(nullptr),
       stack_limit_(stack_limit),
       parameters_end_pos_(kNoSourcePosition),
-      max_info_id_(kInvalidInfoId),
+      max_function_literal_id_(kFunctionLiteralIdInvalid),
       character_stream_(nullptr),
       function_name_(nullptr),
       runtime_call_stats_(runtime_call_stats),
diff --git a/deps/v8/src/parsing/parse-info.h b/deps/v8/src/parsing/parse-info.h
index 0d8485bda94e04..59de7059190c23 100644
--- a/deps/v8/src/parsing/parse-info.h
+++ b/deps/v8/src/parsing/parse-info.h
@@ -328,8 +328,10 @@ class V8_EXPORT_PRIVATE ParseInfo {
     return flags().function_syntax_kind() == FunctionSyntaxKind::kWrapped;
   }
 
-  int max_info_id() const { return max_info_id_; }
-  void set_max_info_id(int max_info_id) { max_info_id_ = max_info_id; }
+  int max_function_literal_id() const { return max_function_literal_id_; }
+  void set_max_function_literal_id(int max_function_literal_id) {
+    max_function_literal_id_ = max_function_literal_id;
+  }
 
   void AllocateSourceRangeMap();
   SourceRangeMap* source_range_map() const { return source_range_map_; }
@@ -378,7 +380,7 @@ class V8_EXPORT_PRIVATE ParseInfo {
   DeclarationScope* script_scope_;
   uintptr_t stack_limit_;
   int parameters_end_pos_;
-  int max_info_id_;
+  int max_function_literal_id_;
 
   v8::CompileHintCallback compile_hint_callback_ = nullptr;
   void* compile_hint_callback_data_ = nullptr;
diff --git a/deps/v8/src/parsing/parser-base.h b/deps/v8/src/parsing/parser-base.h
index 0e82732a7ea89c..54e4d8ecc96d7c 100644
--- a/deps/v8/src/parsing/parser-base.h
+++ b/deps/v8/src/parsing/parser-base.h
@@ -22,6 +22,7 @@
 #include "src/logging/log.h"
 #include "src/logging/runtime-call-stats-scope.h"
 #include "src/objects/function-kind.h"
+#include "src/objects/tagged-impl.h"
 #include "src/parsing/expression-scope.h"
 #include "src/parsing/func-name-inferrer.h"
 #include "src/parsing/parse-info.h"
@@ -262,7 +263,7 @@ class ParserBase {
         expression_scope_(nullptr),
         scanner_(scanner),
         flags_(flags),
-        info_id_(0),
+        function_literal_id_(0),
         default_eager_compile_hint_(FunctionLiteral::kShouldLazyCompile) {
     pointer_buffer_.reserve(32);
     variable_buffer_.reserve(32);
@@ -291,13 +292,13 @@ class ParserBase {
   int loop_nesting_depth() const {
     return function_state_->loop_nesting_depth();
   }
-  int PeekNextInfoId() { return info_id_ + 1; }
-  int GetNextInfoId() { return ++info_id_; }
-  int GetLastInfoId() const { return info_id_; }
+  int PeekNextFunctionLiteralId() { return function_literal_id_ + 1; }
+  int GetNextFunctionLiteralId() { return ++function_literal_id_; }
+  int GetLastFunctionLiteralId() const { return function_literal_id_; }
 
-  void SkipInfos(int delta) { info_id_ += delta; }
+  void SkipFunctionLiterals(int delta) { function_literal_id_ += delta; }
 
-  void ResetInfoId() { info_id_ = 0; }
+  void ResetFunctionLiteralId() { function_literal_id_ = 0; }
 
   // The Zone where the parsing outputs are stored.
   Zone* main_zone() const { return ast_value_factory()->single_parse_zone(); }
@@ -619,7 +620,7 @@ class ParserBase {
             FunctionKind::kClassStaticInitializerFunction);
         static_elements_scope->SetLanguageMode(LanguageMode::kStrict);
         static_elements_scope->set_start_position(beg_pos);
-        static_elements_function_id = parser->GetNextInfoId();
+        static_elements_function_id = parser->GetNextFunctionLiteralId();
       }
       return static_elements_scope;
     }
@@ -631,7 +632,7 @@ class ParserBase {
             FunctionKind::kClassMembersInitializerFunction);
         instance_members_scope->SetLanguageMode(LanguageMode::kStrict);
         instance_members_scope->set_start_position(beg_pos);
-        instance_members_function_id = parser->GetNextInfoId();
+        instance_members_function_id = parser->GetNextFunctionLiteralId();
       }
       return instance_members_scope;
     }
@@ -1556,15 +1557,17 @@ class ParserBase {
   // Keep track of eval() calls since they disable all local variable
   // optimizations. This checks if expression is an eval call, and if yes,
   // forwards the information to scope.
-  bool CheckPossibleEvalCall(ExpressionT expression, bool is_optional_call,
-                             Scope* scope) {
+  Call::PossiblyEval CheckPossibleEvalCall(ExpressionT expression,
+                                           bool is_optional_call,
+                                           Scope* scope) {
     if (impl()->IsIdentifier(expression) &&
         impl()->IsEval(impl()->AsIdentifier(expression)) && !is_optional_call) {
       function_state_->RecordFunctionOrEvalCall();
       scope->RecordEvalCall();
-      return true;
+
+      return Call::IS_POSSIBLY_EVAL;
     }
-    return false;
+    return Call::NOT_EVAL;
   }
 
   // Convenience method which determines the type of return statement to emit
@@ -1678,7 +1681,7 @@ class ParserBase {
   Scanner* scanner_;
 
   const UnoptimizedCompileFlags flags_;
-  int info_id_;
+  int function_literal_id_;
 
   FunctionLiteral::EagerCompileHint default_eager_compile_hint_;
 
@@ -1887,7 +1890,7 @@ bool ParserBase<Impl>::IsExtraordinaryPrivateNameAccessAllowed() const {
         return true;
       // Top-level wrapper function scopes.
       case FUNCTION_SCOPE:
-        return info_id_ == kFunctionLiteralIdTopLevel;
+        return function_literal_id_ == kFunctionLiteralIdTopLevel;
       // Used by debug-evaluate. If the outer scope is top-level,
       // extraordinary private name access is allowed.
       case EVAL_SCOPE:
@@ -2073,7 +2076,8 @@ ParserBase<Impl>::ParsePrimaryExpression() {
     }
 
     if (V8_UNLIKELY(peek() == Token::kArrow)) {
-      ArrowHeadParsingScope parsing_scope(impl(), kind, PeekNextInfoId());
+      ArrowHeadParsingScope parsing_scope(impl(), kind,
+                                          PeekNextFunctionLiteralId());
       IdentifierT name = ParseAndClassifyIdentifier(token);
       ClassifyParameter(name, beg_pos, end_position());
       ExpressionT result =
@@ -2140,7 +2144,8 @@ ParserBase<Impl>::ParsePrimaryExpression() {
         if (peek() != Token::kArrow) ReportUnexpectedToken(Token::kRightParen);
         next_arrow_function_info_.scope =
             NewFunctionScope(FunctionKind::kArrowFunction);
-        next_arrow_function_info_.function_literal_id = PeekNextInfoId();
+        next_arrow_function_info_.function_literal_id =
+            PeekNextFunctionLiteralId();
         next_arrow_function_info_.could_be_immediately_invoked =
             position_after_last_primary_expression_open_parenthesis_ == beg_pos;
         return factory()->NewEmptyParentheses(beg_pos);
@@ -2149,7 +2154,7 @@ ParserBase<Impl>::ParsePrimaryExpression() {
       bool could_be_immediately_invoked_arrow_function =
           position_after_last_primary_expression_open_parenthesis_ == beg_pos;
       ArrowHeadParsingScope maybe_arrow(impl(), FunctionKind::kArrowFunction,
-                                        PeekNextInfoId());
+                                        PeekNextFunctionLiteralId());
       position_after_last_primary_expression_open_parenthesis_ =
           peek_position();
       // Heuristically try to detect immediately called functions before
@@ -3134,7 +3139,7 @@ ParserBase<Impl>::ParseAssignmentExpressionCoverGrammarContinuation(
     // function, and checks whether it's still the function id we wanted. If
     // not, we'll reindex the arrow function formal parameters to shift them all
     // 1 down to make space for the arrow function.
-    if (function_literal_id != GetNextInfoId()) {
+    if (function_literal_id != GetNextFunctionLiteralId()) {
       impl()->ReindexArrowFunctionFormalParameters(&parameters);
     }
 
@@ -3719,7 +3724,7 @@ ParserBase<Impl>::ParseLeftHandSideContinuation(ExpressionT result) {
     int pos = position();
 
     ArrowHeadParsingScope maybe_arrow(impl(), FunctionKind::kAsyncArrowFunction,
-                                      PeekNextInfoId());
+                                      PeekNextFunctionLiteralId());
     Scope::Snapshot scope_snapshot(scope());
 
     ExpressionListT args(pointer_buffer());
@@ -3825,13 +3830,11 @@ ParserBase<Impl>::ParseLeftHandSideContinuation(ExpressionT result) {
         // no explicit receiver.
         // These calls are marked as potentially direct eval calls. Whether
         // they are actually direct calls to eval is determined at run time.
-        int eval_scope_info_index = 0;
-        if (CheckPossibleEvalCall(result, is_optional, scope())) {
-          eval_scope_info_index = GetNextInfoId();
-        }
+        Call::PossiblyEval is_possibly_eval =
+            CheckPossibleEvalCall(result, is_optional, scope());
 
         result = factory()->NewCall(result, args, pos, has_spread,
-                                    eval_scope_info_index, is_optional);
+                                    is_possibly_eval, is_optional);
 
         fni_.RemoveLastFunction();
         break;
@@ -4672,7 +4675,7 @@ void ParserBase<Impl>::ParseFunctionBody(
     if (has_error()) return;
 
     inner_scope = NewVarblockScope();
-    inner_scope->set_start_position(end_position());
+    inner_scope->set_start_position(scanner()->location().beg_pos);
   }
 
   StatementListT inner_body(pointer_buffer());
@@ -6091,7 +6094,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseWithStatement(
   StatementT body = impl()->NullStatement();
   {
     BlockState block_state(&scope_, with_scope);
-    with_scope->set_start_position(position());
+    with_scope->set_start_position(scanner()->peek_location().beg_pos);
     body = ParseStatement(labels, nullptr);
     with_scope->set_end_position(end_position());
   }
@@ -6293,7 +6296,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseTryStatement() {
 
       if (has_binding) {
         catch_info.scope = NewScope(CATCH_SCOPE);
-        catch_info.scope->set_start_position(position());
+        catch_info.scope->set_start_position(scanner()->location().beg_pos);
 
         {
           BlockState catch_block_state(&scope_, catch_info.scope);
@@ -6303,7 +6306,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseTryStatement() {
           // as part of destructuring the catch parameter.
           {
             BlockState catch_variable_block_state(zone(), &scope_);
-            scope()->set_start_position(peek_position());
+            scope()->set_start_position(position());
 
             if (peek_any_identifier()) {
               IdentifierT identifier = ParseNonRestrictedIdentifier();
@@ -6420,7 +6423,6 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForStatement(
     // Create an inner block scope which will be the parent scope of scopes
     // possibly created by ParseVariableDeclarations.
     Scope* inner_block_scope = NewScope(BLOCK_SCOPE);
-    inner_block_scope->set_start_position(end_position());
     {
       BlockState inner_state(&scope_, inner_block_scope);
       ParseVariableDeclarations(kForStatement, &for_info.parsing_result,
@@ -6446,6 +6448,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForStatement(
     // above was parsed there. We'll finalize the unnecessary outer block scope
     // after parsing the rest of the loop.
     StatementT result = impl()->NullStatement();
+    inner_block_scope->set_start_position(scope()->start_position());
     {
       BlockState inner_state(&scope_, inner_block_scope);
       StatementT init =
@@ -6465,7 +6468,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForStatement(
     ParseVariableDeclarations(kForStatement, &for_info.parsing_result,
                               &for_info.bound_names);
     DCHECK_EQ(for_info.parsing_result.descriptor.mode, VariableMode::kVar);
-    for_info.position = position();
+    for_info.position = scanner()->location().beg_pos;
 
     if (CheckInOrOf(&for_info.mode)) {
       return ParseForEachStatementWithDeclarations(stmt_pos, &for_info, labels,
@@ -6572,6 +6575,10 @@ ParserBase<Impl>::ParseForEachStatementWithDeclarations(
 
   Expect(Token::kRightParen);
 
+  if (IsLexicalVariableMode(for_info->parsing_result.descriptor.mode)) {
+    inner_block_scope->set_start_position(position());
+  }
+
   ExpressionT each_variable = impl()->NullExpression();
   BlockT body_block = impl()->NullBlock();
   {
@@ -6750,7 +6757,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForAwaitStatement(
   Expect(Token::kFor);
   Expect(Token::kAwait);
   Expect(Token::kLeftParen);
-  scope()->set_start_position(position());
+  scope()->set_start_position(scanner()->location().beg_pos);
   scope()->set_is_hidden();
 
   auto loop = factory()->NewForOfStatement(stmt_pos, IteratorType::kAsync);
@@ -6764,7 +6771,6 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForAwaitStatement(
 
   bool has_declarations = false;
   Scope* inner_block_scope = NewScope(BLOCK_SCOPE);
-  inner_block_scope->set_start_position(peek_position());
 
   bool starts_with_let = peek() == Token::kLet;
   if (peek() == Token::kVar || peek() == Token::kConst ||
@@ -6781,7 +6787,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForAwaitStatement(
       ParseVariableDeclarations(kForStatement, &for_info.parsing_result,
                                 &for_info.bound_names);
     }
-    for_info.position = position();
+    for_info.position = scanner()->location().beg_pos;
 
     // Only a single declaration is allowed in for-await-of loops
     if (for_info.parsing_result.declarations.size() != 1) {
@@ -6836,6 +6842,7 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForAwaitStatement(
   StatementT body = impl()->NullStatement();
   {
     BlockState block_state(&scope_, inner_block_scope);
+    scope()->set_start_position(scanner()->location().beg_pos);
 
     SourceRange body_range;
     {
diff --git a/deps/v8/src/parsing/parser.cc b/deps/v8/src/parsing/parser.cc
index c09342c05c0423..fb03e8e4516162 100644
--- a/deps/v8/src/parsing/parser.cc
+++ b/deps/v8/src/parsing/parser.cc
@@ -80,7 +80,7 @@ FunctionLiteral* Parser::DefaultConstructor(const AstRawString* name,
       name, function_scope, body, expected_property_count, parameter_count,
       parameter_count, FunctionLiteral::kNoDuplicateParameters,
       FunctionSyntaxKind::kAnonymousExpression, default_eager_compile_hint(),
-      pos, true, GetNextInfoId());
+      pos, true, GetNextFunctionLiteralId());
   return function_literal;
 }
 
@@ -601,7 +601,7 @@ FunctionLiteral* Parser::DoParseProgram(Isolate* isolate, ParseInfo* info) {
   DCHECK_NULL(scope_);
 
   ParsingModeScope mode(this, allow_lazy_ ? PARSE_LAZILY : PARSE_EAGERLY);
-  ResetInfoId();
+  ResetFunctionLiteralId();
 
   FunctionLiteral* result = nullptr;
   {
@@ -706,7 +706,7 @@ FunctionLiteral* Parser::DoParseProgram(Isolate* isolate, ParseInfo* info) {
     result->set_suspend_count(function_state.suspend_count());
   }
 
-  info->set_max_info_id(GetLastInfoId());
+  info->set_max_function_literal_id(GetLastFunctionLiteralId());
 
   if (has_error()) return nullptr;
 
@@ -896,7 +896,7 @@ void Parser::ParseFunction(Isolate* isolate, ParseInfo* info,
     result = ParseClassForMemberInitialization(
         function_kind, start_position, function_literal_id, end_position,
         info->function_name());
-    info->set_max_info_id(GetLastInfoId());
+
   } else if (V8_UNLIKELY(shared_info->private_name_lookup_skips_outer_class() &&
                          original_scope_->is_class_scope())) {
     // If the function skips the outer class and the outer scope is a class, the
@@ -937,9 +937,9 @@ FunctionLiteral* Parser::DoParseFunction(Isolate* isolate, ParseInfo* info,
   DCHECK(ast_value_factory());
   fni_.PushEnclosingName(raw_name);
 
-  ResetInfoId();
+  ResetFunctionLiteralId();
   DCHECK_LT(0, function_literal_id);
-  SkipInfos(function_literal_id - 1);
+  SkipFunctionLiterals(function_literal_id - 1);
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
@@ -973,7 +973,7 @@ FunctionLiteral* Parser::DoParseFunction(Isolate* isolate, ParseInfo* info,
         }
       }
 
-      CHECK_EQ(function_literal_id, GetNextInfoId());
+      CHECK_EQ(function_literal_id, GetNextFunctionLiteralId());
 
       // TODO(adamk): We should construct this scope from the ScopeInfo.
       DeclarationScope* scope = NewFunctionScope(kind);
@@ -1046,8 +1046,6 @@ FunctionLiteral* Parser::DoParseFunction(Isolate* isolate, ParseInfo* info,
         flags().has_static_private_methods_or_accessors());
   }
 
-  info->set_max_info_id(GetLastInfoId());
-
   DCHECK_IMPLIES(result, function_literal_id == result->function_literal_id());
   return result;
 }
@@ -1066,8 +1064,8 @@ FunctionLiteral* Parser::ParseClassForMemberInitialization(
   FunctionState function_state(&function_state_, &scope_, nearest_decl_scope);
 
   // We will reindex the function literals later.
-  ResetInfoId();
-  SkipInfos(initializer_id - 1);
+  ResetFunctionLiteralId();
+  SkipFunctionLiterals(initializer_id - 1);
 
   // We preparse the class members that are not fields with initializers
   // in order to collect the function literal ids.
@@ -2732,7 +2730,7 @@ FunctionLiteral* Parser::ParseFunctionLiteral(
   int num_parameters = -1;
   int function_length = -1;
   bool has_duplicate_parameters = false;
-  int function_literal_id = GetNextInfoId();
+  int function_literal_id = GetNextFunctionLiteralId();
   ProducedPreparseData* produced_preparse_data = nullptr;
 
   // Inner functions will be parsed using a temporary Zone. After parsing, we
@@ -2846,7 +2844,7 @@ bool Parser::SkipFunction(const AstRawString* function_name, FunctionKind kind,
   if (consumed_preparse_data_) {
     int end_position;
     LanguageMode language_mode;
-    int num_inner_infos;
+    int num_inner_functions;
     bool uses_super_property;
     if (stack_overflow()) return true;
     {
@@ -2854,7 +2852,7 @@ bool Parser::SkipFunction(const AstRawString* function_name, FunctionKind kind,
       *produced_preparse_data =
           consumed_preparse_data_->GetDataForSkippableFunction(
               main_zone(), function_scope->start_position(), &end_position,
-              num_parameters, function_length, &num_inner_infos,
+              num_parameters, function_length, &num_inner_functions,
               &uses_super_property, &language_mode);
     }
 
@@ -2867,7 +2865,7 @@ bool Parser::SkipFunction(const AstRawString* function_name, FunctionKind kind,
     if (uses_super_property) {
       function_scope->RecordSuperPropertyUsage();
     }
-    SkipInfos(num_inner_infos);
+    SkipFunctionLiterals(num_inner_functions);
     function_scope->ResetAfterPreparsing(ast_value_factory_, false);
     return true;
   }
@@ -2924,7 +2922,7 @@ bool Parser::SkipFunction(const AstRawString* function_name, FunctionKind kind,
         function_scope->end_position() - function_scope->start_position();
     *num_parameters = logger->num_parameters();
     *function_length = logger->function_length();
-    SkipInfos(logger->num_inner_infos());
+    SkipFunctionLiterals(logger->num_inner_functions());
     if (!private_name_scope_iter.Done()) {
       private_name_scope_iter.GetScope()->MigrateUnresolvedPrivateNameTail(
           factory(), unresolved_private_tail);
@@ -2967,13 +2965,8 @@ Block* Parser::BuildParameterInitializationBlock(
   return factory()->NewBlock(true, init_statements);
 }
 
-// TODO(verwaest): Consider building these try/catches in the bytecode generator
-// without hidden scopes.
 Scope* Parser::NewHiddenCatchScope() {
-  DCHECK(scope()->is_declaration_scope());
   Scope* catch_scope = NewScopeWithParent(scope(), CATCH_SCOPE);
-  catch_scope->set_start_position(position());
-  catch_scope->set_end_position(end_position());
   bool was_added;
   catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(),
                             VariableMode::kVar, NORMAL_VARIABLE, &was_added);
@@ -3093,7 +3086,7 @@ void Parser::ParseFunction(
         }
       }
       Expect(Token::kRightParen);
-      int formals_end_position = end_position();
+      int formals_end_position = scanner()->location().end_pos;
 
       CheckArityRestrictions(formals.arity, kind, formals.has_rest,
                              function_scope->start_position(),
@@ -3631,15 +3624,7 @@ void Parser::RewriteAsyncFunctionBody(ScopedPtrList<Statement>* body,
   block->statements()->Add(factory()->NewSyntheticAsyncReturnStatement(
                                return_value, return_value->position()),
                            zone());
-  if (block->statements()->length() > 1 ||
-      !(return_value->IsLiteral() &&
-        return_value->AsLiteral()->type() == Literal::kUndefined)) {
-    // We only build a promise reject try/catch if there's actually a body that
-    // can throw. Otherwise we might try to create two catch blocks with the
-    // same source position, which doesn't work for scope_info reuse through
-    // source-position-based unique scope IDs.
-    block = BuildRejectPromiseOnException(block, repl_mode);
-  }
+  block = BuildRejectPromiseOnException(block, repl_mode);
   body->Add(block);
 }
 
diff --git a/deps/v8/src/parsing/preparser-logger.h b/deps/v8/src/parsing/preparser-logger.h
index b3bc56f5b33389..daa89a9ed82f47 100644
--- a/deps/v8/src/parsing/preparser-logger.h
+++ b/deps/v8/src/parsing/preparser-logger.h
@@ -14,27 +14,27 @@ class PreParserLogger final {
       : end_(-1),
         num_parameters_(-1),
         function_length_(-1),
-        num_inner_infos_(-1) {}
+        num_inner_functions_(-1) {}
 
   void LogFunction(int end, int num_parameters, int function_length,
-                   int num_inner_infos) {
+                   int num_inner_functions) {
     end_ = end;
     num_parameters_ = num_parameters;
     function_length_ = function_length;
-    num_inner_infos_ = num_inner_infos;
+    num_inner_functions_ = num_inner_functions;
   }
 
   int end() const { return end_; }
   int num_parameters() const { return num_parameters_; }
   int function_length() const { return function_length_; }
-  int num_inner_infos() const { return num_inner_infos_; }
+  int num_inner_functions() const { return num_inner_functions_; }
 
  private:
   int end_;
   // For function entries.
   int num_parameters_;
   int function_length_;
-  int num_inner_infos_;
+  int num_inner_functions_;
 };
 
 }  // namespace internal
diff --git a/deps/v8/src/parsing/preparser.cc b/deps/v8/src/parsing/preparser.cc
index 4955045227c425..8e1e1e6595b8ed 100644
--- a/deps/v8/src/parsing/preparser.cc
+++ b/deps/v8/src/parsing/preparser.cc
@@ -113,7 +113,7 @@ PreParser::PreParseResult PreParser::PreParseFunction(
   // In the preparser, we use the function literal ids to count how many
   // FunctionLiterals were encountered. The PreParser doesn't actually persist
   // FunctionLiterals, so there IDs don't matter.
-  ResetInfoId();
+  ResetFunctionLiteralId();
 
   // The caller passes the function_scope which is not yet inserted into the
   // scope stack. All scopes above the function_scope are ignored by the
@@ -277,7 +277,7 @@ PreParser::Expression PreParser::ParseFunctionLiteral(
 
   DeclarationScope* function_scope = NewFunctionScope(kind);
   function_scope->SetLanguageMode(language_mode);
-  int func_id = GetNextInfoId();
+  int func_id = GetNextFunctionLiteralId();
   bool skippable_function = false;
 
   // Start collecting data for a new function which might contain skippable
@@ -330,7 +330,8 @@ PreParser::Expression PreParser::ParseFunctionLiteral(
     }
     if (skippable_function) {
       preparse_data_builder_scope.SetSkippableFunction(
-          function_scope, formals.function_length, GetLastInfoId() - func_id);
+          function_scope, formals.function_length,
+          GetLastFunctionLiteralId() - func_id);
     }
   }
 
@@ -366,7 +367,7 @@ void PreParser::ParseStatementListAndLogFunction(
   int body_end = scanner()->peek_location().end_pos;
   DCHECK_EQ(this->scope()->is_function_scope(), formals->is_simple);
   log_.LogFunction(body_end, formals->num_parameters(),
-                   formals->function_length, GetLastInfoId());
+                   formals->function_length, GetLastFunctionLiteralId());
 }
 
 PreParserBlock PreParser::BuildParameterInitializationBlock(
diff --git a/deps/v8/src/parsing/preparser.h b/deps/v8/src/parsing/preparser.h
index 4ec4399343bb49..dbb338aee749f6 100644
--- a/deps/v8/src/parsing/preparser.h
+++ b/deps/v8/src/parsing/preparser.h
@@ -581,9 +581,10 @@ class PreParserFactory {
   }
   PreParserExpression NewCall(PreParserExpression expression,
                               const PreParserExpressionList& arguments, int pos,
-                              bool has_spread, int eval_scope_info_index = 0,
+                              bool has_spread,
+                              Call::PossiblyEval possibly_eval = Call::NOT_EVAL,
                               bool optional_chain = false) {
-    if (eval_scope_info_index > 0) {
+    if (possibly_eval == Call::IS_POSSIBLY_EVAL) {
       DCHECK(expression.IsIdentifier() && expression.AsIdentifier().IsEval());
       DCHECK(!optional_chain);
       return PreParserExpression::CallEval();
@@ -1176,7 +1177,7 @@ class PreParser : public ParserBase<PreParser> {
       function_scope->set_start_position(pos);
       function_scope->set_end_position(pos);
       FunctionState function_state(&function_state_, &scope_, function_scope);
-      GetNextInfoId();
+      GetNextFunctionLiteralId();
     }
     return PreParserExpression::Default();
   }
diff --git a/deps/v8/src/profiler/heap-snapshot-generator.cc b/deps/v8/src/profiler/heap-snapshot-generator.cc
index 86b7b9a05eaa8a..fc690f911e9db5 100644
--- a/deps/v8/src/profiler/heap-snapshot-generator.cc
+++ b/deps/v8/src/profiler/heap-snapshot-generator.cc
@@ -1709,7 +1709,8 @@ void V8HeapExplorer::ExtractScriptReferences(HeapEntry* entry,
   TagObject(script->line_ends(), "(script line ends)", HeapEntry::kCode);
   SetInternalReference(entry, "line_ends", script->line_ends(),
                        Script::kLineEndsOffset);
-  TagObject(script->infos(), "(infos)", HeapEntry::kCode);
+  TagObject(script->shared_function_infos(), "(shared function infos)",
+            HeapEntry::kCode);
   TagObject(script->host_defined_options(), "(host-defined options)",
             HeapEntry::kCode);
 #if V8_ENABLE_WEBASSEMBLY
@@ -1723,7 +1724,7 @@ void V8HeapExplorer::ExtractScriptReferences(HeapEntry* entry,
                          Script::kEvalFromPositionOffset);
     SetInternalReference(entry, "wasm_weak_instance_list",
                          script->wasm_weak_instance_list(),
-                         Script::kInfosOffset);
+                         Script::kSharedFunctionInfosOffset);
   }
 #endif
 }
diff --git a/deps/v8/src/runtime/runtime-compiler.cc b/deps/v8/src/runtime/runtime-compiler.cc
index 67437c0178d3bd..9683573bd8d27c 100644
--- a/deps/v8/src/runtime/runtime-compiler.cc
+++ b/deps/v8/src/runtime/runtime-compiler.cc
@@ -626,7 +626,7 @@ static Tagged<Object> CompileGlobalEval(Isolate* isolate,
                                         Handle<i::Object> source_object,
                                         Handle<SharedFunctionInfo> outer_info,
                                         LanguageMode language_mode,
-                                        int eval_scope_info_index,
+                                        int eval_scope_position,
                                         int eval_position) {
   Handle<NativeContext> native_context = isolate->native_context();
 
@@ -655,21 +655,11 @@ static Tagged<Object> CompileGlobalEval(Isolate* isolate,
   static const ParseRestriction restriction = NO_PARSE_RESTRICTION;
   Handle<JSFunction> compiled;
   Handle<Context> context(isolate->context(), isolate);
-  if (!Is<NativeContext>(*context) && v8_flags.reuse_scope_infos) {
-    Tagged<WeakFixedArray> array = Cast<Script>(outer_info->script())->infos();
-    Tagged<ScopeInfo> stored_info;
-    if (array->get(eval_scope_info_index)
-            .GetHeapObjectIfWeak(isolate, &stored_info)) {
-      CHECK_EQ(stored_info, context->scope_info());
-    } else {
-      array->set(eval_scope_info_index, MakeWeak(context->scope_info()));
-    }
-  }
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, compiled,
-      Compiler::GetFunctionFromEval(source.ToHandleChecked(), outer_info,
-                                    context, language_mode, restriction,
-                                    kNoSourcePosition, eval_position),
+      Compiler::GetFunctionFromEval(
+          source.ToHandleChecked(), outer_info, context, language_mode,
+          restriction, kNoSourcePosition, eval_scope_position, eval_position),
       ReadOnlyRoots(isolate).exception());
   return *compiled;
 }
diff --git a/deps/v8/src/runtime/runtime-wasm.cc b/deps/v8/src/runtime/runtime-wasm.cc
index 9af490308d2e8e..71e7f3504afdef 100644
--- a/deps/v8/src/runtime/runtime-wasm.cc
+++ b/deps/v8/src/runtime/runtime-wasm.cc
@@ -509,6 +509,8 @@ void ReplaceWrapper(Isolate* isolate,
   CHECK(trusted_instance_data->try_get_func_ref(function_index, &func_ref));
   Tagged<JSFunction> external_function;
   CHECK(func_ref->internal(isolate)->try_get_external(&external_function));
+  if (external_function->shared()->HasWasmJSFunctionData()) return;
+  CHECK(external_function->shared()->HasWasmExportedFunctionData());
   external_function->set_code(*wrapper_code);
   Tagged<WasmExportedFunctionData> function_data =
       external_function->shared()->wasm_exported_function_data();
diff --git a/deps/v8/src/sandbox/compactible-external-entity-table.h b/deps/v8/src/sandbox/compactible-external-entity-table.h
index 875cba46df8545..79ac7e09b0e314 100644
--- a/deps/v8/src/sandbox/compactible-external-entity-table.h
+++ b/deps/v8/src/sandbox/compactible-external-entity-table.h
@@ -42,7 +42,7 @@ enum class ExternalEntityTableCompactionOutcome {
  *    compacted. This decision is mostly based on the absolute and relative
  *    size of the freelist.
  *  - If compaction is needed, this algorithm determines by how many segments
- *    it would like to shrink the space (N). It will then attempts to move all
+ *    it would like to shrink the space (N). It will then attempt to move all
  *    live entries out of these segments so that they can be deallocated
  *    afterwards during sweeping.
  *  - The algorithm then simply selects the last N segments for evacuation, and
diff --git a/deps/v8/src/sandbox/external-pointer-table.cc b/deps/v8/src/sandbox/external-pointer-table.cc
index 50491f86793f75..1e66c17c3452f3 100644
--- a/deps/v8/src/sandbox/external-pointer-table.cc
+++ b/deps/v8/src/sandbox/external-pointer-table.cc
@@ -42,7 +42,7 @@ class SegmentsIterator {
   using const_iterator = typename std::set<Segment>::const_reverse_iterator;
 
  public:
-  SegmentsIterator() {}
+  SegmentsIterator() = default;
 
   void AddSegments(const std::set<Segment>& segments, Data data) {
     streams_.emplace_back(segments.rbegin(), segments.rend(), data);
@@ -126,7 +126,7 @@ uint32_t ExternalPointerTable::EvacuateAndSweepAndCompact(Space* space,
     segments_iter.AddSegments(from_space_segments, from_space_compaction);
 
     FreelistHead empty_freelist;
-    from_space->freelist_head_.store(empty_freelist, std::memory_order_release);
+    from_space->freelist_head_.store(empty_freelist, std::memory_order_relaxed);
 
     for (Address field : from_space->invalidated_fields_)
       space->invalidated_fields_.push_back(field);
@@ -176,6 +176,13 @@ uint32_t ExternalPointerTable::EvacuateAndSweepAndCompact(Space* space,
         Address handle_location =
             payload.ExtractEvacuationEntryHandleLocation();
 
+        // The evacuation entry may be invalidated by the Scavenger that has
+        // freed the object.
+        if (handle_location == kNullAddress) {
+          AddToFreelist(i);
+          continue;
+        }
+
         // The external pointer field may have been invalidated in the meantime
         // (for example if the host object has been in-place converted to a
         // different type of object). In that case, the field no longer
@@ -295,6 +302,40 @@ void ExternalPointerTable::ResolveEvacuationEntryDuringSweeping(
   }
 }
 
+void ExternalPointerTable::UpdateAllEvacuationEntries(
+    Space* space, std::function<Address(Address)> function) {
+  DCHECK(space->BelongsTo(this));
+  DCHECK(!space->is_internal_read_only_space());
+
+  if (!space->IsCompacting()) return;
+
+  // Lock the space. Technically this is not necessary since no other thread can
+  // allocate entries at this point, but some of the methods we call on the
+  // space assert that the lock is held.
+  base::MutexGuard guard(&space->mutex_);
+  // Same for the invalidated fields mutex.
+  base::MutexGuard invalidated_fields_guard(&space->invalidated_fields_mutex_);
+
+  const uint32_t start_of_evacuation_area =
+      space->start_of_evacuation_area_.load(std::memory_order_relaxed);
+
+  // Iterate until the start of evacuation area.
+  for (auto& segment : space->segments_) {
+    if (segment.first_entry() == start_of_evacuation_area) return;
+    for (uint32_t i = segment.first_entry(); i < segment.last_entry() + 1;
+         ++i) {
+      ExternalPointerTableEntry& entry = at(i);
+      ExternalPointerTableEntry::Payload payload = entry.GetRawPayload();
+      if (!payload.ContainsEvacuationEntry()) {
+        continue;
+      }
+      Address new_location =
+          function(payload.ExtractEvacuationEntryHandleLocation());
+      entry.MakeEvacuationEntry(new_location);
+    }
+  }
+}
+
 }  // namespace internal
 }  // namespace v8
 
diff --git a/deps/v8/src/sandbox/external-pointer-table.h b/deps/v8/src/sandbox/external-pointer-table.h
index 3d5b4a90f897cf..7de7d76fe44474 100644
--- a/deps/v8/src/sandbox/external-pointer-table.h
+++ b/deps/v8/src/sandbox/external-pointer-table.h
@@ -350,6 +350,10 @@ class V8_EXPORT_PRIVATE ExternalPointerTable
   uint32_t SweepAndCompact(Space* space, Counters* counters);
   uint32_t Sweep(Space* space, Counters* counters);
 
+  // Updates all evacuation entries with new handle locations. The function
+  // takes the old hanlde location and returns the new one.
+  void UpdateAllEvacuationEntries(Space*, std::function<Address(Address)>);
+
   inline bool Contains(Space* space, ExternalPointerHandle handle) const;
 
   // A resource outside of the V8 heap whose lifetime is tied to something
diff --git a/deps/v8/src/snapshot/code-serializer.cc b/deps/v8/src/snapshot/code-serializer.cc
index 0f4bea1f0ae477..04b71a59ca94e7 100644
--- a/deps/v8/src/snapshot/code-serializer.cc
+++ b/deps/v8/src/snapshot/code-serializer.cc
@@ -618,9 +618,8 @@ MaybeHandle<SharedFunctionInfo> CodeSerializer::FinishOffThreadDeserialize(
   if (background_merge_task &&
       background_merge_task->HasPendingForegroundWork()) {
     DCHECK_EQ(data.scripts.size(), 1);
-    Handle<Script> new_script = data.scripts[0];
-    result =
-        background_merge_task->CompleteMergeInForeground(isolate, new_script);
+    Handle<Script> script = data.scripts[0];
+    result = background_merge_task->CompleteMergeInForeground(isolate, script);
     DCHECK(Object::StrictEquals(Cast<Script>(result->script())->source(),
                                 *source));
     DCHECK(isolate->factory()->script_list()->Contains(
diff --git a/deps/v8/src/wasm/canonical-types.cc b/deps/v8/src/wasm/canonical-types.cc
index 0b7c6601cf29fd..5b8acb75e74e05 100644
--- a/deps/v8/src/wasm/canonical-types.cc
+++ b/deps/v8/src/wasm/canonical-types.cc
@@ -17,14 +17,25 @@ TypeCanonicalizer* GetTypeCanonicalizer() {
 
 TypeCanonicalizer::TypeCanonicalizer() { AddPredefinedArrayTypes(); }
 
-// For convenience, limit canonicalized type indices to Smi range.
-// We could squeeze out a few more bits if necessary by passing them
-// from compiled wrappers to runtime functions as Smi-tagged unsigned ints.
-// That would give us "uint31" range on 32-bit platforms, and allow
-// uint32_t (or even more) on 64-bit platforms. But we probably don't want
-// to store that many types in the TypeCanonicalizer anyway.
-static constexpr size_t kMaxCanonicalTypes = kSmiMaxValue;
+// Inside the TypeCanonicalizer, we use ValueType instances constructed
+// from canonical type indices, so we can't let them get bigger than what
+// we have storage space for. Code outside the TypeCanonicalizer already
+// supports up to Smi range for canonical type indices.
+// TODO(jkummerow): Raise this limit. Possible options:
+// - increase the size of ValueType::HeapTypeField, using currently-unused bits.
+// - change the encoding of ValueType: one bit says whether it's a ref type,
+//   the other bits then encode the index or the kind of non-ref type.
+// - refactor the TypeCanonicalizer's internals to no longer use ValueTypes
+//   and related infrastructure, and use a wider encoding of canonicalized
+//   type indices only here.
+// - wait for 32-bit platforms to no longer be relevant, and increase the
+//   size of ValueType to 64 bits.
+// None of this seems urgent, as we have no evidence of the current limit
+// being an actual limitation in practice.
+static constexpr size_t kMaxCanonicalTypes = kV8MaxWasmTypes;
+// We don't want any valid modules to fail canonicalization.
 static_assert(kMaxCanonicalTypes >= kV8MaxWasmTypes);
+// We want the invalid index to fail any range checks.
 static_assert(kInvalidCanonicalIndex > kMaxCanonicalTypes);
 
 void TypeCanonicalizer::CheckMaxCanonicalIndex() const {
@@ -215,6 +226,7 @@ ValueType TypeCanonicalizer::CanonicalizeValueType(
     const WasmModule* module, ValueType type,
     uint32_t recursive_group_start) const {
   if (!type.has_index()) return type;
+  static_assert(kMaxCanonicalTypes <= (1u << ValueType::kHeapTypeBits));
   return type.ref_index() >= recursive_group_start
              ? ValueType::CanonicalWithRelativeIndex(
                    type.kind(), type.ref_index() - recursive_group_start)
diff --git a/deps/v8/src/wasm/graph-builder-interface.cc b/deps/v8/src/wasm/graph-builder-interface.cc
index bc67cf0ecbe3bf..fbc035a29e5319 100644
--- a/deps/v8/src/wasm/graph-builder-interface.cc
+++ b/deps/v8/src/wasm/graph-builder-interface.cc
@@ -1206,8 +1206,7 @@ class WasmGraphBuildingInterface {
 
   void BrOnNonNull(FullDecoder* decoder, const Value& ref_object, Value* result,
                    uint32_t depth, bool /* drop_null_on_fallthrough */) {
-    result->node =
-        builder_->TypeGuard(ref_object.node, ref_object.type.AsNonNull());
+    result->node = ref_object.node;
     SsaEnv* false_env = ssa_env_;
     SsaEnv* true_env = Split(decoder->zone(), false_env);
     false_env->SetNotMerged();
@@ -1859,8 +1858,13 @@ class WasmGraphBuildingInterface {
         // and BrOnNull interacts with the values on the stack.
         // TODO(14034): The compiler shouldn't have to access the stack used by
         // the decoder ideally.
+        // Note: This TypeGuard doesn't add any new type information but we need
+        // a non-const Value that we can return to the decoder for
+        // value_on_branch. The clean solution would be to emit the TypeGuard
+        // with the branch-type in the effect edge of the branch and use
+        // value_on_branch->type as type there.
         SetAndTypeNode(value_on_branch,
-                       builder_->TypeGuard(object.node, value_on_branch->type));
+                       builder_->TypeGuard(object.node, object.type));
         return BrOnNull(decoder, object, br_depth, true, value_on_branch);
       case HeapType::kAny:
         // Any may never need a cast as it is either implicitly convertible or
diff --git a/deps/v8/src/wasm/value-type.h b/deps/v8/src/wasm/value-type.h
index e1dd287cac011e..eb69c8542e78e5 100644
--- a/deps/v8/src/wasm/value-type.h
+++ b/deps/v8/src/wasm/value-type.h
@@ -592,6 +592,7 @@ class ValueType {
 
   static constexpr ValueType FromIndex(ValueKind kind, uint32_t index) {
     DCHECK(kind == kRefNull || kind == kRef || kind == kRtt);
+    CHECK_LT(index, kV8MaxWasmTypes);
     return ValueType(KindField::encode(kind) | HeapTypeField::encode(index));
   }
 
diff --git a/deps/v8/test/cctest/heap/test-heap.cc b/deps/v8/test/cctest/heap/test-heap.cc
index fbac24efae6b6a..26a788f01844bc 100644
--- a/deps/v8/test/cctest/heap/test-heap.cc
+++ b/deps/v8/test/cctest/heap/test-heap.cc
@@ -1782,7 +1782,7 @@ void CompilationCacheRegeneration(bool retain_root_sfi, bool flush_root_sfi,
     DirectHandle<Script> script(Cast<Script>(lazy_sfi->script()), isolate);
     bool root_sfi_still_exists = false;
     Tagged<MaybeObject> maybe_root_sfi =
-        script->infos()->get(kFunctionLiteralIdTopLevel);
+        script->shared_function_infos()->get(kFunctionLiteralIdTopLevel);
     if (Tagged<HeapObject> sfi_or_undefined;
         maybe_root_sfi.GetHeapObject(&sfi_or_undefined)) {
       root_sfi_still_exists = !IsUndefined(sfi_or_undefined);
diff --git a/deps/v8/test/cctest/test-debug.cc b/deps/v8/test/cctest/test-debug.cc
index ab736c9b4d96d1..fd266706cd6e6e 100644
--- a/deps/v8/test/cctest/test-debug.cc
+++ b/deps/v8/test/cctest/test-debug.cc
@@ -3150,7 +3150,7 @@ class DebugScopingListener : public v8::debug::DebugDelegate {
 
     auto scopes = stack_traces->GetScopeIterator();
     CHECK_EQ(v8::debug::ScopeIterator::ScopeTypeWith, scopes->GetType());
-    CHECK_EQ(19, scopes->GetStartLocation().GetColumnNumber());
+    CHECK_EQ(20, scopes->GetStartLocation().GetColumnNumber());
     CHECK_EQ(31, scopes->GetEndLocation().GetColumnNumber());
 
     scopes->Advance();
diff --git a/deps/v8/test/cctest/test-serialize.cc b/deps/v8/test/cctest/test-serialize.cc
index 79db5964e2f724..b9d9f24211af8d 100644
--- a/deps/v8/test/cctest/test-serialize.cc
+++ b/deps/v8/test/cctest/test-serialize.cc
@@ -3323,10 +3323,9 @@ static void CodeSerializerMergeDeserializedScript(bool retain_toplevel_sfi) {
 
   Handle<HeapObject> retained_toplevel_sfi;
   if (retain_toplevel_sfi) {
-    retained_toplevel_sfi = handle(script->infos()
-                                       ->get(kFunctionLiteralIdTopLevel)
-                                       .GetHeapObjectAssumeWeak(),
-                                   isolate);
+    retained_toplevel_sfi = handle(
+        script->shared_function_infos()->get(0).GetHeapObjectAssumeWeak(),
+        isolate);
   }
 
   // GC twice in case incremental marking had already marked the bytecode array.
@@ -5772,16 +5771,15 @@ UNINITIALIZED_TEST(ClassFieldsWithBindings) {
   FreeCurrentEmbeddedBlob();
 }
 
-void CheckInfosAreWeak(Tagged<WeakFixedArray> sfis, Isolate* isolate) {
+void CheckSFIsAreWeak(Tagged<WeakFixedArray> sfis, Isolate* isolate) {
   CHECK_GT(sfis->length(), 0);
   int no_of_weak = 0;
   for (int i = 0; i < sfis->length(); ++i) {
     Tagged<MaybeObject> maybe_object = sfis->get(i);
     Tagged<HeapObject> heap_object;
-    CHECK(!maybe_object.GetHeapObjectIfWeak(isolate, &heap_object) ||
+    CHECK(maybe_object.IsWeakOrCleared() ||
           (maybe_object.GetHeapObjectIfStrong(&heap_object) &&
-           IsUndefined(heap_object, isolate)) ||
-          Is<SharedFunctionInfo>(heap_object) || Is<ScopeInfo>(heap_object));
+           IsUndefined(heap_object, isolate)));
     if (maybe_object.IsWeak()) {
       ++no_of_weak;
     }
@@ -5833,10 +5831,10 @@ UNINITIALIZED_TEST(WeakArraySerializationInSnapshot) {
     DirectHandle<JSFunction> function =
         Cast<JSFunction>(v8::Utils::OpenDirectHandle(*x));
 
-    // Verify that the pointers in infos are weak.
+    // Verify that the pointers in shared_function_infos are weak.
     Tagged<WeakFixedArray> sfis =
-        Cast<Script>(function->shared()->script())->infos();
-    CheckInfosAreWeak(sfis, reinterpret_cast<i::Isolate*>(isolate));
+        Cast<Script>(function->shared()->script())->shared_function_infos();
+    CheckSFIsAreWeak(sfis, reinterpret_cast<i::Isolate*>(isolate));
   }
   isolate->Dispose();
   delete[] blob.data;
@@ -5866,9 +5864,10 @@ TEST(WeakArraySerializationInCodeCache) {
       CompileScript(isolate, src, script_details, cache,
                     v8::ScriptCompiler::kConsumeCodeCache);
 
-  // Verify that the pointers in infos are weak.
-  Tagged<WeakFixedArray> sfis = Cast<Script>(copy->script())->infos();
-  CheckInfosAreWeak(sfis, isolate);
+  // Verify that the pointers in shared_function_infos are weak.
+  Tagged<WeakFixedArray> sfis =
+      Cast<Script>(copy->script())->shared_function_infos();
+  CheckSFIsAreWeak(sfis, isolate);
 
   delete cache;
 }
diff --git a/deps/v8/test/cctest/wasm/wasm-run-utils.cc b/deps/v8/test/cctest/wasm/wasm-run-utils.cc
index 15e8106bae8bc7..c4d54e46982229 100644
--- a/deps/v8/test/cctest/wasm/wasm-run-utils.cc
+++ b/deps/v8/test/cctest/wasm/wasm-run-utils.cc
@@ -434,7 +434,8 @@ Handle<WasmInstanceObject> TestingModuleBuilder::InitInstanceObject() {
   // Asm.js modules are expected to have "normal" scripts, not Wasm scripts.
   if (is_asmjs_module(native_module->module())) {
     script->set_type(Script::Type::kNormal);
-    script->set_infos(ReadOnlyRoots{isolate_}.empty_weak_fixed_array());
+    script->set_shared_function_infos(
+        ReadOnlyRoots{isolate_}.empty_weak_fixed_array());
   }
 
   DirectHandle<WasmModuleObject> module_object =
diff --git a/deps/v8/test/mjsunit/regress-352402518.js b/deps/v8/test/mjsunit/harmony/modules-async-error-parent-entry.mjs
similarity index 71%
rename from deps/v8/test/mjsunit/regress-352402518.js
rename to deps/v8/test/mjsunit/harmony/modules-async-error-parent-entry.mjs
index a712fbc4cfcd88..055cba4d216ea4 100644
--- a/deps/v8/test/mjsunit/regress-352402518.js
+++ b/deps/v8/test/mjsunit/harmony/modules-async-error-parent-entry.mjs
@@ -2,6 +2,4 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --reuse-scope-infos
-
-with({}){function h(){}}
+assertThrowsAsync(import('./modules-skip-async-error-parent.mjs'));
diff --git a/deps/v8/test/mjsunit/harmony/modules-import-16.mjs b/deps/v8/test/mjsunit/harmony/modules-import-16.mjs
index cf1ed9723c04cf..92f87632604f80 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.toString()))"
+    " ran = true;} ).catch(err => %AbortJS(err))"
 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.toString()))"
+    " ran = true;} ).catch(err => %AbortJS(err))"
 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.toString())))"
+    " ran = true;} ).catch(err => %AbortJS(err)))"
 func = new Function(body);
 func();
 
diff --git a/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-dynamic.mjs b/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-dynamic.mjs
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-static1.mjs b/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-static1.mjs
new file mode 100644
index 00000000000000..a2e1a1169fd93d
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-static1.mjs
@@ -0,0 +1,6 @@
+// Copyright 2024 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.
+
+await import('./modules-skip-async-error-parent-dynamic.mjs');
+import('./modules-skip-async-error-parent.mjs').catch(() => {});
diff --git a/deps/v8/test/mjsunit/regress-class-initializer-eval.js b/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-static2.mjs
similarity index 57%
rename from deps/v8/test/mjsunit/regress-class-initializer-eval.js
rename to deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-static2.mjs
index 83cfc1007627d9..ca7f2772693ed2 100644
--- a/deps/v8/test/mjsunit/regress-class-initializer-eval.js
+++ b/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent-static2.mjs
@@ -2,11 +2,5 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax
-
-let c = class {
-  x = eval("");
-};
-new c;
-%ForceFlush(%GetInitializerFunction(c));
-new c;
+import('./modules-skip-async-error-parent-static1.mjs');
+await import('./modules-skip-async-error-parent-dynamic.mjs');
diff --git a/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent.mjs b/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent.mjs
new file mode 100644
index 00000000000000..7fdfe7f6c2f5f9
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/modules-skip-async-error-parent.mjs
@@ -0,0 +1,10 @@
+// Copyright 2024 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.
+
+import './modules-skip-async-error-parent-static1.mjs';
+import './modules-skip-async-error-parent-static2.mjs';
+
+await {};
+
+throw new Error('aaa');
diff --git a/deps/v8/test/mjsunit/maglev/regress-362784006.js b/deps/v8/test/mjsunit/maglev/regress-362784006.js
new file mode 100644
index 00000000000000..56ea6a02058889
--- /dev/null
+++ b/deps/v8/test/mjsunit/maglev/regress-362784006.js
@@ -0,0 +1,19 @@
+// Copyright 2024 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.
+//
+// Flags: --invocation-count-for-maglev-osr=1 --invocation-count-for-maglev=1
+// Flags: --minimum-invocations-after-ic-update=1 --deopt-every-n-times=250
+// Flags: --single-threaded --verify-heap
+
+// The flags ensure that we verify the heap just before we deopt the first
+// Maglev OSR synchronously.
+// --deopt-every-n-times > 0 forces MaterializeHeapObjects to call GC.
+
+let v0 = 1;
+let vn = 1000;
+for (let i1 = v0; i1 <= vn; i1 += v0) {
+    v0 = v0 && i1;
+    let v8 = "";
+    [v8,] = v8;
+}
diff --git a/deps/v8/test/mjsunit/maglev/regress-363983041.js b/deps/v8/test/mjsunit/maglev/regress-363983041.js
new file mode 100644
index 00000000000000..8f5d2b6d59e1d2
--- /dev/null
+++ b/deps/v8/test/mjsunit/maglev/regress-363983041.js
@@ -0,0 +1,14 @@
+// Copyright 2024 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.
+//
+// Flags: --allow-natives-syntax
+
+function foo(x) {
+  return new x();
+}
+
+%PrepareFunctionForOptimization(foo);
+foo(Object);
+%OptimizeFunctionOnNextCall(foo);
+assertThrows(foo, TypeError);
diff --git a/deps/v8/test/mjsunit/regress-352414652.js b/deps/v8/test/mjsunit/regress-352414652.js
deleted file mode 100644
index d6fb72da9153ca..00000000000000
--- a/deps/v8/test/mjsunit/regress-352414652.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2024 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.
-
-// Flags: --allow-natives-syntax --reuse-scope-infos
-
-function __f_11() {
-  for (let i =  __f_26 = function() { return i }; i < 1; ++i) {
-  }
-}
-__f_11();
-  %ForceFlush(__f_11);
-      __f_11();
diff --git a/deps/v8/test/mjsunit/regress-352739458.js b/deps/v8/test/mjsunit/regress-352739458.js
deleted file mode 100644
index 6e265957e10c86..00000000000000
--- a/deps/v8/test/mjsunit/regress-352739458.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2024 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.
-
-// Flags: --reuse-scope-infos --allow-natives-syntax
-
-Realm.eval(Realm.current(), `function f(s) {
-  return eval(s);
-}
-let g = f("0,function(y) { return ()=>{ eval() } }");
-let i = g(1);
-%ForceFlush(g);
-print(g(2));`);
diff --git a/deps/v8/test/mjsunit/regress-353561476.js b/deps/v8/test/mjsunit/regress-353561476.js
deleted file mode 100644
index 04c78681bebc4b..00000000000000
--- a/deps/v8/test/mjsunit/regress-353561476.js
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2024 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.
-
-// Flags: --reuse-scope-infos --expose-gc --stress-flush-code
-
-  function executeCode(code) {
-    if (typeof code === 'function') return code();
-  }
-  assertThrows = function assertThrows(code) {
-      executeCode(code);
-  };
-function __getRandomProperty() {
-}
-(function () {
-  __callGC = function () {
-      gc();
-  };
-})();
-  var __v_25 = [];
-function __f_10(__v_29, __v_30) {
-    var __v_31 = Realm.create();
-  try {
-    assertThrows(function () {
-        Realm.eval(__v_31, __v_29[
-        __v_29.length - 1]);
-    }, Realm. __v_30);
-  } catch (e) {}
-    delete __v_25[__getRandomProperty()], __callGC();
-}
-  var __v_28 = [{
-    scripts: ['eval("function NaN() {}");'],
-  }, {
-    scripts: [`
-      `.replace()],
-  }];
-  __v_28.forEach(function (__v_33) {
-      __f_10(__v_33.scripts, __v_33.expectedError);
-      __f_10(__v_33.scripts, __v_33.expectedError);
-  });
diff --git a/deps/v8/test/mjsunit/regress-4530868594868224.js b/deps/v8/test/mjsunit/regress-4530868594868224.js
deleted file mode 100644
index ddd1363a9a12f9..00000000000000
--- a/deps/v8/test/mjsunit/regress-4530868594868224.js
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2024 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.
-
-// Flags: --fuzzing
-
-const __v_2 = [{
-  body: function () {
-  },
-  body: function () {
-  }
-}, {
-  body: function () {
-    const __v_11 = {
-    };
-  }
-}];
-  var __v_30 = [{
-    body: function () {
-        var __v_140 = async () => __v_147 = async () => __v_173 = 'str';
-    }
-  }];
diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-361862737.js b/deps/v8/test/mjsunit/regress/wasm/regress-361862737.js
new file mode 100644
index 00000000000000..d6db4a029056c7
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/wasm/regress-361862737.js
@@ -0,0 +1,31 @@
+// Copyright 2024 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.
+
+d8.file.execute('test/mjsunit/wasm/wasm-module-builder.js');
+
+// This test case reproduces a case in Turbofan where the WasmTyper was
+// flip-flopping between two different states never reaching a fix point.
+const builder = new WasmModuleBuilder();
+let $array1 = builder.addArray(kWasmI16, true, kNoSuperType, true);
+let loopSig = builder.addType(makeSig([kWasmFuncRef], []));
+let funcEndless = builder.addFunction('funcEndless', kSig_v_v).exportFunc()
+  .addLocals(kWasmFuncRef, 1)  // $var0
+  .addBody([
+    kExprRefNull, kFuncRefCode,
+    kExprLoop, loopSig,
+      kExprLocalTee, 0,  // $var0
+      kExprBrOnNonNull, 0,
+      kExprLocalGet, 0,  // $var0
+      kExprRefAsNonNull,
+      kExprBrOnNonNull, 0,
+    kExprEnd,
+
+    // Use something with a gc prefix to enable the WasmTyper.
+    kExprRefNull, $array1,
+    kGCPrefix, kExprArrayLen,
+    kExprDrop,
+  ]);
+
+const instance = builder.instantiate();
+assertTraps(kTrapNullDereference, () => instance.exports.funcEndless(null));
diff --git a/deps/v8/test/mjsunit/test-scopeinfo-reuse-eval.js b/deps/v8/test/mjsunit/test-scopeinfo-reuse-eval.js
deleted file mode 100644
index f20dfa7cace12b..00000000000000
--- a/deps/v8/test/mjsunit/test-scopeinfo-reuse-eval.js
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2024 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.
-
-// Flags: --allow-natives-syntax
-
-let x = 1;
-let f = eval("let y = 20; (function() { y; return function() { return x } })");
-// Keep g in f alive to keep its outer scope chain alive.
-let g = f();
-// Flush and recompile f, which will try to reuse the scope info chain attached
-// to g. Verify that we don't get a clash between the eval scope and the script
-// scope.
-%ForceFlush(f);
-f();
diff --git a/deps/v8/test/unittests/api/deserialize-unittest.cc b/deps/v8/test/unittests/api/deserialize-unittest.cc
index fc4d3850ce6513..113727c2332e41 100644
--- a/deps/v8/test/unittests/api/deserialize-unittest.cc
+++ b/deps/v8/test/unittests/api/deserialize-unittest.cc
@@ -326,16 +326,14 @@ class MergeDeserializedCodeTest : public DeserializeTest {
   // The source code used in these tests.
   static constexpr char kSourceCode[] = R"(
     // Looks like an IIFE but isn't, to get eagerly parsed:
-    { let captured = 10;
-      var eager = (function () {
-        // Actual IIFE, also eagerly parsed:
-        return (function iife() {
-          return captured, 42;
-        })();
-      });
-      // Lazily parsed:
-      var lazy = function () { return eager(); };
-    }
+    var eager = (function () {
+      // Actual IIFE, also eagerly parsed:
+      return (function iife() {
+        return 42;
+      })();
+    });
+    // Lazily parsed:
+    var lazy = function () { return eager(); };
   )";
 
   // Objects from the Script's object graph whose lifetimes and connectedness
@@ -415,7 +413,7 @@ class MergeDeserializedCodeTest : public DeserializeTest {
                WeakOrSmi(toplevel_sfi->feedback_metadata()));
     i::Tagged<i::Script> script = i::Cast<i::Script>(toplevel_sfi->script());
     array->set(kScript, WeakOrSmi(script));
-    i::Tagged<i::WeakFixedArray> sfis = script->infos();
+    i::Tagged<i::WeakFixedArray> sfis = script->shared_function_infos();
     CHECK_EQ(sfis->length(), 4);
     CHECK_EQ(sfis->get(0), WeakOrSmi(toplevel_sfi));
     i::Tagged<i::SharedFunctionInfo> eager =
diff --git a/deps/v8/test/unittests/heap/local-factory-unittest.cc b/deps/v8/test/unittests/heap/local-factory-unittest.cc
index 1c3c4e90268a85..ae953fd77bc488 100644
--- a/deps/v8/test/unittests/heap/local-factory-unittest.cc
+++ b/deps/v8/test/unittests/heap/local-factory-unittest.cc
@@ -85,13 +85,12 @@ class LocalFactoryTest : public TestWithIsolateAndZone {
     parser.ParseOnBackground(local_isolate(), parse_info(), script_, 0, 0,
                              kFunctionLiteralIdTopLevel);
 
-    DeclarationScope::AllocateScopeInfos(parse_info(), script_,
-                                         local_isolate());
+    DeclarationScope::AllocateScopeInfos(parse_info(), local_isolate());
 
     // Create the SFI list on the script so that SFI SetScript works.
     DirectHandle<WeakFixedArray> infos = local_factory()->NewWeakFixedArray(
-        parse_info()->max_info_id() + 1, AllocationType::kOld);
-    script_->set_infos(*infos);
+        parse_info()->max_function_literal_id() + 1, AllocationType::kOld);
+    script_->set_shared_function_infos(*infos);
 
     return parse_info()->literal();
   }
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/CallLookupSlot.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/CallLookupSlot.golden
index b0a2834195d892..4c1dcc766b6b80 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/CallLookupSlot.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/CallLookupSlot.golden
@@ -29,7 +29,7 @@ bytecodes: [
                 B(Star3),
                 B(LdaZero),
                 B(Star7),
-                B(LdaSmi), I8(3),
+                B(LdaSmi), I8(30),
                 B(Star8),
                 B(LdaSmi), I8(52),
                 B(Star9),
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/Eval.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/Eval.golden
index abd6f12cf45fbf..7f20bbf1fae258 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/Eval.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/Eval.golden
@@ -27,7 +27,7 @@ bytecodes: [
                 B(Star3),
                 B(LdaZero),
                 B(Star7),
-                B(LdaSmi), I8(2),
+                B(LdaSmi), I8(30),
                 B(Star8),
                 B(LdaSmi), I8(41),
                 B(Star9),
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden
index 104532fb0e2906..0a7882b68a0b86 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden
@@ -152,7 +152,7 @@ bytecodes: [
                 B(Star13),
                 B(LdaZero),
                 B(Star), R(17),
-                B(LdaSmi), I8(2),
+                B(LdaSmi), I8(37),
                 B(Star), R(18),
                 B(LdaSmi), I8(41),
                 B(Star), R(19),
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/LookupSlot.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/LookupSlot.golden
index cd8c87619ef51e..c41f23c7266927 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/LookupSlot.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/LookupSlot.golden
@@ -28,7 +28,7 @@ bytecodes: [
                 B(Star3),
                 B(LdaZero),
                 B(Star7),
-                B(LdaSmi), I8(2),
+                B(LdaSmi), I8(10),
                 B(Star8),
                 B(LdaSmi), I8(14),
                 B(Star9),
@@ -72,7 +72,7 @@ bytecodes: [
                 B(Star3),
                 B(LdaZero),
                 B(Star7),
-                B(LdaSmi), I8(2),
+                B(LdaSmi), I8(10),
                 B(Star8),
                 B(LdaSmi), I8(14),
                 B(Star9),
@@ -119,7 +119,7 @@ bytecodes: [
                 B(Star3),
                 B(LdaZero),
                 B(Star7),
-                B(LdaSmi), I8(2),
+                B(LdaSmi), I8(10),
                 B(Star8),
                 B(LdaSmi), I8(29),
                 B(Star9),
@@ -167,7 +167,7 @@ bytecodes: [
                 B(Star3),
                 B(LdaZero),
                 B(Star7),
-                B(LdaSmi), I8(3),
+                B(LdaSmi), I8(38),
                 B(Star8),
                 B(LdaSmi), I8(44),
                 B(Star9),
@@ -216,7 +216,7 @@ bytecodes: [
                 B(Star3),
                 B(LdaZero),
                 B(Star7),
-                B(LdaSmi), I8(3),
+                B(LdaSmi), I8(34),
                 B(Star8),
                 B(LdaSmi), I8(40),
                 B(Star9),
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden
index 4a470d044ce9ad..2348930b653eaa 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden
@@ -98,7 +98,7 @@ bytecodes: [
                 B(Star8),
                 B(LdaZero),
                 B(Star12),
-                B(LdaSmi), I8(2),
+                B(LdaSmi), I8(31),
                 B(Star13),
                 B(LdaSmi), I8(48),
                 B(Star14),
diff --git a/deps/v8/test/unittests/parser/parsing-unittest.cc b/deps/v8/test/unittests/parser/parsing-unittest.cc
index d7026f67cd654e..e549092beb8a51 100644
--- a/deps/v8/test/unittests/parser/parsing-unittest.cc
+++ b/deps/v8/test/unittests/parser/parsing-unittest.cc
@@ -1431,7 +1431,7 @@ TEST_F(ParsingTest, ScopeUsesArgumentsSuperThis) {
       flags.set_allow_lazy_parsing(false);
       i::ParseInfo info(isolate, flags, &compile_state, &reusable_state);
       CHECK_PARSE_PROGRAM(&info, script, isolate);
-      i::DeclarationScope::AllocateScopeInfos(&info, script, isolate);
+      i::DeclarationScope::AllocateScopeInfos(&info, isolate);
       CHECK_NOT_NULL(info.literal());
 
       i::DeclarationScope* script_scope = info.literal()->scope();
@@ -1507,24 +1507,26 @@ TEST_F(ParsingTest, ScopePositions) {
   };
 
   const SourceData source_data[] = {
-      {"  with ({}", "){ block; }", " more;", i::WITH_SCOPE,
+      {"  with ({}) ", "{ block; }", " more;", i::WITH_SCOPE,
        i::LanguageMode::kSloppy},
-      {"  with ({}", "){ block; }", "; more;", i::WITH_SCOPE,
+      {"  with ({}) ", "{ block; }", "; more;", i::WITH_SCOPE,
        i::LanguageMode::kSloppy},
-      {"  with ({}",
-       "){\n"
+      {"  with ({}) ",
+       "{\n"
        "    block;\n"
        "  }",
        "\n"
        "  more;",
        i::WITH_SCOPE, i::LanguageMode::kSloppy},
-      {"  with ({}", ")statement;", " more;", i::WITH_SCOPE,
+      {"  with ({}) ", "statement;", " more;", i::WITH_SCOPE,
        i::LanguageMode::kSloppy},
-      {"  with ({}", ")statement",
+      {"  with ({}) ", "statement",
        "\n"
        "  more;",
        i::WITH_SCOPE, i::LanguageMode::kSloppy},
-      {"  with ({}", ")statement;",
+      {"  with ({})\n"
+       "    ",
+       "statement;",
        "\n"
        "  more;",
        i::WITH_SCOPE, i::LanguageMode::kSloppy},
@@ -1575,25 +1577,25 @@ TEST_F(ParsingTest, ScopePositions) {
        "  (function fun",
        "(a,b) { infunction; }", ")();", i::FUNCTION_SCOPE,
        i::LanguageMode::kSloppy},
-      {"  for (", "let x = 1 ; x < 10; ++ x) { block; }", " more;",
+      {"  for ", "(let x = 1 ; x < 10; ++ x) { block; }", " more;",
        i::BLOCK_SCOPE, i::LanguageMode::kStrict},
-      {"  for (", "let x = 1 ; x < 10; ++ x) { block; }", "; more;",
+      {"  for ", "(let x = 1 ; x < 10; ++ x) { block; }", "; more;",
        i::BLOCK_SCOPE, i::LanguageMode::kStrict},
-      {"  for (",
-       "let x = 1 ; x < 10; ++ x) {\n"
+      {"  for ",
+       "(let x = 1 ; x < 10; ++ x) {\n"
        "    block;\n"
        "  }",
        "\n"
        "  more;",
        i::BLOCK_SCOPE, i::LanguageMode::kStrict},
-      {"  for (", "let x = 1 ; x < 10; ++ x) statement;", " more;",
+      {"  for ", "(let x = 1 ; x < 10; ++ x) statement;", " more;",
        i::BLOCK_SCOPE, i::LanguageMode::kStrict},
-      {"  for (", "let x = 1 ; x < 10; ++ x) statement",
+      {"  for ", "(let x = 1 ; x < 10; ++ x) statement",
        "\n"
        "  more;",
        i::BLOCK_SCOPE, i::LanguageMode::kStrict},
-      {"  for (",
-       "let x = 1 ; x < 10; ++ x)\n"
+      {"  for ",
+       "(let x = 1 ; x < 10; ++ x)\n"
        "    statement;",
        "\n"
        "  more;",
@@ -12306,7 +12308,7 @@ TEST_F(ParsingTest, LexicalLoopVariable) {
     i::ParseInfo info(isolate, flags, &compile_state, &reusable_state);
     CHECK_PARSE_PROGRAM(&info, script, isolate);
 
-    i::DeclarationScope::AllocateScopeInfos(&info, script, isolate);
+    i::DeclarationScope::AllocateScopeInfos(&info, isolate);
     CHECK_NOT_NULL(info.literal());
 
     i::DeclarationScope* script_scope = info.literal()->scope();
diff --git a/deps/v8/test/unittests/test-helpers.cc b/deps/v8/test/unittests/test-helpers.cc
index d2c80eaf6b89fc..24ccdfd6805e5a 100644
--- a/deps/v8/test/unittests/test-helpers.cc
+++ b/deps/v8/test/unittests/test-helpers.cc
@@ -35,7 +35,7 @@ Handle<SharedFunctionInfo> CreateSharedFunctionInfo(
                                     .ToHandleChecked();
   DirectHandle<Script> script = isolate->factory()->NewScript(source);
   DirectHandle<WeakFixedArray> infos = isolate->factory()->NewWeakFixedArray(3);
-  script->set_infos(*infos);
+  script->set_shared_function_infos(*infos);
   Handle<SharedFunctionInfo> shared =
       isolate->factory()->NewSharedFunctionInfoForBuiltin(
           isolate->factory()->NewStringFromAsciiChecked("f"),