diff --git a/common.gypi b/common.gypi
index c56785cbadfa2d..04852d81103ef8 100644
--- a/common.gypi
+++ b/common.gypi
@@ -36,7 +36,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.24',
+    'v8_embedder_string': '-node.25',
 
     ##### V8 defaults for Node.js #####
 
diff --git a/deps/v8/src/api/api.cc b/deps/v8/src/api/api.cc
index a06394e6c1cd09..d10da486e9c4df 100644
--- a/deps/v8/src/api/api.cc
+++ b/deps/v8/src/api/api.cc
@@ -2861,6 +2861,7 @@ MaybeLocal<Function> ScriptCompiler::CompileFunctionInternal(
         i_isolate, source->resource_name, source->resource_line_offset,
         source->resource_column_offset, source->source_map_url,
         source->host_defined_options, source->resource_options);
+    script_details.wrapped_arguments = arguments_list;
 
     std::unique_ptr<i::AlignedCachedData> cached_data;
     if (options == kConsumeCodeCache) {
@@ -2873,8 +2874,8 @@ MaybeLocal<Function> ScriptCompiler::CompileFunctionInternal(
     i::Handle<i::JSFunction> scoped_result;
     has_pending_exception =
         !i::Compiler::GetWrappedFunction(
-             Utils::OpenHandle(*source->source_string), arguments_list, context,
-             script_details, cached_data.get(), options, no_cache_reason)
+             Utils::OpenHandle(*source->source_string), context, script_details,
+             cached_data.get(), options, no_cache_reason)
              .ToHandle(&scoped_result);
     if (options == kConsumeCodeCache) {
       source->cached_data->rejected = cached_data->rejected();
diff --git a/deps/v8/src/codegen/compilation-cache.cc b/deps/v8/src/codegen/compilation-cache.cc
index 72b36071b82406..6f6eabfc1342ae 100644
--- a/deps/v8/src/codegen/compilation-cache.cc
+++ b/deps/v8/src/codegen/compilation-cache.cc
@@ -190,8 +190,8 @@ void CompilationCacheScript::Put(Handle<String> source,
                                  Handle<SharedFunctionInfo> function_info) {
   HandleScope scope(isolate());
   Handle<CompilationCacheTable> table = GetTable();
-  table_ = *CompilationCacheTable::PutScript(table, source, function_info,
-                                             isolate());
+  table_ = *CompilationCacheTable::PutScript(table, source, kNullMaybeHandle,
+                                             function_info, isolate());
 }
 
 InfoCellPair CompilationCacheEval::Lookup(Handle<String> source,
diff --git a/deps/v8/src/codegen/compiler.cc b/deps/v8/src/codegen/compiler.cc
index 31c5acceebc4f1..840b9f77f6d333 100644
--- a/deps/v8/src/codegen/compiler.cc
+++ b/deps/v8/src/codegen/compiler.cc
@@ -3255,14 +3255,13 @@ struct ScriptCompileTimerScope {
   }
 };
 
-Handle<Script> NewScript(
-    Isolate* isolate, ParseInfo* parse_info, Handle<String> source,
-    ScriptDetails script_details, NativesFlag natives,
-    MaybeHandle<FixedArray> maybe_wrapped_arguments = kNullMaybeHandle) {
+Handle<Script> NewScript(Isolate* isolate, ParseInfo* parse_info,
+                         Handle<String> source, ScriptDetails script_details,
+                         NativesFlag natives) {
   // Create a script object describing the script to be compiled.
-  Handle<Script> script =
-      parse_info->CreateScript(isolate, source, maybe_wrapped_arguments,
-                               script_details.origin_options, natives);
+  Handle<Script> script = parse_info->CreateScript(
+      isolate, source, script_details.wrapped_arguments,
+      script_details.origin_options, natives);
   DisallowGarbageCollection no_gc;
   SetScriptFieldsFromDetails(isolate, *script, script_details, &no_gc);
   LOG(isolate, ScriptDetails(*script));
@@ -3639,9 +3638,8 @@ Compiler::GetSharedFunctionInfoForScriptWithCompileHints(
 
 // static
 MaybeHandle<JSFunction> Compiler::GetWrappedFunction(
-    Handle<String> source, Handle<FixedArray> arguments,
-    Handle<Context> context, const ScriptDetails& script_details,
-    AlignedCachedData* cached_data,
+    Handle<String> source, Handle<Context> context,
+    const ScriptDetails& script_details, AlignedCachedData* cached_data,
     v8::ScriptCompiler::CompileOptions compile_options,
     v8::ScriptCompiler::NoCacheReason no_cache_reason) {
   Isolate* isolate = context->GetIsolate();
@@ -3649,16 +3647,28 @@ MaybeHandle<JSFunction> Compiler::GetWrappedFunction(
 
   if (compile_options == ScriptCompiler::kConsumeCodeCache) {
     DCHECK(cached_data);
+    DCHECK_EQ(script_details.repl_mode, REPLMode::kNo);
   } else {
     DCHECK_NULL(cached_data);
   }
 
   LanguageMode language_mode = construct_language_mode(v8_flags.use_strict);
-
+  DCHECK(!script_details.wrapped_arguments.is_null());
   MaybeHandle<SharedFunctionInfo> maybe_result;
+  Handle<SharedFunctionInfo> result;
+  Handle<Script> script;
+  IsCompiledScope is_compiled_scope;
   bool can_consume_code_cache =
       compile_options == ScriptCompiler::kConsumeCodeCache;
-  if (can_consume_code_cache) {
+  CompilationCache* compilation_cache = isolate->compilation_cache();
+  // First check per-isolate compilation cache.
+  CompilationCacheScript::LookupResult lookup_result =
+      compilation_cache->LookupScript(source, script_details, language_mode);
+  maybe_result = lookup_result.toplevel_sfi();
+  if (maybe_result.ToHandle(&result)) {
+    is_compiled_scope = result->is_compiled_scope(isolate);
+    compile_timer.set_hit_isolate_cache();
+  } else if (can_consume_code_cache) {
     compile_timer.set_consuming_code_cache();
     // Then check cached code provided by embedder.
     NestedTimedHistogramScope timer(isolate->counters()->compile_deserialize());
@@ -3667,16 +3677,22 @@ MaybeHandle<JSFunction> Compiler::GetWrappedFunction(
                  "V8.CompileDeserialize");
     maybe_result = CodeSerializer::Deserialize(isolate, cached_data, source,
                                                script_details.origin_options);
-    if (maybe_result.is_null()) {
+    bool consuming_code_cache_succeeded = false;
+    if (maybe_result.ToHandle(&result)) {
+      is_compiled_scope = result->is_compiled_scope(isolate);
+      if (is_compiled_scope.is_compiled()) {
+        consuming_code_cache_succeeded = true;
+        // Promote to per-isolate compilation cache.
+        compilation_cache->PutScript(source, language_mode, result);
+      }
+    }
+    if (!consuming_code_cache_succeeded) {
       // Deserializer failed. Fall through to compile.
       compile_timer.set_consuming_code_cache_failed();
     }
   }
 
-  Handle<SharedFunctionInfo> wrapped;
-  Handle<Script> script;
-  IsCompiledScope is_compiled_scope;
-  if (!maybe_result.ToHandle(&wrapped)) {
+  if (maybe_result.is_null()) {
     UnoptimizedCompileFlags flags = UnoptimizedCompileFlags::ForToplevelCompile(
         isolate, true, language_mode, script_details.repl_mode,
         ScriptType::kClassic, v8_flags.lazy);
@@ -3696,9 +3712,8 @@ MaybeHandle<JSFunction> Compiler::GetWrappedFunction(
     if (!context->IsNativeContext()) {
       maybe_outer_scope_info = handle(context->scope_info(), isolate);
     }
-
     script = NewScript(isolate, &parse_info, source, script_details,
-                       NOT_NATIVES_CODE, arguments);
+                       NOT_NATIVES_CODE);
 
     Handle<SharedFunctionInfo> top_level;
     maybe_result = v8::internal::CompileToplevel(&parse_info, script,
@@ -3711,18 +3726,23 @@ MaybeHandle<JSFunction> Compiler::GetWrappedFunction(
     for (SharedFunctionInfo info = infos.Next(); !info.is_null();
          info = infos.Next()) {
       if (info.is_wrapped()) {
-        wrapped = Handle<SharedFunctionInfo>(info, isolate);
+        result = Handle<SharedFunctionInfo>(info, isolate);
         break;
       }
     }
-    DCHECK(!wrapped.is_null());
-  } else {
-    is_compiled_scope = wrapped->is_compiled_scope(isolate);
-    script = Handle<Script>(Script::cast(wrapped->script()), isolate);
+    DCHECK(!result.is_null());
+
+    is_compiled_scope = result->is_compiled_scope(isolate);
+    script = Handle<Script>(Script::cast(result->script()), isolate);
+    // Add the result to the isolate cache if there's no context extension.
+    if (maybe_outer_scope_info.is_null()) {
+      compilation_cache->PutScript(source, language_mode, result);
+    }
   }
+
   DCHECK(is_compiled_scope.is_compiled());
 
-  return Factory::JSFunctionBuilder{isolate, wrapped, context}
+  return Factory::JSFunctionBuilder{isolate, result, context}
       .set_allocation_type(AllocationType::kYoung)
       .Build();
 }
diff --git a/deps/v8/src/codegen/compiler.h b/deps/v8/src/codegen/compiler.h
index 67c8c145f0fb65..c14842318a6e15 100644
--- a/deps/v8/src/codegen/compiler.h
+++ b/deps/v8/src/codegen/compiler.h
@@ -153,9 +153,8 @@ class V8_EXPORT_PRIVATE Compiler : public AllStatic {
   // Create a function that results from wrapping |source| in a function,
   // with |arguments| being a list of parameters for that function.
   V8_WARN_UNUSED_RESULT static MaybeHandle<JSFunction> GetWrappedFunction(
-      Handle<String> source, Handle<FixedArray> arguments,
-      Handle<Context> context, const ScriptDetails& script_details,
-      AlignedCachedData* cached_data,
+      Handle<String> source, Handle<Context> context,
+      const ScriptDetails& script_details, AlignedCachedData* cached_data,
       v8::ScriptCompiler::CompileOptions compile_options,
       v8::ScriptCompiler::NoCacheReason no_cache_reason);
 
diff --git a/deps/v8/src/codegen/script-details.h b/deps/v8/src/codegen/script-details.h
index 5317ae989e1fb7..dbd72d603c1c9e 100644
--- a/deps/v8/src/codegen/script-details.h
+++ b/deps/v8/src/codegen/script-details.h
@@ -30,6 +30,7 @@ struct ScriptDetails {
   MaybeHandle<Object> name_obj;
   MaybeHandle<Object> source_map_url;
   MaybeHandle<Object> host_defined_options;
+  MaybeHandle<FixedArray> wrapped_arguments;
   REPLMode repl_mode;
   const ScriptOriginOptions origin_options;
 };
diff --git a/deps/v8/src/objects/compilation-cache-table-inl.h b/deps/v8/src/objects/compilation-cache-table-inl.h
index 831cc474fe6493..b4e6c76d4c9dae 100644
--- a/deps/v8/src/objects/compilation-cache-table-inl.h
+++ b/deps/v8/src/objects/compilation-cache-table-inl.h
@@ -67,10 +67,12 @@ class ScriptCacheKey : public HashTableKey {
   ScriptCacheKey(Handle<String> source, MaybeHandle<Object> name,
                  int line_offset, int column_offset,
                  v8::ScriptOriginOptions origin_options,
-                 MaybeHandle<Object> host_defined_options, Isolate* isolate);
+                 MaybeHandle<Object> host_defined_options,
+                 MaybeHandle<FixedArray> maybe_wrapped_arguments,
+                 Isolate* isolate);
 
   bool IsMatch(Object other) override;
-  bool MatchesOrigin(Script script);
+  bool MatchesScript(Script script);
 
   Handle<Object> AsHandle(Isolate* isolate, Handle<SharedFunctionInfo> shared);
 
@@ -98,6 +100,7 @@ class ScriptCacheKey : public HashTableKey {
   int column_offset_;
   v8::ScriptOriginOptions origin_options_;
   MaybeHandle<Object> host_defined_options_;
+  MaybeHandle<FixedArray> wrapped_arguments_;
   Isolate* isolate_;
 };
 
diff --git a/deps/v8/src/objects/compilation-cache-table.cc b/deps/v8/src/objects/compilation-cache-table.cc
index 5cf4ef1077fec7..658675c407a443 100644
--- a/deps/v8/src/objects/compilation-cache-table.cc
+++ b/deps/v8/src/objects/compilation-cache-table.cc
@@ -244,7 +244,7 @@ Smi ScriptHash(String source, MaybeHandle<Object> maybe_name, int line_offset,
 // We only re-use a cached function for some script source code if the
 // script originates from the same place. This is to avoid issues
 // when reporting errors, etc.
-bool ScriptCacheKey::MatchesOrigin(Script script) {
+bool ScriptCacheKey::MatchesScript(Script script) {
   DisallowGarbageCollection no_gc;
 
   // If the script name isn't set, the boilerplate script should have
@@ -268,6 +268,30 @@ bool ScriptCacheKey::MatchesOrigin(Script script) {
     return false;
   }
 
+  Handle<FixedArray> wrapped_arguments_handle;
+  if (wrapped_arguments_.ToHandle(&wrapped_arguments_handle)) {
+    if (!script.is_wrapped()) {
+      return false;
+    }
+    FixedArray wrapped_arguments = *wrapped_arguments_handle;
+    FixedArray other_wrapped_arguments = script.wrapped_arguments();
+    int length = wrapped_arguments.length();
+    if (length != other_wrapped_arguments.length()) {
+      return false;
+    }
+    for (int i = 0; i < length; i++) {
+      Object arg = wrapped_arguments.get(i);
+      Object other_arg = other_wrapped_arguments.get(i);
+      DCHECK(arg.IsString());
+      DCHECK(other_arg.IsString());
+      if (!String::cast(arg).Equals(String::cast(other_arg))) {
+        return false;
+      }
+    }
+  } else if (script.is_wrapped()) {
+    return false;
+  }
+
   // Don't compare host options if the script was deserialized because we didn't
   // serialize host options (see CodeSerializer::SerializeObjectImpl())
   if (script.deserialized() &&
@@ -303,12 +327,14 @@ ScriptCacheKey::ScriptCacheKey(Handle<String> source,
     : ScriptCacheKey(source, script_details->name_obj,
                      script_details->line_offset, script_details->column_offset,
                      script_details->origin_options,
-                     script_details->host_defined_options, isolate) {}
+                     script_details->host_defined_options,
+                     script_details->wrapped_arguments, isolate) {}
 
 ScriptCacheKey::ScriptCacheKey(Handle<String> source, MaybeHandle<Object> name,
                                int line_offset, int column_offset,
                                v8::ScriptOriginOptions origin_options,
                                MaybeHandle<Object> host_defined_options,
+                               MaybeHandle<FixedArray> maybe_wrapped_arguments,
                                Isolate* isolate)
     : HashTableKey(static_cast<uint32_t>(ScriptHash(*source, name, line_offset,
                                                     column_offset,
@@ -320,8 +346,19 @@ ScriptCacheKey::ScriptCacheKey(Handle<String> source, MaybeHandle<Object> name,
       column_offset_(column_offset),
       origin_options_(origin_options),
       host_defined_options_(host_defined_options),
+      wrapped_arguments_(maybe_wrapped_arguments),
       isolate_(isolate) {
   DCHECK(Smi::IsValid(static_cast<int>(Hash())));
+#ifdef DEBUG
+  Handle<FixedArray> wrapped_arguments;
+  if (maybe_wrapped_arguments.ToHandle(&wrapped_arguments)) {
+    int length = wrapped_arguments->length();
+    for (int i = 0; i < length; i++) {
+      Object arg = wrapped_arguments->get(i);
+      DCHECK(arg.IsString());
+    }
+  }
+#endif
 }
 
 bool ScriptCacheKey::IsMatch(Object other) {
@@ -342,7 +379,7 @@ bool ScriptCacheKey::IsMatch(Object other) {
   }
   Script other_script = Script::cast(other_script_object);
   String other_source = String::cast(other_script.source());
-  return other_source.Equals(*source_) && MatchesOrigin(other_script);
+  return other_source.Equals(*source_) && MatchesScript(other_script);
 }
 
 Handle<Object> ScriptCacheKey::AsHandle(Isolate* isolate,
@@ -469,6 +506,7 @@ Handle<CompilationCacheTable> CompilationCacheTable::EnsureScriptTableCapacity(
 
 Handle<CompilationCacheTable> CompilationCacheTable::PutScript(
     Handle<CompilationCacheTable> cache, Handle<String> src,
+    MaybeHandle<FixedArray> maybe_wrapped_arguments,
     Handle<SharedFunctionInfo> value, Isolate* isolate) {
   src = String::Flatten(isolate, src);
   Handle<Script> script = handle(Script::cast(value->script()), isolate);
@@ -480,7 +518,7 @@ Handle<CompilationCacheTable> CompilationCacheTable::PutScript(
                                           isolate);
   ScriptCacheKey key(src, script_name, script->line_offset(),
                      script->column_offset(), script->origin_options(),
-                     host_defined_options, isolate);
+                     host_defined_options, maybe_wrapped_arguments, isolate);
   Handle<Object> k = key.AsHandle(isolate, value);
 
   // Check whether there is already a matching entry. If so, we must overwrite
diff --git a/deps/v8/src/objects/compilation-cache-table.h b/deps/v8/src/objects/compilation-cache-table.h
index fdd7fb57f0c1a2..a35178d26d9f19 100644
--- a/deps/v8/src/objects/compilation-cache-table.h
+++ b/deps/v8/src/objects/compilation-cache-table.h
@@ -119,6 +119,7 @@ class CompilationCacheTable
       const ScriptDetails& script_details, Isolate* isolate);
   static Handle<CompilationCacheTable> PutScript(
       Handle<CompilationCacheTable> cache, Handle<String> src,
+      MaybeHandle<FixedArray> maybe_wrapped_arguments,
       Handle<SharedFunctionInfo> value, Isolate* isolate);
 
   // Eval code only gets cached after a second probe for the
diff --git a/deps/v8/test/cctest/test-serialize.cc b/deps/v8/test/cctest/test-serialize.cc
index ee9cb5493bee07..47e0e7a63ed6d1 100644
--- a/deps/v8/test/cctest/test-serialize.cc
+++ b/deps/v8/test/cctest/test-serialize.cc
@@ -28,6 +28,8 @@
 #include <signal.h>
 #include <sys/stat.h>
 
+#include <vector>
+
 #include "include/v8-extension.h"
 #include "include/v8-function.h"
 #include "include/v8-locker.h"
@@ -60,7 +62,6 @@
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
 #include "test/cctest/setup-isolate-for-tests.h"
-
 namespace v8 {
 namespace internal {
 
@@ -1906,6 +1907,259 @@ TEST(CodeSerializerPromotedToCompilationCache) {
   delete cache;
 }
 
+TEST(CompileFunctionCompilationCache) {
+  LocalContext env;
+  Isolate* i_isolate = CcTest::i_isolate();
+
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::HandleScope scope(isolate);
+  const char* source = "a + b";
+  v8::Local<v8::String> src = v8_str(source);
+  v8::Local<v8::String> resource_name = v8_str("test");
+  Handle<String> i_src = Utils::OpenHandle(*src);
+  Handle<String> i_resource_name = Utils::OpenHandle(*resource_name);
+
+  v8::Local<v8::PrimitiveArray> host_defined_options =
+      v8::PrimitiveArray::New(isolate, 1);
+  v8::Local<v8::Symbol> sym = v8::Symbol::New(isolate, v8_str("hdo"));
+  host_defined_options->Set(isolate, 0, sym);
+
+  Handle<FixedArray> i_host_defined_options =
+      i_isolate->factory()->NewFixedArray(1);
+  Handle<Symbol> i_sym = Utils::OpenHandle(*sym);
+  i_host_defined_options->set(0, *i_sym);
+
+  v8::ScriptOrigin origin(resource_name, 0, 0, false, -1,
+                          v8::Local<v8::Value>(), false, false, false,
+                          host_defined_options);
+
+  std::vector<const char*> raw_args = {"a", "b"};
+
+  std::vector<v8::Local<v8::String>> args;
+  for (size_t i = 0; i < raw_args.size(); ++i) {
+    args.push_back(v8_str(raw_args[i]));
+  }
+  Handle<FixedArray> i_args =
+      i_isolate->factory()->NewFixedArray(static_cast<int>(args.size()));
+  for (size_t i = 0; i < raw_args.size(); ++i) {
+    Handle<String> arg =
+        i_isolate->factory()->NewStringFromAsciiChecked(raw_args[i]);
+    i_args->set(static_cast<int>(i), *arg);
+  }
+
+  Handle<SharedFunctionInfo> sfi;
+  v8::ScriptCompiler::CachedData* cache;
+  {
+    v8::ScriptCompiler::Source script_source(src, origin);
+    v8::Local<v8::Function> fun =
+        v8::ScriptCompiler::CompileFunction(
+            env.local(), &script_source, args.size(), args.data(), 0, nullptr,
+            v8::ScriptCompiler::kEagerCompile)
+            .ToLocalChecked();
+    cache = v8::ScriptCompiler::CreateCodeCacheForFunction(fun);
+    auto js_function =
+        DirectHandle<JSFunction>::cast(Utils::OpenDirectHandle(*fun));
+    sfi = Handle<SharedFunctionInfo>(js_function->shared(), i_isolate);
+  }
+
+  {
+    DisallowCompilation no_compile_expected(i_isolate);
+    v8::ScriptCompiler::Source script_source(src, origin, cache);
+    v8::Local<v8::Function> fun =
+        v8::ScriptCompiler::CompileFunction(
+            env.local(), &script_source, args.size(), args.data(), 0, nullptr,
+            v8::ScriptCompiler::kConsumeCodeCache)
+            .ToLocalChecked();
+    auto js_function =
+        DirectHandle<JSFunction>::cast(Utils::OpenDirectHandle(*fun));
+    CHECK_EQ(js_function->shared(), *sfi);
+  }
+
+  auto CopyScriptDetails = [&](ScriptOriginOptions origin_options =
+                                   v8::ScriptOriginOptions()) {
+    ScriptDetails script_details(i_resource_name, origin_options);
+    script_details.wrapped_arguments = i_args;
+    script_details.host_defined_options = i_host_defined_options;
+    return script_details;
+  };
+
+  {
+    // Lookup with the same wrapped arguments should succeed.
+    ScriptDetails script_details = CopyScriptDetails();
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *sfi);
+  }
+
+  {
+    // Lookup with empty wrapped arguments and host-defined options should fail:
+    ScriptDetails script_details = CopyScriptDetails();
+    script_details.wrapped_arguments = kNullMaybeHandle;
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different wrapped arguments should fail:
+    Handle<FixedArray> new_args = i_isolate->factory()->NewFixedArray(3);
+    Handle<String> arg_1 = i_isolate->factory()->NewStringFromAsciiChecked("a");
+    Handle<String> arg_2 = i_isolate->factory()->NewStringFromAsciiChecked("b");
+    Handle<String> arg_3 = i_isolate->factory()->NewStringFromAsciiChecked("c");
+    new_args->set(0, *arg_1);
+    new_args->set(1, *arg_2);
+    new_args->set(2, *arg_3);
+    ScriptDetails script_details = CopyScriptDetails();
+    script_details.wrapped_arguments = new_args;
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different host_defined_options should fail:
+    Handle<FixedArray> new_options = i_isolate->factory()->NewFixedArray(1);
+    Handle<Symbol> new_sym = i_isolate->factory()->NewSymbol();
+    new_options->set(0, *new_sym);
+    ScriptDetails script_details = CopyScriptDetails();
+    script_details.host_defined_options = new_options;
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different string with same contents should succeed:
+    ScriptDetails script_details = CopyScriptDetails();
+
+    Handle<String> new_src =
+        i_isolate->factory()->NewStringFromAsciiChecked(source);
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        new_src, script_details, LanguageMode::kSloppy);
+    CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *sfi);
+  }
+
+  {
+    // Lookup with different content should fail;
+    ScriptDetails script_details = CopyScriptDetails();
+
+    Handle<String> new_src =
+        i_isolate->factory()->NewStringFromAsciiChecked("a + b + 1");
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        new_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different name string should fail:
+    ScriptDetails script_details = CopyScriptDetails();
+    script_details.name_obj =
+        i_isolate->factory()->NewStringFromAsciiChecked("other");
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different position should fail:
+    ScriptDetails script_details = CopyScriptDetails();
+    script_details.line_offset = 0xFF;
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different position should fail:
+    ScriptDetails script_details = CopyScriptDetails();
+    script_details.column_offset = 0xFF;
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different language mode should fail:
+    ScriptDetails script_details = CopyScriptDetails();
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kStrict);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  {
+    // Lookup with different script_options should fail
+    ScriptOriginOptions origin_options(false, true);
+    CHECK_NE(ScriptOriginOptions().Flags(), origin_options.Flags());
+    ScriptDetails script_details = CopyScriptDetails(origin_options);
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK(lookup_result.script().is_null() &&
+          lookup_result.toplevel_sfi().is_null());
+  }
+
+  // Compile the function again with different options.
+  Handle<SharedFunctionInfo> other_sfi;
+  v8::Local<v8::Symbol> other_sym;
+  {
+    v8::Local<v8::PrimitiveArray> other_options =
+        v8::PrimitiveArray::New(isolate, 1);
+    other_sym = v8::Symbol::New(isolate, v8_str("hdo2"));
+    other_options->Set(isolate, 0, other_sym);
+    v8::ScriptOrigin other_origin(resource_name, 0, 0, false, -1,
+                                  v8::Local<v8::Value>(), false, false, false,
+                                  other_options);
+
+    v8::ScriptCompiler::Source script_source(src, other_origin);
+    v8::Local<v8::Function> fun =
+        v8::ScriptCompiler::CompileFunction(
+            env.local(), &script_source, args.size(), args.data(), 0, nullptr,
+            v8::ScriptCompiler::kNoCompileOptions,
+            ScriptCompiler::kNoCacheNoReason)
+            .ToLocalChecked();
+    auto js_function =
+        DirectHandle<JSFunction>::cast(Utils::OpenDirectHandle(*fun));
+    other_sfi = Handle<SharedFunctionInfo>(js_function->shared(), i_isolate);
+    CHECK_NE(*other_sfi, *sfi);
+  }
+
+  {
+    // The original script can still be found.
+    ScriptDetails script_details = CopyScriptDetails();
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *sfi);
+  }
+
+  {
+    // The new script can also be found.
+    Handle<FixedArray> other_options = i_isolate->factory()->NewFixedArray(1);
+    Handle<Symbol> i_other_sym = Utils::OpenHandle(*other_sym);
+    other_options->set(0, *i_other_sym);
+    ScriptDetails script_details = CopyScriptDetails();
+    script_details.host_defined_options = other_options;
+
+    auto lookup_result = i_isolate->compilation_cache()->LookupScript(
+        i_src, script_details, LanguageMode::kSloppy);
+    CHECK_EQ(*lookup_result.toplevel_sfi().ToHandleChecked(), *other_sfi);
+  }
+}
+
 TEST(CodeSerializerInternalizedString) {
   LocalContext context;
   Isolate* isolate = CcTest::i_isolate();