diff --git a/BUILD.bazel b/BUILD.bazel
index 63262438aa..13c79bee9a 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -1164,7 +1164,6 @@ filegroup(
         "src/builtins/builtins-utils-inl.h",
         "src/builtins/builtins-utils.h",
         "src/builtins/builtins-weak-refs.cc",
-        "src/builtins/builtins-web-snapshots.cc",
         "src/builtins/builtins.cc",
         "src/builtins/builtins.h",
         "src/builtins/constants-table-builder.cc",
@@ -2207,8 +2206,6 @@ filegroup(
         "src/utils/utils.h",
         "src/utils/version.cc",
         "src/utils/version.h",
-        "src/web-snapshot/web-snapshot.h",
-        "src/web-snapshot/web-snapshot.cc",
         "src/zone/accounting-allocator.cc",
         "src/zone/accounting-allocator.h",
         "src/zone/compressed-zone-ptr.h",
diff --git a/BUILD.gn b/BUILD.gn
index bc2c332cbd..480d68d646 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -4562,7 +4562,6 @@ v8_source_set("v8_base_without_compiler") {
     "src/builtins/builtins-trace.cc",
     "src/builtins/builtins-typed-array.cc",
     "src/builtins/builtins-weak-refs.cc",
-    "src/builtins/builtins-web-snapshots.cc",
     "src/builtins/builtins.cc",
     "src/builtins/constants-table-builder.cc",
     "src/codegen/aligned-slot-allocator.cc",
@@ -4955,8 +4954,6 @@ v8_source_set("v8_base_without_compiler") {
     "src/utils/sha-256.cc",
     "src/utils/utils.cc",
     "src/utils/version.cc",
-    "src/web-snapshot/web-snapshot.cc",
-    "src/web-snapshot/web-snapshot.h",
     "src/zone/accounting-allocator.cc",
     "src/zone/type-stats.cc",
     "src/zone/zone-segment.cc",
diff --git a/src/api/api.cc b/src/api/api.cc
index e1fc639b7e..ee0ac18dc3 100644
--- a/src/api/api.cc
+++ b/src/api/api.cc
@@ -128,7 +128,6 @@
 #include "src/tracing/trace-event.h"
 #include "src/utils/detachable-vector.h"
 #include "src/utils/version.h"
-#include "src/web-snapshot/web-snapshot.h"
 
 #if V8_ENABLE_WEBASSEMBLY
 #include "src/trap-handler/trap-handler.h"
@@ -2225,22 +2224,6 @@ MaybeLocal<Value> Script::Run(Local<Context> context,
   }
 #endif
   auto fun = i::Handle<i::JSFunction>::cast(Utils::OpenHandle(this));
-
-  if (V8_UNLIKELY(i::v8_flags.experimental_web_snapshots)) {
-    i::Handle<i::HeapObject> maybe_script =
-        handle(fun->shared().script(), i_isolate);
-    if (maybe_script->IsScript() &&
-        i::Script::cast(*maybe_script).type() == i::Script::TYPE_WEB_SNAPSHOT) {
-      i::WebSnapshotDeserializer deserializer(
-          reinterpret_cast<i::Isolate*>(v8_isolate),
-          i::Handle<i::Script>::cast(maybe_script));
-      deserializer.Deserialize();
-      RETURN_ON_FAILED_EXECUTION(Value);
-      Local<Value> result = v8::Undefined(v8_isolate);
-      RETURN_ESCAPED(result);
-    }
-  }
-
   i::Handle<i::Object> receiver = i_isolate->global_proxy();
   // TODO(cbruni, chromium:1244145): Remove once migrated to the context.
   i::Handle<i::Object> options(
diff --git a/src/builtins/builtins-definitions.h b/src/builtins/builtins-definitions.h
index 0ca201fc61..424580e38a 100644
--- a/src/builtins/builtins-definitions.h
+++ b/src/builtins/builtins-definitions.h
@@ -626,10 +626,6 @@ namespace internal {
   CPP(JsonRawJson)                                                             \
   CPP(JsonIsRawJson)                                                           \
                                                                                \
-  /* Web snapshots */                                                          \
-  CPP(WebSnapshotSerialize)                                                    \
-  CPP(WebSnapshotDeserialize)                                                  \
-                                                                               \
   /* ICs */                                                                    \
   TFH(LoadIC, LoadWithVector)                                                  \
   TFH(LoadIC_Megamorphic, LoadWithVector)                                      \
diff --git a/src/builtins/builtins-web-snapshots.cc b/src/builtins/builtins-web-snapshots.cc
deleted file mode 100644
index 1e85edd919..0000000000
--- a/src/builtins/builtins-web-snapshots.cc
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright 2022 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/builtins/builtins-utils-inl.h"
-#include "src/builtins/builtins.h"
-#include "src/logging/counters.h"
-#include "src/objects/js-array-buffer-inl.h"
-#include "src/objects/js-array-inl.h"
-#include "src/objects/objects-inl.h"
-#include "src/web-snapshot/web-snapshot.h"
-
-namespace v8 {
-namespace internal {
-
-BUILTIN(WebSnapshotSerialize) {
-  HandleScope scope(isolate);
-  if (args.length() < 2 || args.length() > 3) {
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kInvalidArgument));
-  }
-  Handle<Object> object = args.at(1);
-  Handle<FixedArray> block_list = isolate->factory()->empty_fixed_array();
-  Handle<JSArray> block_list_js_array;
-  if (args.length() == 3) {
-    if (!args[2].IsJSArray()) {
-      THROW_NEW_ERROR_RETURN_FAILURE(
-          isolate, NewTypeError(MessageTemplate::kInvalidArgument));
-    }
-    block_list_js_array = args.at<JSArray>(2);
-    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-        isolate, block_list,
-        JSReceiver::GetOwnValues(isolate, block_list_js_array,
-                                 PropertyFilter::ENUMERABLE_STRINGS));
-  }
-
-  auto snapshot_data = std::make_shared<WebSnapshotData>();
-  WebSnapshotSerializer serializer(isolate);
-  if (!serializer.TakeSnapshot(object, block_list, *snapshot_data)) {
-    DCHECK(isolate->has_pending_exception());
-    return ReadOnlyRoots(isolate).exception();
-  }
-  if (!block_list_js_array.is_null() &&
-      static_cast<uint32_t>(block_list->length()) <
-          serializer.external_object_count()) {
-    Handle<FixedArray> externals = serializer.GetExternals();
-    Handle<Map> map = JSObject::GetElementsTransitionMap(block_list_js_array,
-                                                         PACKED_ELEMENTS);
-    block_list_js_array->set_elements(*externals);
-    block_list_js_array->set_length(Smi::FromInt(externals->length()));
-    block_list_js_array->set_map(*map);
-  }
-
-  MaybeHandle<JSArrayBuffer> maybe_result =
-      isolate->factory()->NewJSArrayBufferAndBackingStore(
-          snapshot_data->buffer_size, InitializedFlag::kUninitialized);
-  Handle<JSArrayBuffer> result;
-  if (!maybe_result.ToHandle(&result)) {
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kOutOfMemory,
-                              isolate->factory()->NewStringFromAsciiChecked(
-                                  "WebSnapshotSerialize")));
-  }
-  uint8_t* data =
-      reinterpret_cast<uint8_t*>(result->GetBackingStore()->buffer_start());
-  memcpy(data, snapshot_data->buffer, snapshot_data->buffer_size);
-
-  return *result;
-}
-
-BUILTIN(WebSnapshotDeserialize) {
-  HandleScope scope(isolate);
-  if (args.length() < 2 || args.length() > 3) {
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kInvalidArgument));
-  }
-
-  if (!args[1].IsJSArrayBuffer()) {
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kInvalidArgument));
-  }
-  auto buffer = args.at<JSArrayBuffer>(1);
-  std::shared_ptr<BackingStore> backing_store = buffer->GetBackingStore();
-  if (backing_store.get() == nullptr) {
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kInvalidArgument));
-  }
-  const uint8_t* data =
-      reinterpret_cast<uint8_t*>(backing_store->buffer_start());
-
-  Handle<FixedArray> injected_references =
-      isolate->factory()->empty_fixed_array();
-  if (args.length() == 3) {
-    if (!args[2].IsJSArray()) {
-      THROW_NEW_ERROR_RETURN_FAILURE(
-          isolate, NewTypeError(MessageTemplate::kInvalidArgument));
-    }
-    auto js_array = args.at<JSArray>(2);
-    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-        isolate, injected_references,
-        JSReceiver::GetOwnValues(isolate, js_array,
-                                 PropertyFilter::ENUMERABLE_STRINGS));
-  }
-
-  WebSnapshotDeserializer deserializer(reinterpret_cast<v8::Isolate*>(isolate),
-                                       data, backing_store->byte_length());
-  if (!deserializer.Deserialize(injected_references)) {
-    DCHECK(isolate->has_pending_exception());
-    return ReadOnlyRoots(isolate).exception();
-  }
-  Handle<Object> object;
-  if (!deserializer.value().ToHandle(&object)) {
-    return ReadOnlyRoots(isolate).undefined_value();
-  }
-  return *object;
-}
-
-}  // namespace internal
-}  // namespace v8
diff --git a/src/codegen/compiler.cc b/src/codegen/compiler.cc
index fa0872b842..a8f40090a0 100644
--- a/src/codegen/compiler.cc
+++ b/src/codegen/compiler.cc
@@ -62,7 +62,6 @@
 #include "src/parsing/scanner-character-streams.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/utils/ostreams.h"
-#include "src/web-snapshot/web-snapshot.h"
 #include "src/zone/zone-list-inl.h"  // crbug.com/v8/8816
 
 #ifdef V8_ENABLE_MAGLEV
@@ -3451,29 +3450,6 @@ MaybeHandle<SharedFunctionInfo> GetSharedFunctionInfoForScriptImpl(
     DCHECK_NULL(deserialize_task);
   }
 
-  if (V8_UNLIKELY(
-          v8_flags.experimental_web_snapshots &&
-          (source->IsExternalOneByteString() || source->IsSeqOneByteString() ||
-           source->IsExternalTwoByteString() || source->IsSeqTwoByteString()) &&
-          source->length() > 4)) {
-    // Experimental: Treat the script as a web snapshot if it starts with the
-    // magic byte sequence. TODO(v8:11525): Remove this once proper embedder
-    // integration is done.
-    bool magic_matches = true;
-    for (size_t i = 0;
-         i < sizeof(WebSnapshotSerializerDeserializer::kMagicNumber); ++i) {
-      if (source->Get(static_cast<int>(i)) !=
-          WebSnapshotSerializerDeserializer::kMagicNumber[i]) {
-        magic_matches = false;
-        break;
-      }
-    }
-    if (magic_matches) {
-      return Compiler::GetSharedFunctionInfoForWebSnapshot(
-          isolate, source, script_details.name_obj);
-    }
-  }
-
   LanguageMode language_mode = construct_language_mode(v8_flags.use_strict);
   CompilationCache* compilation_cache = isolate->compilation_cache();
 
@@ -3801,30 +3777,6 @@ Compiler::GetSharedFunctionInfoForStreamedScript(
   return maybe_result;
 }  // namespace internal
 
-// static
-Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForWebSnapshot(
-    Isolate* isolate, Handle<String> source,
-    MaybeHandle<Object> maybe_script_name) {
-  // This script won't hold the functions created from the web snapshot;
-  // reserving space only for the top-level SharedFunctionInfo is enough.
-  Handle<WeakFixedArray> shared_function_infos =
-      isolate->factory()->NewWeakFixedArray(1, AllocationType::kOld);
-  Handle<Script> script = isolate->factory()->NewScript(source);
-  script->set_type(Script::TYPE_WEB_SNAPSHOT);
-  script->set_shared_function_infos(*shared_function_infos);
-  Handle<Object> script_name;
-  if (maybe_script_name.ToHandle(&script_name) && script_name->IsString()) {
-    script->set_name(String::cast(*script_name));
-  } else {
-    script->set_name(*isolate->factory()->empty_string());
-  }
-
-  Handle<SharedFunctionInfo> shared =
-      isolate->factory()->NewSharedFunctionInfoForWebSnapshot();
-  shared->SetScript(isolate->factory()->read_only_roots(), *script, 0, false);
-  return shared;
-}
-
 // static
 template <typename IsolateT>
 Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfo(
diff --git a/src/codegen/compiler.h b/src/codegen/compiler.h
index 531b0d908b..8d61ffbe74 100644
--- a/src/codegen/compiler.h
+++ b/src/codegen/compiler.h
@@ -224,9 +224,6 @@ class V8_EXPORT_PRIVATE Compiler : public AllStatic {
       Isolate* isolate, Handle<String> source,
       const ScriptDetails& script_details, ScriptStreamingData* streaming_data);
 
-  static Handle<SharedFunctionInfo> GetSharedFunctionInfoForWebSnapshot(
-      Isolate* isolate, Handle<String> source, MaybeHandle<Object> script_name);
-
   // Create a shared function info object for the given function literal
   // node (the code may be lazily compiled).
   template <typename IsolateT>
diff --git a/src/common/message-template.h b/src/common/message-template.h
index bca6ad8d80..6d0949ee9d 100644
--- a/src/common/message-template.h
+++ b/src/common/message-template.h
@@ -709,10 +709,7 @@ namespace internal {
   T(OptionalChainingNoSuper, "Invalid optional chain from super property")     \
   T(OptionalChainingNoTemplate, "Invalid tagged template on optional chain")   \
   /* AggregateError */                                                         \
-  T(AllPromisesRejected, "All promises were rejected")                         \
-  /* Web snapshots */                                                          \
-  T(WebSnapshotError, "Web snapshot failed: %")
-
+  T(AllPromisesRejected, "All promises were rejected")
 enum class MessageTemplate {
 #define TEMPLATE(NAME, STRING) k##NAME,
   MESSAGE_TEMPLATES(TEMPLATE)
diff --git a/src/d8/d8.cc b/src/d8/d8.cc
index e6f48bfedc..8f9d5dbaf9 100644
--- a/src/d8/d8.cc
+++ b/src/d8/d8.cc
@@ -69,7 +69,6 @@
 #include "src/tasks/cancelable-task.h"
 #include "src/utils/ostreams.h"
 #include "src/utils/utils.h"
-#include "src/web-snapshot/web-snapshot.h"
 
 #if V8_OS_POSIX
 #include <signal.h>
@@ -914,52 +913,6 @@ bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
   return success;
 }
 
-bool Shell::TakeWebSnapshot(Isolate* isolate) {
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  Local<Context> realm =
-      Local<Context>::New(isolate, data->realms_[data->realm_current_]);
-  Context::Scope context_scope(realm);
-  Local<Context> context(isolate->GetCurrentContext());
-
-  v8::TryCatch try_catch(isolate);
-  try_catch.SetVerbose(true);
-  const char* web_snapshot_output_file_name = "web.snap";
-  if (options.web_snapshot_output) {
-    web_snapshot_output_file_name = options.web_snapshot_output;
-  }
-
-  if (!options.web_snapshot_config) {
-    isolate->ThrowError(
-        "Web snapshots: --web-snapshot-config is needed when "
-        "--web-snapshot-output is passed");
-    CHECK(try_catch.HasCaught());
-    ReportException(isolate, &try_catch);
-    return false;
-  }
-
-  MaybeLocal<PrimitiveArray> maybe_exports =
-      ReadLines(isolate, options.web_snapshot_config);
-  Local<PrimitiveArray> exports;
-  if (!maybe_exports.ToLocal(&exports)) {
-    isolate->ThrowError("Web snapshots: unable to read config");
-    CHECK(try_catch.HasCaught());
-    ReportException(isolate, &try_catch);
-    return false;
-  }
-
-  i::WebSnapshotSerializer serializer(isolate);
-  i::WebSnapshotData snapshot_data;
-  if (serializer.TakeSnapshot(context, exports, snapshot_data)) {
-    DCHECK_NOT_NULL(snapshot_data.buffer);
-    WriteChars(web_snapshot_output_file_name, snapshot_data.buffer,
-               snapshot_data.buffer_size);
-  } else {
-    CHECK(try_catch.HasCaught());
-    return false;
-  }
-  return true;
-}
-
 namespace {
 
 bool IsAbsolutePath(const std::string& path) {
@@ -1499,44 +1452,6 @@ bool Shell::ExecuteModule(Isolate* isolate, const char* file_name) {
   return true;
 }
 
-bool Shell::ExecuteWebSnapshot(Isolate* isolate, const char* file_name) {
-  HandleScope handle_scope(isolate);
-
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  Local<Context> realm = data->realms_[data->realm_current_].Get(isolate);
-  Context::Scope context_scope(realm);
-
-  std::string absolute_path = NormalizePath(file_name, GetWorkingDirectory());
-
-  int length = 0;
-  std::unique_ptr<uint8_t[]> snapshot_data(
-      reinterpret_cast<uint8_t*>(ReadChars(absolute_path.c_str(), &length)));
-  if (length == 0) {
-    TryCatch try_catch(isolate);
-    isolate->ThrowError("Could not read the web snapshot file");
-    CHECK(try_catch.HasCaught());
-    ReportException(isolate, &try_catch);
-    return false;
-  } else {
-    for (int r = 0; r < DeserializationRunCount(); ++r) {
-      bool skip_exports = r > 0;
-      i::WebSnapshotDeserializer deserializer(isolate, snapshot_data.get(),
-                                              static_cast<size_t>(length));
-      if (!deserializer.Deserialize({}, skip_exports)) {
-        // d8 is calling into the internal APIs which won't do
-        // ReportPendingMessages in all error paths (it's supposed to be done at
-        // the API boundary). Call it here.
-        auto i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-        if (i_isolate->has_pending_exception()) {
-          i_isolate->ReportPendingMessages();
-        }
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
 // Treat every line as a JSON value and parse it.
 bool Shell::LoadJSON(Isolate* isolate, const char* file_name) {
   HandleScope handle_scope(isolate);
@@ -1579,10 +1494,6 @@ PerIsolateData::PerIsolateData(Isolate* isolate)
     async_hooks_wrapper_ = new AsyncHooks(isolate);
   }
   ignore_unhandled_promises_ = false;
-  // TODO(v8:11525): Use methods on global Snapshot objects with
-  // signature checks.
-  HandleScope scope(isolate);
-  Shell::CreateSnapshotTemplate(isolate);
 }
 
 PerIsolateData::~PerIsolateData() {
@@ -1678,14 +1589,6 @@ void PerIsolateData::SetTestApiObjectCtor(Local<FunctionTemplate> ctor) {
   test_api_object_ctor_.Reset(isolate_, ctor);
 }
 
-Local<FunctionTemplate> PerIsolateData::GetSnapshotObjectCtor() const {
-  return snapshot_object_ctor_.Get(isolate_);
-}
-
-void PerIsolateData::SetSnapshotObjectCtor(Local<FunctionTemplate> ctor) {
-  snapshot_object_ctor_.Reset(isolate_, ctor);
-}
-
 Local<FunctionTemplate> PerIsolateData::GetDomNodeCtor() const {
   return dom_node_ctor_.Get(isolate_);
 }
@@ -2168,100 +2071,6 @@ void Shell::RealmSharedSet(Local<String> property, Local<Value> value,
   data->realm_shared_.Reset(isolate, value);
 }
 
-// Realm.takeWebSnapshot(index, exports) takes a snapshot of the list of exports
-// in the realm with the specified index and returns the result.
-void Shell::RealmTakeWebSnapshot(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  Isolate* isolate = args.GetIsolate();
-  if (args.Length() < 2 || !args[1]->IsArray()) {
-    isolate->ThrowError("Invalid argument");
-    return;
-  }
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  int index = data->RealmIndexOrThrow(args, 0);
-  if (index == -1) return;
-  // Create a Local<PrimitiveArray> from the exports array.
-  Local<Context> current_context = isolate->GetCurrentContext();
-  Local<Array> exports_array = args[1].As<Array>();
-  int length = exports_array->Length();
-  Local<PrimitiveArray> exports = PrimitiveArray::New(isolate, length);
-  for (int i = 0; i < length; ++i) {
-    Local<Value> value;
-    Local<String> str;
-    if (!exports_array->Get(current_context, i).ToLocal(&value) ||
-        !value->ToString(current_context).ToLocal(&str) || str.IsEmpty()) {
-      isolate->ThrowError("Invalid argument");
-      return;
-    }
-    exports->Set(isolate, i, str);
-  }
-  // Take the snapshot in the specified Realm.
-  auto snapshot_data_shared = std::make_shared<i::WebSnapshotData>();
-  {
-    TryCatch try_catch(isolate);
-    try_catch.SetVerbose(true);
-    PerIsolateData::ExplicitRealmScope realm_scope(data, index);
-    i::WebSnapshotSerializer serializer(isolate);
-    if (!serializer.TakeSnapshot(realm_scope.context(), exports,
-                                 *snapshot_data_shared)) {
-      CHECK(try_catch.HasCaught());
-      args.GetReturnValue().Set(Undefined(isolate));
-      return;
-    }
-  }
-  // Create a snapshot object and store the WebSnapshotData as an embedder
-  // field. TODO(v8:11525): Use methods on global Snapshot objects with
-  // signature checks.
-  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-  i::Handle<i::Object> snapshot_data_managed =
-      i::Managed<i::WebSnapshotData>::FromSharedPtr(
-          i_isolate, snapshot_data_shared->buffer_size, snapshot_data_shared);
-  v8::Local<v8::Value> shapshot_data = Utils::ToLocal(snapshot_data_managed);
-  Local<ObjectTemplate> snapshot_template =
-      data->GetSnapshotObjectCtor()->InstanceTemplate();
-  Local<Object> snapshot_instance =
-      snapshot_template->NewInstance(isolate->GetCurrentContext())
-          .ToLocalChecked();
-  snapshot_instance->SetInternalField(0, shapshot_data);
-  args.GetReturnValue().Set(snapshot_instance);
-}
-
-// Realm.useWebSnapshot(index, snapshot) deserializes the snapshot in the realm
-// with the specified index.
-void Shell::RealmUseWebSnapshot(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  Isolate* isolate = args.GetIsolate();
-  if (args.Length() < 2 || !args[1]->IsObject()) {
-    isolate->ThrowError("Invalid argument");
-    return;
-  }
-  PerIsolateData* data = PerIsolateData::Get(isolate);
-  int index = data->RealmIndexOrThrow(args, 0);
-  if (index == -1) return;
-  // Restore the snapshot data from the snapshot object.
-  Local<Object> snapshot_instance = args[1].As<Object>();
-  Local<FunctionTemplate> snapshot_template = data->GetSnapshotObjectCtor();
-  if (!snapshot_template->HasInstance(snapshot_instance)) {
-    isolate->ThrowError("Invalid argument");
-    return;
-  }
-  v8::Local<v8::Value> snapshot_data = snapshot_instance->GetInternalField(0);
-  i::Handle<i::Object> snapshot_data_handle = Utils::OpenHandle(*snapshot_data);
-  auto snapshot_data_managed =
-      i::Handle<i::Managed<i::WebSnapshotData>>::cast(snapshot_data_handle);
-  std::shared_ptr<i::WebSnapshotData> snapshot_data_shared =
-      snapshot_data_managed->get();
-  // Deserialize the snapshot in the specified Realm.
-  {
-    PerIsolateData::ExplicitRealmScope realm_scope(data, index);
-    i::WebSnapshotDeserializer deserializer(isolate,
-                                            snapshot_data_shared->buffer,
-                                            snapshot_data_shared->buffer_size);
-    bool success = deserializer.Deserialize();
-    args.GetReturnValue().Set(success);
-  }
-}
-
 void Shell::LogGetAndStop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
@@ -3569,21 +3378,9 @@ Local<ObjectTemplate> Shell::CreateRealmTemplate(Isolate* isolate) {
                       FunctionTemplate::New(isolate, RealmEval));
   realm_template->SetAccessor(String::NewFromUtf8Literal(isolate, "shared"),
                               RealmSharedGet, RealmSharedSet);
-  if (options.d8_web_snapshot_api) {
-    realm_template->Set(isolate, "takeWebSnapshot",
-                        FunctionTemplate::New(isolate, RealmTakeWebSnapshot));
-    realm_template->Set(isolate, "useWebSnapshot",
-                        FunctionTemplate::New(isolate, RealmUseWebSnapshot));
-  }
   return realm_template;
 }
 
-Local<FunctionTemplate> Shell::CreateSnapshotTemplate(Isolate* isolate) {
-  Local<FunctionTemplate> snapshot_template = FunctionTemplate::New(isolate);
-  snapshot_template->InstanceTemplate()->SetInternalFieldCount(1);
-  PerIsolateData::Get(isolate)->SetSnapshotObjectCtor(snapshot_template);
-  return snapshot_template;
-}
 Local<ObjectTemplate> Shell::CreateD8Template(Isolate* isolate) {
   Local<ObjectTemplate> d8_template = ObjectTemplate::New(isolate);
   {
@@ -4464,15 +4261,6 @@ bool SourceGroup::Execute(Isolate* isolate) {
         break;
       }
       continue;
-    } else if (strcmp(arg, "--web-snapshot") == 0 && i + 1 < end_offset_) {
-      // Treat the next file as a web snapshot.
-      arg = argv_[++i];
-      Shell::set_script_executed();
-      if (!Shell::ExecuteWebSnapshot(isolate, arg)) {
-        success = false;
-        break;
-      }
-      continue;
     } else if (strcmp(arg, "--json") == 0 && i + 1 < end_offset_) {
       // Treat the next file as a JSON file.
       arg = argv_[++i];
@@ -4505,13 +4293,6 @@ bool SourceGroup::Execute(Isolate* isolate) {
       break;
     }
   }
-  if (!success) {
-    return false;
-  }
-  if (Shell::options.web_snapshot_config ||
-      Shell::options.web_snapshot_output) {
-    success = Shell::TakeWebSnapshot(isolate);
-  }
   return success;
 }
 
@@ -5067,15 +4848,6 @@ bool Shell::SetOptions(int argc, char* argv[]) {
     } else if (strcmp(argv[i], "--stress-deserialize") == 0) {
       options.stress_deserialize = true;
       argv[i] = nullptr;
-    } else if (strncmp(argv[i], "--web-snapshot-config=", 22) == 0) {
-      options.web_snapshot_config = argv[i] + 22;
-      argv[i] = nullptr;
-    } else if (strncmp(argv[i], "--web-snapshot-output=", 22) == 0) {
-      options.web_snapshot_output = argv[i] + 22;
-      argv[i] = nullptr;
-    } else if (strcmp(argv[i], "--experimental-d8-web-snapshot-api") == 0) {
-      options.d8_web_snapshot_api = true;
-      argv[i] = nullptr;
     } else if (strcmp(argv[i], "--compile-only") == 0) {
       options.compile_only = true;
       argv[i] = nullptr;
@@ -5154,12 +4926,11 @@ bool Shell::SetOptions(int argc, char* argv[]) {
   const char* usage =
       "Synopsis:\n"
       "  shell [options] [--shell] [<file>...]\n"
-      "  d8 [options] [-e <string>] [--shell] [[--module|--web-snapshot]"
+      "  d8 [options] [-e <string>] [--shell] [--module|]"
       " <file>...]\n\n"
       "  -e        execute a string in V8\n"
       "  --shell   run an interactive JavaScript shell\n"
-      "  --module  execute a file as a JavaScript module\n"
-      "  --web-snapshot  execute a file as a web snapshot\n\n";
+      "  --module  execute a file as a JavaScript module\n";
   using HelpOptions = i::FlagList::HelpOptions;
   i::v8_flags.abort_on_contradictory_flags = true;
   i::FlagList::SetFlagsFromCommandLine(&argc, argv, true,
@@ -5186,9 +4957,7 @@ bool Shell::SetOptions(int argc, char* argv[]) {
       current->End(i);
       current++;
       current->Begin(argv, i + 1);
-    } else if (strcmp(str, "--module") == 0 ||
-               strcmp(str, "--web-snapshot") == 0 ||
-               strcmp(str, "--json") == 0) {
+    } else if (strcmp(str, "--module") == 0 || strcmp(str, "--json") == 0) {
       // Pass on to SourceGroup, which understands these options.
     } else if (strncmp(str, "--", 2) == 0) {
       if (!i::v8_flags.correctness_fuzzer_suppressions) {
@@ -5222,7 +4991,6 @@ int Shell::RunMain(Isolate* isolate, bool last_run) {
     }
     HandleScope scope(isolate);
     Local<Context> context = CreateEvaluationContext(isolate);
-    CreateSnapshotTemplate(isolate);
     bool use_existing_context = last_run && use_interactive_shell();
     if (use_existing_context) {
       // Keep using the same context in the interactive shell.
diff --git a/src/d8/d8.h b/src/d8/d8.h
index b70f9c5539..ab7e049472 100644
--- a/src/d8/d8.h
+++ b/src/d8/d8.h
@@ -319,9 +319,6 @@ class PerIsolateData {
   Local<FunctionTemplate> GetTestApiObjectCtor() const;
   void SetTestApiObjectCtor(Local<FunctionTemplate> ctor);
 
-  Local<FunctionTemplate> GetSnapshotObjectCtor() const;
-  void SetSnapshotObjectCtor(Local<FunctionTemplate> ctor);
-
   Local<FunctionTemplate> GetDomNodeCtor() const;
   void SetDomNodeCtor(Local<FunctionTemplate> ctor);
 
@@ -344,7 +341,6 @@ class PerIsolateData {
   std::unordered_set<DynamicImportData*> import_data_;
 #endif
   Global<FunctionTemplate> test_api_object_ctor_;
-  Global<FunctionTemplate> snapshot_object_ctor_;
   Global<FunctionTemplate> dom_node_ctor_;
 
   int RealmIndexOrThrow(const v8::FunctionCallbackInfo<v8::Value>& args,
@@ -464,13 +460,7 @@ class ShellOptions {
       "enable-system-instrumentation", false};
   DisallowReassignment<bool> enable_etw_stack_walking = {
       "enable-etw-stack-walking", false};
-  DisallowReassignment<const char*> web_snapshot_config = {
-      "web-snapshot-config", nullptr};
-  DisallowReassignment<const char*> web_snapshot_output = {
-      "web-snapshot-output", nullptr};
-  DisallowReassignment<bool> d8_web_snapshot_api = {
-      "experimental-d8-web-snapshot-api", false};
-  // Applies to web snapshot and JSON deserialization.
+  // Applies to JSON deserialization.
   DisallowReassignment<bool> stress_deserialize = {"stress-deserialize", false};
   DisallowReassignment<bool> compile_only = {"compile-only", false};
   DisallowReassignment<int> repeat_compile = {"repeat-compile", 1};
@@ -508,8 +498,6 @@ class Shell : public i::AllStatic {
                             ReportExceptions report_exceptions,
                             ProcessMessageQueue process_message_queue);
   static bool ExecuteModule(Isolate* isolate, const char* file_name);
-  static bool TakeWebSnapshot(Isolate* isolate);
-  static bool ExecuteWebSnapshot(Isolate* isolate, const char* file_name);
   static bool LoadJSON(Isolate* isolate, const char* file_name);
   static void ReportException(Isolate* isolate, Local<Message> message,
                               Local<Value> exception);
@@ -569,10 +557,6 @@ class Shell : public i::AllStatic {
                              const PropertyCallbackInfo<Value>& info);
   static void RealmSharedSet(Local<String> property, Local<Value> value,
                              const PropertyCallbackInfo<void>& info);
-  static void RealmTakeWebSnapshot(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RealmUseWebSnapshot(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void LogGetAndStop(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void TestVerifySourcePositions(
@@ -737,8 +721,6 @@ class Shell : public i::AllStatic {
 
   static void PromiseRejectCallback(v8::PromiseRejectMessage reject_message);
 
-  static Local<FunctionTemplate> CreateSnapshotTemplate(Isolate* isolate);
-
  private:
   static inline int DeserializationRunCount() {
     return options.stress_deserialize ? 1000 : 1;
diff --git a/src/diagnostics/objects-debug.cc b/src/diagnostics/objects-debug.cc
index b8b47659ac..02e980c816 100644
--- a/src/diagnostics/objects-debug.cc
+++ b/src/diagnostics/objects-debug.cc
@@ -1898,12 +1898,6 @@ void AllocationSite::AllocationSiteVerify(Isolate* isolate) {
 
 void Script::ScriptVerify(Isolate* isolate) {
   TorqueGeneratedClassVerifiers::ScriptVerify(*this, isolate);
-  if (V8_UNLIKELY(type() == Script::TYPE_WEB_SNAPSHOT)) {
-    CHECK_LE(shared_function_info_count(), shared_function_infos().length());
-  } else {
-    // No overallocating shared_function_infos.
-    CHECK_EQ(shared_function_info_count(), shared_function_infos().length());
-  }
   for (int i = 0; i < shared_function_info_count(); ++i) {
     MaybeObject maybe_object = shared_function_infos().Get(i);
     HeapObject heap_object;
diff --git a/src/diagnostics/objects-printer.cc b/src/diagnostics/objects-printer.cc
index fed1d2a036..7673e83a7e 100644
--- a/src/diagnostics/objects-printer.cc
+++ b/src/diagnostics/objects-printer.cc
@@ -2374,9 +2374,6 @@ void Script::ScriptPrint(std::ostream& os) {
       os << "\n - eval from shared: " << Brief(eval_from_shared());
     } else if (is_wrapped()) {
       os << "\n - wrapped arguments: " << Brief(wrapped_arguments());
-    } else if (type() == TYPE_WEB_SNAPSHOT) {
-      os << "\n - shared function info table: "
-         << Brief(shared_function_info_table());
     }
     os << "\n - eval from position: " << eval_from_position();
   }
diff --git a/src/flags/flag-definitions.h b/src/flags/flag-definitions.h
index 7a5c547a17..497e5a890c 100644
--- a/src/flags/flag-definitions.h
+++ b/src/flags/flag-definitions.h
@@ -589,7 +589,6 @@ DEFINE_BOOL(trace_block_coverage, false,
             "trace collected block coverage information")
 DEFINE_BOOL(trace_protector_invalidation, false,
             "trace protector cell invalidations")
-DEFINE_BOOL(trace_web_snapshot, false, "trace web snapshot deserialization")
 
 DEFINE_BOOL(feedback_normalization, false,
             "feed back normalization to constructors")
@@ -2392,12 +2391,6 @@ DEFINE_NEG_IMPLICATION(single_threaded_gc, concurrent_array_buffer_sweeping)
 DEFINE_NEG_IMPLICATION(single_threaded_gc, stress_concurrent_allocation)
 DEFINE_NEG_IMPLICATION(single_threaded_gc, cppheap_concurrent_marking)
 
-// Web snapshots: 1) expose WebSnapshot.* API 2) interpret scripts as web
-// snapshots if they start with a magic number.
-// TODO(v8:11525): Remove this flag once proper embedder integration is done.
-DEFINE_BOOL(experimental_web_snapshots, false, "enable Web Snapshots")
-DEFINE_NEG_IMPLICATION(experimental_web_snapshots, script_streaming)
-
 #if defined(V8_USE_LIBM_TRIG_FUNCTIONS)
 DEFINE_BOOL(use_libm_trig_functions, true, "use libm trig functions")
 #endif
diff --git a/src/heap/factory-base.cc b/src/heap/factory-base.cc
index 31e249e117..4e2a7490a3 100644
--- a/src/heap/factory-base.cc
+++ b/src/heap/factory-base.cc
@@ -280,8 +280,8 @@ Handle<Script> FactoryBase<Impl>::NewScriptWithId(
     raw.set_context_data(roots.undefined_value(), SKIP_WRITE_BARRIER);
     raw.set_type(Script::TYPE_NORMAL);
     raw.set_line_ends(roots.undefined_value(), SKIP_WRITE_BARRIER);
-    raw.set_eval_from_shared_or_wrapped_arguments_or_sfi_table(
-        roots.undefined_value(), SKIP_WRITE_BARRIER);
+    raw.set_eval_from_shared_or_wrapped_arguments(roots.undefined_value(),
+                                                  SKIP_WRITE_BARRIER);
     raw.set_eval_from_position(0);
     raw.set_shared_function_infos(roots.empty_weak_fixed_array(),
                                   SKIP_WRITE_BARRIER);
diff --git a/src/heap/factory-base.h b/src/heap/factory-base.h
index 4c23839e3a..d4b66b07b9 100644
--- a/src/heap/factory-base.h
+++ b/src/heap/factory-base.h
@@ -338,7 +338,6 @@ class FactoryBase : public TorqueGeneratedFactory<Impl> {
                                               AllocationType allocation);
 
  private:
-  friend class WebSnapshotDeserializer;
   Impl* impl() { return static_cast<Impl*>(this); }
   auto isolate() { return impl()->isolate(); }
   ReadOnlyRoots read_only_roots() { return impl()->read_only_roots(); }
diff --git a/src/heap/factory.cc b/src/heap/factory.cc
index 4d1cdc6da5..a8e0f95c9a 100644
--- a/src/heap/factory.cc
+++ b/src/heap/factory.cc
@@ -1512,8 +1512,8 @@ Handle<Script> Factory::CloneScript(Handle<Script> script) {
     new_script.set_context_data(old_script.context_data());
     new_script.set_type(old_script.type());
     new_script.set_line_ends(*undefined_value(), SKIP_WRITE_BARRIER);
-    new_script.set_eval_from_shared_or_wrapped_arguments_or_sfi_table(
-        script->eval_from_shared_or_wrapped_arguments_or_sfi_table());
+    new_script.set_eval_from_shared_or_wrapped_arguments(
+        script->eval_from_shared_or_wrapped_arguments());
     new_script.set_shared_function_infos(*empty_weak_fixed_array(),
                                          SKIP_WRITE_BARRIER);
     new_script.set_eval_from_position(old_script.eval_from_position());
@@ -3366,12 +3366,6 @@ Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForBuiltin(
   return shared;
 }
 
-Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForWebSnapshot() {
-  return NewSharedFunctionInfo(empty_string(), MaybeHandle<InstructionStream>(),
-                               Builtin::kNoBuiltinId,
-                               FunctionKind::kNormalFunction);
-}
-
 int Factory::NumberToStringCacheHash(Smi number) {
   int mask = (number_string_cache()->length() >> 1) - 1;
   return number.value() & mask;
diff --git a/src/heap/factory.h b/src/heap/factory.h
index b02edcbd19..14d7c49a40 100644
--- a/src/heap/factory.h
+++ b/src/heap/factory.h
@@ -809,8 +809,6 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
       MaybeHandle<String> name, Builtin builtin,
       FunctionKind kind = FunctionKind::kNormalFunction);
 
-  Handle<SharedFunctionInfo> NewSharedFunctionInfoForWebSnapshot();
-
   static bool IsFunctionModeWithPrototype(FunctionMode function_mode) {
     return (function_mode & kWithPrototypeBits) != 0;
   }
@@ -1054,7 +1052,6 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
 
  private:
   friend class FactoryBase<Factory>;
-  friend class WebSnapshotDeserializer;
 
   // ------
   // Customization points for FactoryBase
diff --git a/src/init/bootstrapper.cc b/src/init/bootstrapper.cc
index 3fadd990fb..867df5f4c4 100644
--- a/src/init/bootstrapper.cc
+++ b/src/init/bootstrapper.cc
@@ -246,8 +246,6 @@ class Genesis {
 #undef DECLARE_FEATURE_INITIALIZATION
   void InitializeGlobal_regexp_linear_flag();
 
-  void InitializeGlobal_experimental_web_snapshots();
-
   enum ArrayBufferKind { ARRAY_BUFFER, SHARED_ARRAY_BUFFER };
   Handle<JSFunction> CreateArrayBuffer(Handle<String> name,
                                        ArrayBufferKind array_buffer_kind);
@@ -4150,7 +4148,6 @@ void Genesis::InitializeExperimentalGlobal() {
   HARMONY_INPROGRESS(FEATURE_INITIALIZE_GLOBAL)
 #undef FEATURE_INITIALIZE_GLOBAL
   InitializeGlobal_regexp_linear_flag();
-  InitializeGlobal_experimental_web_snapshots();
 }
 
 bool Genesis::CompileExtension(Isolate* isolate, v8::Extension* extension) {
@@ -5556,21 +5553,6 @@ void Genesis::InitializeGlobal_harmony_intl_number_format_v3() {
 
 #endif  // V8_INTL_SUPPORT
 
-void Genesis::InitializeGlobal_experimental_web_snapshots() {
-  if (!v8_flags.experimental_web_snapshots) return;
-
-  Handle<JSGlobalObject> global(native_context()->global_object(), isolate());
-  Handle<JSObject> web_snapshot_object =
-      factory()->NewJSObject(isolate_->object_function(), AllocationType::kOld);
-  JSObject::AddProperty(isolate_, global, "WebSnapshot", web_snapshot_object,
-                        DONT_ENUM);
-  InstallToStringTag(isolate_, web_snapshot_object, "WebSnapshot");
-  SimpleInstallFunction(isolate_, web_snapshot_object, "serialize",
-                        Builtin::kWebSnapshotSerialize, 2, false);
-  SimpleInstallFunction(isolate_, web_snapshot_object, "deserialize",
-                        Builtin::kWebSnapshotDeserialize, 2, false);
-}
-
 #ifdef V8_INTL_SUPPORT
 void Genesis::InitializeGlobal_harmony_intl_duration_format() {
   if (!v8_flags.harmony_intl_duration_format) return;
diff --git a/src/logging/runtime-call-stats.h b/src/logging/runtime-call-stats.h
index 780151aa60..fca5d54c31 100644
--- a/src/logging/runtime-call-stats.h
+++ b/src/logging/runtime-call-stats.h
@@ -494,21 +494,6 @@ class RuntimeCallTimer final {
   V(TestCounter2)                              \
   V(TestCounter3)                              \
   V(UpdateProtector)                           \
-  V(WebSnapshotDeserialize)                    \
-  V(WebSnapshotDeserialize_Arrays)             \
-  V(WebSnapshotDeserialize_ArrayBuffers)       \
-  V(WebSnapshotDeserialize_BigInts)            \
-  V(WebSnapshotDeserialize_BuiltinObjects)     \
-  V(WebSnapshotDeserialize_Classes)            \
-  V(WebSnapshotDeserialize_Contexts)           \
-  V(WebSnapshotDeserialize_DataViews)          \
-  V(WebSnapshotDeserialize_Exports)            \
-  V(WebSnapshotDeserialize_Functions)          \
-  V(WebSnapshotDeserialize_Maps)               \
-  V(WebSnapshotDeserialize_Objects)            \
-  V(WebSnapshotDeserialize_Strings)            \
-  V(WebSnapshotDeserialize_Symbols)            \
-  V(WebSnapshotDeserialize_TypedArrays)        \
   V(WrappedFunctionLengthGetter)               \
   V(WrappedFunctionNameGetter)
 
diff --git a/src/objects/bigint.h b/src/objects/bigint.h
index f98710d98d..44ac1815a4 100644
--- a/src/objects/bigint.h
+++ b/src/objects/bigint.h
@@ -73,9 +73,6 @@ void MutableBigInt_RightShiftAndCanonicalize(Address result_addr,
 class BigInt;
 class ValueDeserializer;
 class ValueSerializer;
-class WebSnapshotSerializerDeserializer;
-class WebSnapshotSerializer;
-class WebSnapshotDeserializer;
 
 #include "torque-generated/src/objects/bigint-tq.inc"
 
@@ -304,9 +301,6 @@ class BigInt : public BigIntBase {
   friend class StringToBigIntHelper;
   friend class ValueDeserializer;
   friend class ValueSerializer;
-  friend class WebSnapshotSerializerDeserializer;
-  friend class WebSnapshotSerializer;
-  friend class WebSnapshotDeserializer;
 
   // Special functions for StringToBigIntHelper:
   template <typename IsolateT>
diff --git a/src/objects/descriptor-array.h b/src/objects/descriptor-array.h
index 178e6d03af..7a907103a9 100644
--- a/src/objects/descriptor-array.h
+++ b/src/objects/descriptor-array.h
@@ -233,7 +233,6 @@ class DescriptorArray
   using EntryValueField = TaggedField<MaybeObject, kEntryValueOffset>;
 
  private:
-  friend class WebSnapshotDeserializer;
   DECL_INT16_ACCESSORS(filler16bits)
 
   inline void SetKey(InternalIndex descriptor_number, Name key);
diff --git a/src/objects/js-array-buffer.h b/src/objects/js-array-buffer.h
index d8e6c79719..dc97208336 100644
--- a/src/objects/js-array-buffer.h
+++ b/src/objects/js-array-buffer.h
@@ -391,7 +391,6 @@ class JSTypedArray
   template <typename IsolateT>
   friend class Deserializer;
   friend class Factory;
-  friend class WebSnapshotDeserializer;
 
   DECL_PRIMITIVE_SETTER(length, size_t)
   // Reads the "length" field, doesn't assert the TypedArray is not RAB / GSAB
diff --git a/src/objects/objects.cc b/src/objects/objects.cc
index f194b17fd2..2611c5abc0 100644
--- a/src/objects/objects.cc
+++ b/src/objects/objects.cc
@@ -5123,11 +5123,6 @@ MaybeHandle<SharedFunctionInfo> Script::FindSharedFunctionInfo(
     Handle<Script> script, IsolateT* isolate,
     FunctionLiteral* function_literal) {
   int function_literal_id = function_literal->function_literal_id();
-  if (V8_UNLIKELY(script->type() == Script::TYPE_WEB_SNAPSHOT &&
-                  function_literal_id >=
-                      script->shared_function_info_count())) {
-    return FindWebSnapshotSharedFunctionInfo(script, isolate, function_literal);
-  }
 
   CHECK_NE(function_literal_id, kFunctionLiteralIdInvalid);
   // If this check fails, the problem is most probably the function id
@@ -5149,77 +5144,6 @@ template MaybeHandle<SharedFunctionInfo> Script::FindSharedFunctionInfo(
     Handle<Script> script, LocalIsolate* isolate,
     FunctionLiteral* function_literal);
 
-MaybeHandle<SharedFunctionInfo> Script::FindWebSnapshotSharedFunctionInfo(
-    Handle<Script> script, Isolate* isolate,
-    FunctionLiteral* function_literal) {
-  // We might be able to de-dupe the SFI against a SFI that was
-  // created when deserializing the snapshot (or when calling a function which
-  // was included in the snapshot). In that case, we can find it based on the
-  // start position in shared_function_info_table.
-  Handle<ObjectHashTable> shared_function_info_table = handle(
-      ObjectHashTable::cast(script->shared_function_info_table()), isolate);
-  {
-    DisallowHeapAllocation no_gc;
-    Object index_object = shared_function_info_table->Lookup(
-        handle(Smi::FromInt(function_literal->start_position()), isolate));
-    if (!index_object.IsTheHole()) {
-      int index = Smi::cast(index_object).value();
-      DCHECK_LT(index, script->shared_function_info_count());
-      MaybeObject maybe_shared = script->shared_function_infos().Get(index);
-      HeapObject heap_object;
-      if (!maybe_shared->GetHeapObject(&heap_object)) {
-        // We found the correct location but it's not filled in (e.g., the weak
-        // pointer to the SharedFunctionInfo has been cleared). Record the
-        // location in the FunctionLiteral, so that it will be refilled later.
-        // SharedFunctionInfo::SetScript will write the SharedFunctionInfo in
-        // the shared_function_infos.
-        function_literal->set_function_literal_id(index);
-        return MaybeHandle<SharedFunctionInfo>();
-      }
-      SharedFunctionInfo shared = SharedFunctionInfo::cast(heap_object);
-      DCHECK_EQ(shared.StartPosition(), function_literal->start_position());
-      DCHECK_EQ(shared.EndPosition(), function_literal->end_position());
-      return handle(shared, isolate);
-    }
-  }
-
-  // It's possible that FunctionLiterals which were processed before this one
-  // were deduplicated against existing ones. Decrease function_literal_id to
-  // avoid holes in shared_function_infos.
-  int old_length = script->shared_function_info_count();
-  int function_literal_id = old_length;
-  function_literal->set_function_literal_id(function_literal_id);
-
-  // Also add to shared_function_info_table.
-  shared_function_info_table = ObjectHashTable::Put(
-      shared_function_info_table,
-      handle(Smi::FromInt(function_literal->start_position()), isolate),
-      handle(Smi::FromInt(function_literal_id), isolate));
-  script->set_shared_function_info_table(*shared_function_info_table);
-
-  // Grow shared_function_infos if needed (we don't know the correct amount of
-  // space needed upfront).
-  int new_length = old_length + 1;
-  Handle<WeakFixedArray> old_infos =
-      handle(script->shared_function_infos(), isolate);
-  if (new_length > old_infos->length()) {
-    int capacity = WeakArrayList::CapacityForLength(new_length);
-    Handle<WeakFixedArray> new_infos(
-        isolate->factory()->NewWeakFixedArray(capacity, AllocationType::kOld));
-    new_infos->CopyElements(isolate, 0, *old_infos, 0, old_length,
-                            WriteBarrierMode::UPDATE_WRITE_BARRIER);
-    script->set_shared_function_infos(*new_infos);
-  }
-  return MaybeHandle<SharedFunctionInfo>();
-}
-
-MaybeHandle<SharedFunctionInfo> Script::FindWebSnapshotSharedFunctionInfo(
-    Handle<Script> script, LocalIsolate* isolate,
-    FunctionLiteral* function_literal) {
-  // Off-thread serialization of web snapshots is not implemented.
-  UNREACHABLE();
-}
-
 Script::Iterator::Iterator(Isolate* isolate)
     : iterator_(isolate->heap()->script_list()) {}
 
diff --git a/src/objects/scope-info.h b/src/objects/scope-info.h
index e087d7e169..1593a720c1 100644
--- a/src/objects/scope-info.h
+++ b/src/objects/scope-info.h
@@ -316,8 +316,6 @@ class ScopeInfo : public TorqueGeneratedScopeInfo<ScopeInfo, HeapObject> {
   V8_EXPORT_PRIVATE uint32_t Hash();
 
  private:
-  friend class WebSnapshotDeserializer;
-
   int InlinedLocalNamesLookup(String name);
 
   int ContextLocalNamesIndex() const;
diff --git a/src/objects/script-inl.h b/src/objects/script-inl.h
index ffb208e003..6e40e796d3 100644
--- a/src/objects/script-inl.h
+++ b/src/objects/script-inl.h
@@ -25,7 +25,7 @@ NEVER_READ_ONLY_SPACE_IMPL(Script)
 
 #if V8_ENABLE_WEBASSEMBLY
 ACCESSORS_CHECKED(Script, wasm_breakpoint_infos, FixedArray,
-                  kEvalFromSharedOrWrappedArgumentsOrSfiTableOffset,
+                  kEvalFromSharedOrWrappedArgumentsOffset,
                   this->type() == TYPE_WASM)
 ACCESSORS_CHECKED(Script, wasm_managed_native_module, Object,
                   kEvalFromPositionOffset, this->type() == TYPE_WASM)
@@ -37,8 +37,8 @@ ACCESSORS_CHECKED(Script, wasm_weak_instance_list, WeakArrayList,
 #endif  // V8_ENABLE_WEBASSEMBLY
 
 SMI_ACCESSORS(Script, type, kScriptTypeOffset)
-ACCESSORS_CHECKED(Script, eval_from_shared_or_wrapped_arguments_or_sfi_table,
-                  Object, kEvalFromSharedOrWrappedArgumentsOrSfiTableOffset,
+ACCESSORS_CHECKED(Script, eval_from_shared_or_wrapped_arguments, Object,
+                  kEvalFromSharedOrWrappedArgumentsOffset,
                   CHECK_SCRIPT_NOT_WASM)
 SMI_ACCESSORS_CHECKED(Script, eval_from_position, kEvalFromPositionOffset,
                       CHECK_SCRIPT_NOT_WASM)
@@ -48,51 +48,32 @@ ACCESSORS(Script, compiled_lazy_function_positions, Object,
           kCompiledLazyFunctionPositionsOffset)
 
 bool Script::is_wrapped() const {
-  return eval_from_shared_or_wrapped_arguments_or_sfi_table().IsFixedArray() &&
-         type() != TYPE_WEB_SNAPSHOT;
+  return eval_from_shared_or_wrapped_arguments().IsFixedArray();
 }
 
 bool Script::has_eval_from_shared() const {
-  return eval_from_shared_or_wrapped_arguments_or_sfi_table()
-      .IsSharedFunctionInfo();
+  return eval_from_shared_or_wrapped_arguments().IsSharedFunctionInfo();
 }
 
 void Script::set_eval_from_shared(SharedFunctionInfo shared,
                                   WriteBarrierMode mode) {
   DCHECK(!is_wrapped());
-  DCHECK_NE(type(), TYPE_WEB_SNAPSHOT);
-  set_eval_from_shared_or_wrapped_arguments_or_sfi_table(shared, mode);
+  set_eval_from_shared_or_wrapped_arguments(shared, mode);
 }
 
 SharedFunctionInfo Script::eval_from_shared() const {
   DCHECK(has_eval_from_shared());
-  return SharedFunctionInfo::cast(
-      eval_from_shared_or_wrapped_arguments_or_sfi_table());
+  return SharedFunctionInfo::cast(eval_from_shared_or_wrapped_arguments());
 }
 
 void Script::set_wrapped_arguments(FixedArray value, WriteBarrierMode mode) {
   DCHECK(!has_eval_from_shared());
-  DCHECK_NE(type(), TYPE_WEB_SNAPSHOT);
-  set_eval_from_shared_or_wrapped_arguments_or_sfi_table(value, mode);
+  set_eval_from_shared_or_wrapped_arguments(value, mode);
 }
 
 FixedArray Script::wrapped_arguments() const {
   DCHECK(is_wrapped());
-  return FixedArray::cast(eval_from_shared_or_wrapped_arguments_or_sfi_table());
-}
-
-void Script::set_shared_function_info_table(ObjectHashTable value,
-                                            WriteBarrierMode mode) {
-  DCHECK(!has_eval_from_shared());
-  DCHECK(!is_wrapped());
-  DCHECK_EQ(type(), TYPE_WEB_SNAPSHOT);
-  set_eval_from_shared_or_wrapped_arguments_or_sfi_table(value, mode);
-}
-
-ObjectHashTable Script::shared_function_info_table() const {
-  DCHECK_EQ(type(), TYPE_WEB_SNAPSHOT);
-  return ObjectHashTable::cast(
-      eval_from_shared_or_wrapped_arguments_or_sfi_table());
+  return FixedArray::cast(eval_from_shared_or_wrapped_arguments());
 }
 
 DEF_GETTER(Script, shared_function_infos, WeakFixedArray) {
@@ -114,11 +95,6 @@ void Script::set_shared_function_infos(WeakFixedArray value,
 }
 
 int Script::shared_function_info_count() const {
-  if (V8_UNLIKELY(type() == TYPE_WEB_SNAPSHOT)) {
-    // +1 because the 0th element in shared_function_infos is reserved for the
-    // top-level SharedFunctionInfo which doesn't exist.
-    return shared_function_info_table().NumberOfElements() + 1;
-  }
   return shared_function_infos().length();
 }
 
diff --git a/src/objects/script.h b/src/objects/script.h
index 7e33d9fdb7..fea0014f6d 100644
--- a/src/objects/script.h
+++ b/src/objects/script.h
@@ -46,8 +46,7 @@ class Script : public TorqueGeneratedScript<Script, Struct> {
 #if V8_ENABLE_WEBASSEMBLY
     TYPE_WASM = 3,
 #endif  // V8_ENABLE_WEBASSEMBLY
-    TYPE_INSPECTOR = 4,
-    TYPE_WEB_SNAPSHOT = 5
+    TYPE_INSPECTOR = 4
   };
 
   // Script compilation types.
@@ -62,7 +61,7 @@ class Script : public TorqueGeneratedScript<Script, Struct> {
   // [type]: the script type.
   DECL_INT_ACCESSORS(type)
 
-  DECL_ACCESSORS(eval_from_shared_or_wrapped_arguments_or_sfi_table, Object)
+  DECL_ACCESSORS(eval_from_shared_or_wrapped_arguments, Object)
 
   // [eval_from_shared]: for eval scripts the shared function info for the
   // function from which eval was called.
@@ -71,12 +70,6 @@ class Script : public TorqueGeneratedScript<Script, Struct> {
   // [wrapped_arguments]: for the list of arguments in a wrapped script.
   DECL_ACCESSORS(wrapped_arguments, FixedArray)
 
-  // For web snapshots: a hash table mapping function positions to indices in
-  // shared_function_infos.
-  // TODO(v8:11525): Replace with a more efficient data structure mapping
-  // function positions to weak pointers to SharedFunctionInfos directly.
-  DECL_ACCESSORS(shared_function_info_table, ObjectHashTable)
-
   // Whether the script is implicitly wrapped in a function.
   inline bool is_wrapped() const;
 
@@ -221,14 +214,6 @@ class Script : public TorqueGeneratedScript<Script, Struct> {
       Handle<Script> script, IsolateT* isolate,
       FunctionLiteral* function_literal);
 
-  static MaybeHandle<SharedFunctionInfo> FindWebSnapshotSharedFunctionInfo(
-      Handle<Script> script, Isolate* isolate,
-      FunctionLiteral* function_literal);
-
-  static MaybeHandle<SharedFunctionInfo> FindWebSnapshotSharedFunctionInfo(
-      Handle<Script> script, LocalIsolate* isolate,
-      FunctionLiteral* function_literal);
-
   // Iterate over all script objects on the heap.
   class V8_EXPORT_PRIVATE Iterator {
    public:
diff --git a/src/objects/script.tq b/src/objects/script.tq
index 5851169517..a0e0c9dc46 100644
--- a/src/objects/script.tq
+++ b/src/objects/script.tq
@@ -42,10 +42,9 @@ extern class Script extends Struct {
 
   // For scripts originating from eval: the SharedFunctionInfo contains the SFI
   // for the script. For scripts wrapped as functions: the FixedArray contains
-  // the arguments. For web snapshots: the ObjectHashTable maps function start
-  // position to SFI index in shared_function_infos.
-  eval_from_shared_or_wrapped_arguments_or_sfi_table: SharedFunctionInfo|
-      FixedArray|ObjectHashTable|Undefined;
+  // the arguments.
+  eval_from_shared_or_wrapped_arguments: SharedFunctionInfo|FixedArray|
+      Undefined;
   eval_from_position: Smi|Foreign;  // Smi or Managed<wasm::NativeModule>
   shared_function_infos: WeakFixedArray|WeakArrayList;
 
diff --git a/src/objects/shared-function-info.h b/src/objects/shared-function-info.h
index 082946ac05..509a95bf4f 100644
--- a/src/objects/shared-function-info.h
+++ b/src/objects/shared-function-info.h
@@ -689,8 +689,6 @@ class SharedFunctionInfo
                                      Isolate* isolate);
 
  private:
-  friend class WebSnapshotDeserializer;
-
 #ifdef VERIFY_HEAP
   void SharedFunctionInfoVerify(ReadOnlyRoots roots);
 #endif
diff --git a/src/objects/value-serializer.h b/src/objects/value-serializer.h
index 67a81a3b7c..13156b99dd 100644
--- a/src/objects/value-serializer.h
+++ b/src/objects/value-serializer.h
@@ -98,8 +98,6 @@ class ValueSerializer {
   void SetTreatArrayBufferViewsAsHostObjects(bool mode);
 
  private:
-  friend class WebSnapshotSerializer;
-
   // Managing allocations of the internal buffer.
   Maybe<bool> ExpandBuffer(size_t required_capacity);
 
@@ -249,8 +247,6 @@ class ValueDeserializer {
   bool ReadByte(uint8_t* value) V8_WARN_UNUSED_RESULT;
 
  private:
-  friend class WebSnapshotDeserializer;
-
   // Reading the wire format.
   Maybe<SerializationTag> PeekTag() const V8_WARN_UNUSED_RESULT;
   void ConsumeTag(SerializationTag peeked_tag);
diff --git a/src/parsing/parser.cc b/src/parsing/parser.cc
index bb5c053093..7e78ad5493 100644
--- a/src/parsing/parser.cc
+++ b/src/parsing/parser.cc
@@ -889,15 +889,6 @@ void Parser::ParseFunction(Isolate* isolate, ParseInfo* info,
   }
 
   int function_literal_id = shared_info->function_literal_id();
-  if (V8_UNLIKELY(script->type() == Script::TYPE_WEB_SNAPSHOT)) {
-    // Function literal IDs for inner functions haven't been allocated when
-    // deserializing. Put the inner function SFIs to the end of the list;
-    // they'll be deduplicated later (if the corresponding SFIs exist already)
-    // in Script::FindSharedFunctionInfo. (-1 here because function_literal_id
-    // is the parent's id. The inner function will get ids starting from
-    // function_literal_id + 1.)
-    function_literal_id = script->shared_function_info_count() - 1;
-  }
 
   // Initialize parser state.
   info->set_function_name(ast_value_factory()->GetString(
diff --git a/src/runtime/runtime-test.cc b/src/runtime/runtime-test.cc
index 5560d24052..cb86710db1 100644
--- a/src/runtime/runtime-test.cc
+++ b/src/runtime/runtime-test.cc
@@ -36,7 +36,6 @@
 #include "src/profiler/heap-snapshot-generator.h"
 #include "src/regexp/regexp.h"
 #include "src/snapshot/snapshot.h"
-#include "src/web-snapshot/web-snapshot.h"
 
 #ifdef V8_ENABLE_MAGLEV
 #include "src/maglev/maglev.h"
diff --git a/src/web-snapshot/web-snapshot.cc b/src/web-snapshot/web-snapshot.cc
deleted file mode 100644
index 5278accd8c..0000000000
--- a/src/web-snapshot/web-snapshot.cc
+++ /dev/null
@@ -1,4289 +0,0 @@
-// Copyright 2021 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/web-snapshot/web-snapshot.h"
-
-#include <limits>
-
-#include "include/v8-isolate.h"
-#include "include/v8-local-handle.h"
-#include "include/v8-object.h"
-#include "include/v8-primitive.h"
-#include "include/v8-script.h"
-#include "src/api/api-inl.h"
-#include "src/handles/handles.h"
-#include "src/logging/runtime-call-stats-scope.h"
-#include "src/objects/bigint.h"
-#include "src/objects/contexts-inl.h"
-#include "src/objects/js-array-buffer-inl.h"
-#include "src/objects/js-regexp-inl.h"
-#include "src/objects/script.h"
-
-namespace v8 {
-namespace internal {
-
-constexpr uint8_t WebSnapshotSerializerDeserializer::kMagicNumber[4];
-constexpr int WebSnapshotSerializerDeserializer::kBuiltinObjectCount;
-
-// When encountering an error during deserializing, we note down the error but
-// don't bail out from processing the snapshot further. This is to speed up
-// deserialization; the error case is now slower since we don't bail out, but
-// the non-error case is faster, since we don't repeatedly check for errors.
-// (Invariant: we might fill our internal data structures with arbitrary data,
-// but it shouldn't have an observable effect.)
-
-// This doesn't increase the complexity of processing the data in a robust and
-// secure way. We cannot trust the data anyway, so every upcoming byte can have
-// an arbitrary value, not depending on whether or not we've encountered an
-// error before.
-void WebSnapshotSerializerDeserializer::Throw(const char* message) {
-  if (error_message_ != nullptr) {
-    return;
-  }
-  error_message_ = message;
-  if (!isolate_->has_pending_exception()) {
-    isolate_->Throw(*factory()->NewError(
-        MessageTemplate::kWebSnapshotError,
-        factory()->NewStringFromAsciiChecked(error_message_)));
-  }
-}
-
-void WebSnapshotSerializerDeserializer::IterateBuiltinObjects(
-    std::function<void(Handle<String>, Handle<HeapObject>)> func) {
-  // TODO(v8:11525): Add more builtins.
-  auto roots = ReadOnlyRoots(isolate_);
-
-  func(handle(roots.Error_string(), isolate_),
-       handle(isolate_->context().error_function(), isolate_));
-
-  func(factory()->NewStringFromAsciiChecked("Error.prototype"),
-       handle(isolate_->context().error_function().instance_prototype(),
-              isolate_));
-
-  func(handle(roots.Object_string(), isolate_),
-       handle(isolate_->context().object_function(), isolate_));
-
-  func(factory()->NewStringFromAsciiChecked("Object.prototype"),
-       handle(isolate_->context().initial_object_prototype(), isolate_));
-
-  func(handle(roots.Function_string(), isolate_),
-       handle(isolate_->context().function_function(), isolate_));
-
-  func(factory()->NewStringFromAsciiChecked("Function.prototype"),
-       handle(isolate_->context().function_prototype(), isolate_));
-
-  // TODO(v8:11525): There are no obvious names for these, since AsyncFunction
-  // etc are not properties of the global object.
-
-  func(factory()->NewStringFromAsciiChecked("AsyncFunction"),
-       handle(isolate_->context().async_function_constructor(), isolate_));
-
-  func(
-      factory()->NewStringFromAsciiChecked("AsyncFunction"),
-      handle(
-          isolate_->context().async_function_constructor().instance_prototype(),
-          isolate_));
-
-  auto generator_function =
-      handle(JSFunction::cast(isolate_->context()
-                                  .generator_function_map()
-                                  .constructor_or_back_pointer()),
-             isolate_);
-  func(factory()->NewStringFromAsciiChecked("GeneratorFunction"),
-       generator_function);
-
-  func(factory()->NewStringFromAsciiChecked("GeneratorFunction.prototype"),
-       handle(generator_function->instance_prototype(), isolate_));
-
-  auto async_generator_function =
-      handle(JSFunction::cast(isolate_->context()
-                                  .async_generator_function_map()
-                                  .constructor_or_back_pointer()),
-             isolate_);
-  func(factory()->NewStringFromAsciiChecked("AsyncGeneratorFunction"),
-       async_generator_function);
-
-  func(factory()->NewStringFromAsciiChecked("AsyncGeneratorFunction.prototype"),
-       handle(async_generator_function->instance_prototype(), isolate_));
-
-  static_assert(kBuiltinObjectCount == 12);
-}
-
-uint8_t WebSnapshotSerializerDeserializer::FunctionKindToFunctionFlags(
-    FunctionKind kind) {
-  // TODO(v8:11525): Support more function kinds.
-  switch (kind) {
-    case FunctionKind::kNormalFunction:
-    case FunctionKind::kArrowFunction:
-    case FunctionKind::kGeneratorFunction:
-    case FunctionKind::kAsyncFunction:
-    case FunctionKind::kAsyncArrowFunction:
-    case FunctionKind::kAsyncGeneratorFunction:
-    case FunctionKind::kBaseConstructor:
-    case FunctionKind::kDefaultBaseConstructor:
-    case FunctionKind::kDerivedConstructor:
-    case FunctionKind::kDefaultDerivedConstructor:
-    case FunctionKind::kConciseMethod:
-    case FunctionKind::kAsyncConciseMethod:
-    case FunctionKind::kStaticConciseMethod:
-    case FunctionKind::kStaticAsyncConciseMethod:
-    case FunctionKind::kStaticConciseGeneratorMethod:
-    case FunctionKind::kStaticAsyncConciseGeneratorMethod:
-      break;
-    default:
-      Throw("Unsupported function kind");
-  }
-  auto flags = AsyncFunctionBitField::encode(IsAsyncFunction(kind)) |
-               GeneratorFunctionBitField::encode(IsGeneratorFunction(kind)) |
-               ArrowFunctionBitField::encode(IsArrowFunction(kind)) |
-               MethodBitField::encode(IsConciseMethod(kind)) |
-               StaticBitField::encode(IsStatic(kind)) |
-               ClassConstructorBitField::encode(IsClassConstructor(kind)) |
-               DefaultConstructorBitField::encode(IsDefaultConstructor(kind)) |
-               DerivedConstructorBitField::encode(IsDerivedConstructor(kind));
-  return flags;
-}
-
-// TODO(v8:11525): Optionally, use an enum instead.
-FunctionKind WebSnapshotSerializerDeserializer::FunctionFlagsToFunctionKind(
-    uint8_t flags) {
-  FunctionKind kind;
-  if (IsFunctionOrMethod(flags)) {
-    if (ArrowFunctionBitField::decode(flags) && MethodBitField::decode(flags)) {
-      kind = FunctionKind::kInvalid;
-    } else {
-      uint32_t index = AsyncFunctionBitField::decode(flags) << 0 |
-                       GeneratorFunctionBitField::decode(flags) << 1 |
-                       (ArrowFunctionBitField::decode(flags) ||
-                        StaticBitField::decode(flags))
-                           << 2 |
-                       MethodBitField::decode(flags) << 3;
-      static const FunctionKind kFunctionKinds[] = {
-          // kNormalFunction
-          // is_generator = false
-          FunctionKind::kNormalFunction,  // is_async = false
-          FunctionKind::kAsyncFunction,   // is_async = true
-          // is_generator = true
-          FunctionKind::kGeneratorFunction,       // is_async = false
-          FunctionKind::kAsyncGeneratorFunction,  // is_async = true
-
-          // kArrowFunction
-          // is_generator = false
-          FunctionKind::kArrowFunction,       // is_async = false
-          FunctionKind::kAsyncArrowFunction,  // is_async = true
-          // is_generator = true
-          FunctionKind::kInvalid,  // is_async = false
-          FunctionKind::kInvalid,  // is_async = true
-
-          // kNonStaticMethod
-          // is_generator = false
-          FunctionKind::kConciseMethod,       // is_async = false
-          FunctionKind::kAsyncConciseMethod,  // is_async = true
-          // is_generator = true
-          // TODO(v8::11525) Support FunctionKind::kConciseGeneratorMethod.
-          FunctionKind::kInvalid,  // is_async = false
-          // TODO(v8::11525) Support FunctionKind::kAsyncConciseGeneratorMethod.
-          FunctionKind::kInvalid,  // is_async = true
-
-          // kStaticMethod
-          // is_generator = false
-          FunctionKind::kStaticConciseMethod,       // is_async = false
-          FunctionKind::kStaticAsyncConciseMethod,  // is_async = true
-          // is_generator = true
-          FunctionKind::kStaticConciseGeneratorMethod,      // is_async = false
-          FunctionKind::kStaticAsyncConciseGeneratorMethod  // is_async = true
-      };
-      kind = kFunctionKinds[index];
-    }
-  } else if (IsConstructor(flags)) {
-    static const FunctionKind kFunctionKinds[] = {
-        // is_derived = false
-        FunctionKind::kBaseConstructor,         // is_default = false
-        FunctionKind::kDefaultBaseConstructor,  // is_default = true
-        // is_derived = true
-        FunctionKind::kDerivedConstructor,        // is_default = false
-        FunctionKind::kDefaultDerivedConstructor  // is_default = true
-    };
-    kind = kFunctionKinds[flags >> DefaultConstructorBitField::kShift];
-  } else {
-    kind = FunctionKind::kInvalid;
-  }
-  if (kind == FunctionKind::kInvalid) {
-    Throw("Invalid function flags\n");
-  }
-  return kind;
-}
-
-bool WebSnapshotSerializerDeserializer::IsFunctionOrMethod(uint8_t flags) {
-  uint32_t mask = AsyncFunctionBitField::kMask |
-                  GeneratorFunctionBitField::kMask |
-                  ArrowFunctionBitField::kMask | MethodBitField::kMask |
-                  StaticBitField::kMask;
-  return (flags & mask) == flags;
-}
-
-bool WebSnapshotSerializerDeserializer::IsConstructor(uint8_t flags) {
-  uint32_t mask = ClassConstructorBitField::kMask |
-                  DefaultConstructorBitField::kMask |
-                  DerivedConstructorBitField::kMask;
-  return ClassConstructorBitField::decode(flags) && (flags & mask) == flags;
-}
-
-uint8_t WebSnapshotSerializerDeserializer::GetDefaultAttributeFlags() {
-  auto flags = ReadOnlyBitField::encode(false) |
-               ConfigurableBitField::encode(true) |
-               EnumerableBitField::encode(true);
-  return flags;
-}
-
-uint8_t WebSnapshotSerializerDeserializer::AttributesToFlags(
-    PropertyDetails details) {
-  auto flags = ReadOnlyBitField::encode(details.IsReadOnly()) |
-               ConfigurableBitField::encode(details.IsConfigurable()) |
-               EnumerableBitField::encode(details.IsEnumerable());
-  return flags;
-}
-
-PropertyAttributes WebSnapshotSerializerDeserializer::FlagsToAttributes(
-    uint8_t flags) {
-  int attributes = ReadOnlyBitField::decode(flags) * READ_ONLY +
-                   !ConfigurableBitField::decode(flags) * DONT_DELETE +
-                   !EnumerableBitField::decode(flags) * DONT_ENUM;
-  return PropertyAttributesFromInt(attributes);
-}
-
-WebSnapshotSerializer::WebSnapshotSerializer(v8::Isolate* isolate)
-    : WebSnapshotSerializer(reinterpret_cast<v8::internal::Isolate*>(isolate)) {
-}
-
-WebSnapshotSerializer::WebSnapshotSerializer(Isolate* isolate)
-    : WebSnapshotSerializerDeserializer(isolate),
-      string_serializer_(isolate_, nullptr),
-      symbol_serializer_(isolate_, nullptr),
-      bigint_serializer_(isolate_, nullptr),
-      map_serializer_(isolate_, nullptr),
-      builtin_object_serializer_(isolate_, nullptr),
-      context_serializer_(isolate_, nullptr),
-      function_serializer_(isolate_, nullptr),
-      class_serializer_(isolate_, nullptr),
-      array_serializer_(isolate_, nullptr),
-      typed_array_serializer_(isolate_, nullptr),
-      array_buffer_serializer_(isolate_, nullptr),
-      data_view_serializer_(isolate_, nullptr),
-      object_serializer_(isolate_, nullptr),
-      export_serializer_(isolate_, nullptr),
-      external_object_ids_(isolate_->heap()),
-      string_ids_(isolate_->heap()),
-      symbol_ids_(isolate_->heap()),
-      bigint_ids_(isolate_->heap()),
-      map_ids_(isolate_->heap()),
-      context_ids_(isolate_->heap()),
-      function_ids_(isolate_->heap()),
-      class_ids_(isolate_->heap()),
-      array_ids_(isolate_->heap()),
-      typed_array_ids_(isolate->heap()),
-      array_buffer_ids_(isolate->heap()),
-      data_view_ids_(isolate->heap()),
-      object_ids_(isolate_->heap()),
-      builtin_object_to_name_(isolate_->heap()),
-      builtin_object_ids_(isolate_->heap()),
-      all_strings_(isolate_->heap()) {
-  auto empty_array_list = factory()->empty_array_list();
-  strings_ = empty_array_list;
-  symbols_ = empty_array_list;
-  bigints_ = empty_array_list;
-  maps_ = empty_array_list;
-  contexts_ = empty_array_list;
-  functions_ = empty_array_list;
-  classes_ = empty_array_list;
-  arrays_ = empty_array_list;
-  array_buffers_ = empty_array_list;
-  typed_arrays_ = empty_array_list;
-  data_views_ = empty_array_list;
-  objects_ = empty_array_list;
-}
-
-WebSnapshotSerializer::~WebSnapshotSerializer() {}
-
-bool WebSnapshotSerializer::TakeSnapshot(
-    Handle<Object> object, MaybeHandle<FixedArray> maybe_externals,
-    WebSnapshotData& data_out) {
-  if (string_ids_.size() > 0) {
-    Throw("Can't reuse WebSnapshotSerializer");
-    return false;
-  }
-  if (!maybe_externals.is_null()) {
-    ShallowDiscoverExternals(*maybe_externals.ToHandleChecked());
-  }
-
-  v8::Local<v8::Context> context =
-      reinterpret_cast<v8::Isolate*>(isolate_)->GetCurrentContext();
-  ShallowDiscoverBuiltinObjects(context);
-
-  if (object->IsHeapObject()) Discover(Handle<HeapObject>::cast(object));
-
-  ConstructSource();
-  // The export is serialized with the empty string as name; we need to
-  // "discover" the name here.
-  DiscoverString(factory()->empty_string());
-  SerializeExport(object, factory()->empty_string());
-
-  WriteSnapshot(data_out.buffer, data_out.buffer_size);
-
-  if (has_error()) {
-    isolate_->ReportPendingMessages();
-    return false;
-  }
-  return true;
-}
-
-bool WebSnapshotSerializer::TakeSnapshot(v8::Local<v8::Context> context,
-                                         v8::Local<v8::PrimitiveArray> exports,
-                                         WebSnapshotData& data_out) {
-  if (string_ids_.size() > 0) {
-    Throw("Can't reuse WebSnapshotSerializer");
-    return false;
-  }
-  v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
-
-  ShallowDiscoverBuiltinObjects(context);
-
-  Handle<FixedArray> export_objects =
-      isolate_->factory()->NewFixedArray(exports->Length());
-  for (int i = 0, length = exports->Length(); i < length; ++i) {
-    v8::Local<v8::String> str =
-        exports->Get(v8_isolate, i)->ToString(context).ToLocalChecked();
-    if (str->Length() == 0) {
-      continue;
-    }
-    // Discover the export name.
-    DiscoverString(Handle<String>::cast(Utils::OpenHandle(*str)));
-    v8::ScriptCompiler::Source source(str);
-    auto script = ScriptCompiler::Compile(context, &source).ToLocalChecked();
-    v8::MaybeLocal<v8::Value> script_result = script->Run(context);
-    v8::Local<v8::Object> v8_object;
-    if (script_result.IsEmpty() ||
-        !script_result.ToLocalChecked()->ToObject(context).ToLocal(
-            &v8_object)) {
-      Throw("Exported object not found");
-      return false;
-    }
-    auto object = Handle<JSObject>::cast(Utils::OpenHandle(*v8_object));
-    export_objects->set(i, *object);
-    Discover(object);
-    // The error messages will be confusing if we continue running code when
-    // already in the error state.
-    if (has_error()) {
-      isolate_->ReportPendingMessages();
-      return false;
-    }
-  }
-
-  ConstructSource();
-
-  for (int i = 0, length = exports->Length(); i < length; ++i) {
-    v8::Local<v8::String> str =
-        exports->Get(v8_isolate, i)->ToString(context).ToLocalChecked();
-    if (str->Length() == 0) {
-      continue;
-    }
-    SerializeExport(handle(export_objects->get(i), isolate_),
-                    Handle<String>::cast(Utils::OpenHandle(*str)));
-  }
-
-  WriteSnapshot(data_out.buffer, data_out.buffer_size);
-
-  if (has_error()) {
-    isolate_->ReportPendingMessages();
-    return false;
-  }
-  return true;
-}
-
-void WebSnapshotSerializer::SerializePendingItems() {
-  // The information about string reference counts is now complete. The strings
-  // in strings_ are not in place and can be serialized now. The in-place
-  // strings will be serialized as part of their respective objects.
-  for (int i = 0; i < strings_->Length(); ++i) {
-    Handle<String> string = handle(String::cast(strings_->Get(i)), isolate_);
-    SerializeString(string, string_serializer_);
-  }
-
-  for (int i = 0; i < symbols_->Length(); ++i) {
-    Handle<Symbol> symbol = handle(Symbol::cast(symbols_->Get(i)), isolate_);
-    SerializeSymbol(symbol);
-  }
-
-  for (int i = 0; i < bigints_->Length(); ++i) {
-    Handle<BigInt> bigint = handle(BigInt::cast(bigints_->Get(i)), isolate_);
-    SerializeBigInt(bigint);
-  }
-
-  for (int i = 0; i < maps_->Length(); ++i) {
-    Handle<Map> map = handle(Map::cast(maps_->Get(i)), isolate_);
-    SerializeMap(map);
-  }
-  for (auto name_id : builtin_objects_) {
-    SerializeBuiltinObject(name_id);
-  }
-
-  for (int i = 0; i < contexts_->Length(); ++i) {
-    Handle<Context> context =
-        handle(Context::cast(contexts_->Get(i)), isolate_);
-    SerializeContext(context, static_cast<uint32_t>(i));
-  }
-
-  // Serialize the items in the reverse order. The items at the end of the
-  // functions_ etc get lower IDs and vice versa. IDs which items use for
-  // referring to each other are reversed by Get<item>Id() functions.
-  for (int i = functions_->Length() - 1; i >= 0; --i) {
-    Handle<JSFunction> function =
-        handle(JSFunction::cast(functions_->Get(i)), isolate_);
-    SerializeFunction(function);
-  }
-  for (int i = classes_->Length() - 1; i >= 0; --i) {
-    Handle<JSFunction> function =
-        handle(JSFunction::cast(classes_->Get(i)), isolate_);
-    SerializeClass(function);
-  }
-  for (int i = arrays_->Length() - 1; i >= 0; --i) {
-    Handle<JSArray> array = handle(JSArray::cast(arrays_->Get(i)), isolate_);
-    SerializeArray(array);
-  }
-  for (int i = array_buffers_->Length() - 1; i >= 0; --i) {
-    Handle<JSArrayBuffer> array_buffer =
-        handle(JSArrayBuffer::cast(array_buffers_->Get(i)), isolate_);
-    SerializeArrayBuffer(array_buffer);
-  }
-  for (int i = typed_arrays_->Length() - 1; i >= 0; --i) {
-    Handle<JSTypedArray> typed_array =
-        handle(JSTypedArray::cast(typed_arrays_->Get(i)), isolate_);
-    SerializeTypedArray(typed_array);
-  }
-  for (int i = data_views_->Length() - 1; i >= 0; --i) {
-    Handle<JSDataView> data_view =
-        handle(JSDataView::cast(data_views_->Get(i)), isolate_);
-    SerializeDataView(data_view);
-  }
-  for (int i = objects_->Length() - 1; i >= 0; --i) {
-    Handle<JSObject> object =
-        handle(JSObject::cast(objects_->Get(i)), isolate_);
-    SerializeObject(object);
-  }
-}
-
-// Format (full snapshot):
-// - Magic number (4 bytes)
-// - String count
-// - For each string:
-//   - Serialized string
-// - Symbol count
-// - For each symbol:
-//   - Serialized symbol
-// - Builtin object count
-// - For each builtin object:
-//   - Id of the builtin object name string
-// - Shape count
-// - For each shape:
-//   - Serialized shape
-// - Context count
-// - For each context:
-//   - Serialized context
-// - Function count
-// - For each function:
-//   - Serialized function
-// - Object count
-// - For each object:
-//   - Serialized object
-// - Export count
-// - For each export:
-//   - Serialized export
-void WebSnapshotSerializer::WriteSnapshot(uint8_t*& buffer,
-                                          size_t& buffer_size) {
-  if (has_error()) {
-    return;
-  }
-  SerializePendingItems();
-
-  ValueSerializer total_serializer(isolate_, nullptr);
-  size_t needed_size =
-      sizeof(kMagicNumber) + string_serializer_.buffer_size_ +
-      symbol_serializer_.buffer_size_ + bigint_serializer_.buffer_size_ +
-      builtin_object_serializer_.buffer_size_ + map_serializer_.buffer_size_ +
-      context_serializer_.buffer_size_ + function_serializer_.buffer_size_ +
-      class_serializer_.buffer_size_ + array_serializer_.buffer_size_ +
-      array_buffer_serializer_.buffer_size_ +
-      typed_array_serializer_.buffer_size_ +
-      data_view_serializer_.buffer_size_ + object_serializer_.buffer_size_ +
-      export_serializer_.buffer_size_ + 14 * sizeof(uint32_t);
-  if (total_serializer.ExpandBuffer(needed_size).IsNothing()) {
-    Throw("Out of memory");
-    return;
-  }
-
-  total_serializer.WriteRawBytes(kMagicNumber, 4);
-  WriteObjects(total_serializer, string_count(), string_serializer_, "strings");
-  WriteObjects(total_serializer, symbol_count(), symbol_serializer_, "symbols");
-  WriteObjects(total_serializer, bigint_count(), bigint_serializer_, "bigints");
-  WriteObjects(total_serializer, builtin_object_count(),
-               builtin_object_serializer_, "builtin_objects");
-  WriteObjects(total_serializer, map_count(), map_serializer_, "maps");
-  WriteObjects(total_serializer, context_count(), context_serializer_,
-               "contexts");
-  WriteObjects(total_serializer, function_count(), function_serializer_,
-               "functions");
-  WriteObjects(total_serializer, array_count(), array_serializer_, "arrays");
-  WriteObjects(total_serializer, array_buffer_count(), array_buffer_serializer_,
-               "array buffers");
-  WriteObjects(total_serializer, typed_array_count(), typed_array_serializer_,
-               "typed arrays");
-  WriteObjects(total_serializer, data_view_count(), data_view_serializer_,
-               "data views");
-  WriteObjects(total_serializer, object_count(), object_serializer_, "objects");
-  WriteObjects(total_serializer, class_count(), class_serializer_, "classes");
-  WriteObjects(total_serializer, export_count_, export_serializer_, "exports");
-
-  if (has_error()) {
-    return;
-  }
-
-  auto result = total_serializer.Release();
-  buffer = result.first;
-  buffer_size = result.second;
-}
-void WebSnapshotSerializer::WriteObjects(ValueSerializer& destination,
-                                         size_t count, ValueSerializer& source,
-                                         const char* name) {
-  if (count > std::numeric_limits<uint32_t>::max()) {
-    Throw("Too many objects");
-    return;
-  }
-  destination.WriteUint32(static_cast<uint32_t>(count));
-  destination.WriteRawBytes(source.buffer_, source.buffer_size_);
-}
-
-bool WebSnapshotSerializer::InsertIntoIndexMap(ObjectCacheIndexMap& map,
-                                               HeapObject heap_object,
-                                               uint32_t& id) {
-  DisallowGarbageCollection no_gc;
-  int index_out;
-  bool found = map.LookupOrInsert(heap_object, &index_out);
-  id = static_cast<uint32_t>(index_out);
-  return found;
-}
-
-// Format:
-// - Length
-// - Raw bytes (data)
-void WebSnapshotSerializer::SerializeString(Handle<String> string,
-                                            ValueSerializer& serializer) {
-  DisallowGarbageCollection no_gc;
-  String::FlatContent flat = string->GetFlatContent(no_gc);
-  DCHECK(flat.IsFlat());
-  if (flat.IsOneByte()) {
-    base::Vector<const uint8_t> chars = flat.ToOneByteVector();
-    serializer.WriteUint32(chars.length());
-    serializer.WriteRawBytes(chars.begin(), chars.length() * sizeof(uint8_t));
-  } else if (flat.IsTwoByte()) {
-    v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
-    v8::Local<v8::String> api_string = Utils::ToLocal(string);
-    int length = api_string->Utf8Length(v8_isolate);
-    std::unique_ptr<char[]> buffer(new char[length]);
-    api_string->WriteUtf8(v8_isolate, buffer.get(), length);
-    serializer.WriteUint32(length);
-    serializer.WriteRawBytes(buffer.get(), length * sizeof(uint8_t));
-  } else {
-    UNREACHABLE();
-  }
-}
-
-// Format (serialized symbol):
-// - 0 if the symbol is non-global and there's no description, 1 if the symbol
-// is non-global and there is a description, 2 if the symbol is global (there
-// must be a description).
-void WebSnapshotSerializer::SerializeSymbol(Handle<Symbol> symbol) {
-  if (symbol->description().IsUndefined()) {
-    CHECK(!symbol->is_in_public_symbol_table());
-    symbol_serializer_.WriteUint32(SymbolType::kNonGlobalNoDesription);
-  } else {
-    symbol_serializer_.WriteUint32(symbol->is_in_public_symbol_table()
-                                       ? SymbolType::kGlobal
-                                       : SymbolType::kNonGlobal);
-    WriteStringId(handle(String::cast(symbol->description()), isolate_),
-                  symbol_serializer_);
-  }
-}
-
-// Format (serialized bigint)
-// - BigIntFlags, including sign and byte length.
-// - digit bytes.
-void WebSnapshotSerializer::SerializeBigInt(Handle<BigInt> bigint) {
-  uint32_t flags = BigIntSignAndLengthToFlags(bigint);
-  bigint_serializer_.WriteUint32(flags);
-  int byte_length = BigIntLengthBitField::decode(flags);
-  uint8_t* dest;
-  if (bigint_serializer_.ReserveRawBytes(byte_length).To(&dest)) {
-    bigint->SerializeDigits(dest);
-  } else {
-    Throw("Serialize BigInt failed");
-    return;
-  }
-}
-
-bool WebSnapshotSerializer::ShouldBeSerialized(Handle<Name> key) {
-  // Don't serialize class_positions_symbol property in Class.
-  if (key->Equals(*factory()->class_positions_symbol())) {
-    return false;
-  }
-  return true;
-}
-
-// Format (serialized shape):
-// - PropertyAttributesType
-// - Property count
-// - For each property
-//   - Name: STRING_ID + String id or SYMBOL_ID + Symbol id or in-place string
-//   - If the PropertyAttributesType is CUSTOM: attributes
-// - __proto__: Serialized value
-void WebSnapshotSerializer::SerializeMap(Handle<Map> map) {
-  DCHECK(!map->is_dictionary_map());
-  int first_custom_index = -1;
-  std::vector<Handle<Name>> keys;
-  std::vector<uint8_t> attributes;
-  keys.reserve(map->NumberOfOwnDescriptors());
-  attributes.reserve(map->NumberOfOwnDescriptors());
-  for (InternalIndex i : map->IterateOwnDescriptors()) {
-    PropertyDetails details =
-        map->instance_descriptors(kRelaxedLoad).GetDetails(i);
-
-    // If there are non-field properties in a map that doesn't allow them, i.e.,
-    // a non-function map, DiscoverMap has already thrown.
-    if (details.location() != PropertyLocation::kField) {
-      continue;
-    }
-
-    Handle<Name> key(map->instance_descriptors(kRelaxedLoad).GetKey(i),
-                     isolate_);
-    if (!ShouldBeSerialized(key)) {
-      continue;
-    }
-    keys.push_back(key);
-    if (first_custom_index >= 0 || details.IsReadOnly() ||
-        !details.IsConfigurable() || details.IsDontEnum()) {
-      if (first_custom_index == -1) first_custom_index = i.as_int();
-      attributes.push_back(AttributesToFlags(details));
-    }
-  }
-
-  map_serializer_.WriteUint32(first_custom_index == -1
-                                  ? PropertyAttributesType::DEFAULT
-                                  : PropertyAttributesType::CUSTOM);
-
-  map_serializer_.WriteUint32(static_cast<uint32_t>(keys.size()));
-
-  uint8_t default_flags = GetDefaultAttributeFlags();
-  for (size_t i = 0; i < keys.size(); ++i) {
-    if (keys[i]->IsString()) {
-      WriteStringMaybeInPlace(Handle<String>::cast(keys[i]), map_serializer_);
-    } else if (keys[i]->IsSymbol()) {
-      map_serializer_.WriteByte(ValueType::SYMBOL_ID);
-      map_serializer_.WriteUint32(GetSymbolId(Symbol::cast(*keys[i])));
-    } else {
-      // This error should've been recognized in the discovery phase.
-      CHECK(false);
-    }
-    if (first_custom_index >= 0) {
-      if (static_cast<int>(i) < first_custom_index) {
-        map_serializer_.WriteByte(default_flags);
-      } else {
-        map_serializer_.WriteByte(attributes[i - first_custom_index]);
-      }
-    }
-  }
-
-  WriteValue(handle(map->prototype(), isolate_), map_serializer_);
-}
-
-void WebSnapshotSerializer::SerializeBuiltinObject(uint32_t name_id) {
-  builtin_object_serializer_.WriteUint32(name_id);
-}
-
-// Construct the minimal source string to be included in the snapshot. Maintain
-// the "inner function is textually inside its outer function" relationship.
-// Example:
-// Input:
-// Full source:       abcdefghijklmnopqrstuvwxyzåäö
-// Functions:            11111111       22222222  3
-// Inner functions:       44  55         666
-// Output:
-// Constructed source:   defghijkstuvwxyzö
-// Functions:            11111111222222223
-// Inner functions        44  55  666
-void WebSnapshotSerializer::ConstructSource() {
-  if (source_intervals_.empty()) {
-    return;
-  }
-
-  Handle<String> source_string = factory()->empty_string();
-  int current_interval_start = 0;
-  int current_interval_end = 0;
-  for (const auto& interval : source_intervals_) {
-    DCHECK_LE(current_interval_start, interval.first);  // Iterated in order.
-    DCHECK_LE(interval.first, interval.second);
-    if (interval.second <= current_interval_end) {
-      // This interval is fully within the current interval. We don't need to
-      // include any new source code, just record the position conversion.
-      auto offset_within_parent = interval.first - current_interval_start;
-      source_offset_to_compacted_source_offset_[interval.first] =
-          source_offset_to_compacted_source_offset_[current_interval_start] +
-          offset_within_parent;
-      continue;
-    }
-    // Start a new interval.
-    current_interval_start = interval.first;
-    current_interval_end = interval.second;
-    source_offset_to_compacted_source_offset_[current_interval_start] =
-        source_string->length();
-    MaybeHandle<String> new_source_string = factory()->NewConsString(
-        source_string,
-        factory()->NewSubString(full_source_, current_interval_start,
-                                current_interval_end));
-    if (!new_source_string.ToHandle(&source_string)) {
-      Throw("Cannot construct source string");
-      return;
-    }
-  }
-  DiscoverString(source_string);
-  bool in_place = false;
-  source_id_ = GetStringId(source_string, in_place);
-  DCHECK(!in_place);
-}
-
-void WebSnapshotSerializer::SerializeFunctionProperties(
-    Handle<JSFunction> function, ValueSerializer& serializer) {
-  Handle<Map> map(function->map(), isolate_);
-  if (function->map() ==
-      isolate_->context().get(function->shared().function_map_index())) {
-    serializer.WriteUint32(0);
-    return;
-  } else {
-    serializer.WriteUint32(GetMapId(function->map()) + 1);
-  }
-  for (InternalIndex i : map->IterateOwnDescriptors()) {
-    PropertyDetails details =
-        map->instance_descriptors(kRelaxedLoad).GetDetails(i);
-    if (details.location() == PropertyLocation::kDescriptor) {
-      continue;
-    }
-    if (!ShouldBeSerialized(
-            handle(map->instance_descriptors().GetKey(i), isolate_))) {
-      continue;
-    }
-    FieldIndex field_index = FieldIndex::ForDetails(*map, details);
-    Handle<Object> value = JSObject::FastPropertyAt(
-        isolate_, function, details.representation(), field_index);
-    WriteValue(value, serializer);
-  }
-}
-
-void WebSnapshotSerializer::SerializeFunctionInfo(Handle<JSFunction> function,
-                                                  ValueSerializer& serializer) {
-  if (!function->shared().HasSourceCode()) {
-    Throw("Function without source code");
-    return;
-  }
-
-  {
-    DisallowGarbageCollection no_gc;
-    Context context = function->context();
-    if (context.IsNativeContext() || context.IsScriptContext()) {
-      serializer.WriteUint32(0);
-    } else {
-      DCHECK(context.IsFunctionContext() || context.IsBlockContext());
-      uint32_t context_id = GetContextId(context);
-      serializer.WriteUint32(context_id + 1);
-    }
-  }
-
-  serializer.WriteUint32(source_id_);
-  Handle<Script> script =
-      handle(Script::cast(function->shared().script()), isolate_);
-  int start = function->shared().StartPosition();
-  int end = function->shared().EndPosition();
-  int final_offset =
-      source_offset_to_compacted_source_offset_[script_offsets_[script->id()] +
-                                                start];
-  serializer.WriteUint32(final_offset);
-  serializer.WriteUint32(end - start);
-
-  serializer.WriteUint32(
-      function->shared().internal_formal_parameter_count_without_receiver());
-  serializer.WriteByte(FunctionKindToFunctionFlags(function->shared().kind()));
-
-  if (function->has_prototype_slot() && function->has_instance_prototype()) {
-    DisallowGarbageCollection no_gc;
-    JSObject prototype = JSObject::cast(function->instance_prototype());
-    uint32_t prototype_id = GetObjectId(prototype);
-    serializer.WriteUint32(prototype_id + 1);
-  } else {
-    serializer.WriteUint32(0);
-  }
-}
-
-void WebSnapshotSerializer::ShallowDiscoverExternals(FixedArray externals) {
-  DisallowGarbageCollection no_gc;
-  for (int i = 0; i < externals.length(); i++) {
-    Object object = externals.get(i);
-    if (!object.IsHeapObject()) continue;
-    uint32_t unused_id = 0;
-    InsertIntoIndexMap(external_object_ids_, HeapObject::cast(object),
-                       unused_id);
-  }
-}
-
-void WebSnapshotSerializer::ShallowDiscoverBuiltinObjects(
-    v8::Local<v8::Context> context) {
-  // Fill in builtin_object_to_name_. Don't discover them or their
-  // names, so that they won't be included in the snapshot unless needed.
-
-  builtin_object_name_strings_ =
-      isolate_->factory()->NewFixedArray(kBuiltinObjectCount);
-
-  int i = 0;
-  IterateBuiltinObjects([&](Handle<String> name, Handle<HeapObject> object) {
-    builtin_object_name_strings_->set(i, *name);
-    uint32_t id;
-    bool already_exists =
-        InsertIntoIndexMap(builtin_object_to_name_, *object, id);
-    CHECK(!already_exists);
-    CHECK_EQ(static_cast<int>(id), i);
-    ++i;
-  });
-  DCHECK_EQ(i, kBuiltinObjectCount);
-}
-
-void WebSnapshotSerializer::Discover(Handle<HeapObject> start_object) {
-  // The object discovery phase assigns IDs for objects / functions / classes /
-  // arrays and discovers outgoing references from them. This is needed so that
-  // e.g., we know all functions upfront and can construct the source code that
-  // covers them before serializing the functions.
-
-  discovery_queue_.push(start_object);
-
-  while (!discovery_queue_.empty()) {
-    const Handle<HeapObject>& object = discovery_queue_.front();
-    switch (object->map().instance_type()) {
-      case JS_FUNCTION_TYPE:
-        DiscoverFunction(Handle<JSFunction>::cast(object));
-        break;
-      case JS_CLASS_CONSTRUCTOR_TYPE:
-        DiscoverClass(Handle<JSFunction>::cast(object));
-        break;
-      case JS_OBJECT_TYPE:
-      case JS_OBJECT_PROTOTYPE_TYPE:
-        DiscoverObject(Handle<JSObject>::cast(object));
-        break;
-      case JS_ARRAY_TYPE:
-        DiscoverArray(Handle<JSArray>::cast(object));
-        break;
-      case SYMBOL_TYPE:
-        DiscoverSymbol(Handle<Symbol>::cast(object));
-        break;
-      case BIGINT_TYPE:
-        DiscoverBigInt(Handle<BigInt>::cast(object));
-        break;
-      case ODDBALL_TYPE:
-      case HEAP_NUMBER_TYPE:
-        // Can't contain references to other objects.
-        break;
-      case JS_PRIMITIVE_WRAPPER_TYPE: {
-        Handle<JSPrimitiveWrapper> wrapper =
-            Handle<JSPrimitiveWrapper>::cast(object);
-        Handle<Object> value = handle(wrapper->value(), isolate_);
-        if (value->IsHeapObject()) {
-          discovery_queue_.push(Handle<HeapObject>::cast(value));
-        }
-        break;
-      }
-      case JS_REG_EXP_TYPE: {
-        Handle<JSRegExp> regexp = Handle<JSRegExp>::cast(object);
-        Handle<String> pattern = handle(regexp->source(), isolate_);
-        DiscoverString(pattern);
-        Handle<String> flags_string =
-            JSRegExp::StringFromFlags(isolate_, regexp->flags());
-        DiscoverString(flags_string);
-        break;
-      }
-      case JS_ARRAY_BUFFER_TYPE: {
-        Handle<JSArrayBuffer> array_buffer =
-            Handle<JSArrayBuffer>::cast(object);
-        DiscoverArrayBuffer(array_buffer);
-        break;
-      }
-      case JS_TYPED_ARRAY_TYPE: {
-        Handle<JSTypedArray> typed_array = Handle<JSTypedArray>::cast(object);
-        DiscoverTypedArray(typed_array);
-        break;
-      }
-      case JS_DATA_VIEW_TYPE: {
-        Handle<JSDataView> data_view = Handle<JSDataView>::cast(object);
-        DiscoverDataView(data_view);
-        break;
-      }
-      default:
-        if (object->IsString()) {
-          // These are array elements / object properties -> allow in place
-          // strings.
-          DiscoverString(Handle<String>::cast(object), AllowInPlace::Yes);
-          break;
-        } else if (external_object_ids_.size() > 0) {
-          int unused_id;
-          external_object_ids_.LookupOrInsert(*object, &unused_id);
-        } else {
-          Throw("Unsupported object");
-        }
-    }
-    discovery_queue_.pop();
-  }
-}
-
-void WebSnapshotSerializer::DiscoverPropertyKey(Handle<Name> key) {
-  if (key->IsString()) {
-    DiscoverString(Handle<String>::cast(key), AllowInPlace::Yes);
-  } else if (key->IsSymbol()) {
-    DiscoverSymbol(Handle<Symbol>::cast(key));
-  } else {
-    Throw("Property key is not a String / Symbol");
-    return;
-  }
-}
-
-void WebSnapshotSerializer::DiscoverMap(Handle<Map> map,
-                                        bool allow_property_in_descriptor) {
-  // Dictionary map object names get discovered in DiscoverObject.
-  if (map->is_dictionary_map()) {
-    return;
-  }
-
-  uint32_t id;
-  if (InsertIntoIndexMap(map_ids_, *map, id)) {
-    return;
-  }
-  DCHECK_EQ(id, maps_->Length());
-  maps_ = ArrayList::Add(isolate_, maps_, map);
-  for (InternalIndex i : map->IterateOwnDescriptors()) {
-    PropertyDetails details =
-        map->instance_descriptors(kRelaxedLoad).GetDetails(i);
-    if (details.location() != PropertyLocation::kField) {
-      if (!allow_property_in_descriptor) {
-        Throw("Properties which are not fields not supported");
-        return;
-      } else {
-        continue;
-      }
-    }
-    Handle<Name> key(map->instance_descriptors(kRelaxedLoad).GetKey(i),
-                     isolate_);
-    if (ShouldBeSerialized(key)) {
-      DiscoverPropertyKey(key);
-    }
-  }
-}
-
-void WebSnapshotSerializer::DiscoverString(Handle<String> string,
-                                           AllowInPlace can_be_in_place) {
-  // Can't contain references to other objects. We only log the existence of the
-  // string itself. Internalize the strings so that we can properly track which
-  // String objects are the same string.
-  string = factory()->InternalizeString(string);
-  auto result = all_strings_.FindOrInsert(string);
-  if (can_be_in_place == AllowInPlace::Yes && !result.already_exists) {
-    // This is the only reference to the string so far. Don't generate and
-    // ID for it yet; only generate it when another reference to the string is
-    // found.
-    return;
-  }
-  // The string is referred to more than two places, or in-placing not allowed
-  // -> not a candidate for writing it in-place. Generate an ID for it.
-
-  // TODO(v8:11525): Allow in-place strings in more places. Heuristics for
-  // when to make them in place?
-  uint32_t id;
-  if (InsertIntoIndexMap(string_ids_, *string, id)) {
-    return;
-  }
-  DCHECK_EQ(id, strings_->Length());
-  strings_ = ArrayList::Add(isolate_, strings_, string);
-}
-
-void WebSnapshotSerializer::DiscoverMapForFunction(
-    Handle<JSFunction> function) {
-  JSObject::MigrateSlowToFast(function, 0, "Web snapshot");
-  // TODO(v8:11525): Support functions with so many properties that they can't
-  // be in fast mode.
-  if (!function->HasFastProperties()) {
-    Throw("Unsupported function with dictionary map");
-    return;
-  }
-  if (function->map() !=
-      isolate_->context().get(function->shared().function_map_index())) {
-    Handle<Map> map(function->map(), isolate_);
-    // We only serialize properties which are fields in function. And properties
-    // which are descriptors will be setup in CreateJSFunction.
-    DiscoverMap(map, true);
-    discovery_queue_.push(handle(map->prototype(), isolate_));
-    // Discover property values.
-    for (InternalIndex i : map->IterateOwnDescriptors()) {
-      PropertyDetails details =
-          map->instance_descriptors(kRelaxedLoad).GetDetails(i);
-      if (details.location() == PropertyLocation::kDescriptor) {
-        continue;
-      }
-      if (!ShouldBeSerialized(
-              handle(map->instance_descriptors().GetKey(i), isolate_))) {
-        continue;
-      }
-      FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
-      Handle<Object> value = JSObject::FastPropertyAt(
-          isolate_, function, details.representation(), field_index);
-      if (!value->IsHeapObject()) continue;
-      discovery_queue_.push(Handle<HeapObject>::cast(value));
-    }
-  }
-}
-
-void WebSnapshotSerializer::DiscoverFunction(Handle<JSFunction> function) {
-  if (DiscoverIfBuiltinObject(function)) {
-    return;
-  }
-
-  uint32_t id;
-  if (InsertIntoIndexMap(function_ids_, *function, id)) {
-    return;
-  }
-
-  DCHECK_EQ(id, functions_->Length());
-  functions_ = ArrayList::Add(isolate_, functions_, function);
-
-  DiscoverContextAndPrototype(function);
-
-  DiscoverMapForFunction(function);
-  DiscoverSource(function);
-}
-
-void WebSnapshotSerializer::DiscoverClass(Handle<JSFunction> function) {
-  uint32_t id;
-  if (InsertIntoIndexMap(class_ids_, *function, id)) {
-    return;
-  }
-
-  DCHECK_EQ(id, classes_->Length());
-  classes_ = ArrayList::Add(isolate_, classes_, function);
-
-  DiscoverContextAndPrototype(function);
-
-  DiscoverMapForFunction(function);
-  // TODO(v8:11525): Support class members.
-  DiscoverSource(function);
-}
-
-void WebSnapshotSerializer::DiscoverContextAndPrototype(
-    Handle<JSFunction> function) {
-  Handle<Context> context(function->context(), isolate_);
-  if (context->IsFunctionContext() || context->IsBlockContext()) {
-    DiscoverContext(context);
-  }
-
-  if (function->has_prototype_slot() &&
-      function->map().has_non_instance_prototype()) {
-    Throw("Functions with non-instance prototypes not supported");
-    return;
-  }
-
-  if (function->has_prototype_slot() && function->has_instance_prototype()) {
-    Handle<JSObject> prototype = Handle<JSObject>::cast(
-        handle(function->instance_prototype(), isolate_));
-    discovery_queue_.push(prototype);
-  }
-
-  discovery_queue_.push(handle(function->map().prototype(), isolate_));
-}
-
-void WebSnapshotSerializer::DiscoverContext(Handle<Context> context) {
-  // Make sure the parent context (if any), gets a smaller ID. This ensures the
-  // parent context references in the snapshot are not deferred.
-  if (!context->previous().IsNativeContext() &&
-      !context->previous().IsScriptContext()) {
-    DiscoverContext(handle(context->previous(), isolate_));
-  }
-
-  uint32_t id;
-  if (InsertIntoIndexMap(context_ids_, *context, id)) return;
-
-  DCHECK_EQ(id, contexts_->Length());
-  contexts_ = ArrayList::Add(isolate_, contexts_, context);
-
-  Handle<ScopeInfo> scope_info = handle(context->scope_info(), isolate_);
-  for (auto it : ScopeInfo::IterateLocalNames(scope_info)) {
-    DiscoverString(handle(it->name(), isolate_));
-    Object value =
-        context->get(scope_info->ContextHeaderLength() + it->index());
-    if (!value.IsHeapObject()) continue;
-    discovery_queue_.push(handle(HeapObject::cast(value), isolate_));
-  }
-
-  if (!context->previous().IsNativeContext() &&
-      !context->previous().IsScriptContext()) {
-    DiscoverContext(handle(context->previous(), isolate_));
-  }
-}
-
-void WebSnapshotSerializer::DiscoverSource(Handle<JSFunction> function) {
-  // Function may not have source code, e.g. we discover source for a builtin
-  // function. In SerializeFunctionInfo, we also check if the function has
-  // source code, and we throw the same error here if the function doesn't
-  // have source code to be consistent with SerializeFunctionInfo.
-  if (!function->shared().HasSourceCode()) {
-    Throw("Function without source code");
-    return;
-  }
-  // There might be multiple scripts where functions are coming from. Construct
-  // a combined source code for them by simply concatenating the sources (and
-  // keep track which script source is where); the source code will be later
-  // optimized by ConstructSource.
-  Handle<Script> script =
-      handle(Script::cast(function->shared().script()), isolate_);
-  Handle<String> function_script_source =
-      handle(String::cast(script->source()), isolate_);
-  int script_offset_int;
-  if (full_source_.is_null()) {
-    // This is the first script.
-    script_offset_int = 0;
-    full_source_ = function_script_source;
-    script_offsets_.insert({script->id(), script_offset_int});
-  } else {
-    auto it = script_offsets_.find(script->id());
-    if (it == script_offsets_.end()) {
-      // This script hasn't been encountered yet and its source code has to be
-      // added to full_source_.
-      DCHECK(!full_source_.is_null());
-      script_offset_int = full_source_->length();
-      script_offsets_.insert({script->id(), script_offset_int});
-      if (!factory()
-               ->NewConsString(full_source_, function_script_source)
-               .ToHandle(&full_source_)) {
-        Throw("Can't construct source");
-        return;
-      }
-    } else {
-      // The script source is already somewhere in full_source_.
-      script_offset_int = it->second;
-    }
-  }
-  source_intervals_.emplace(
-      script_offset_int + function->shared().StartPosition(),
-      script_offset_int + function->shared().EndPosition());
-}
-
-void WebSnapshotSerializer::DiscoverArray(Handle<JSArray> array) {
-  uint32_t id;
-  if (InsertIntoIndexMap(array_ids_, *array, id)) {
-    return;
-  }
-  DCHECK_EQ(id, arrays_->Length());
-  arrays_ = ArrayList::Add(isolate_, arrays_, array);
-
-  DiscoverElements(array);
-}
-
-void WebSnapshotSerializer::DiscoverElements(Handle<JSObject> object) {
-  auto elements_kind = object->GetElementsKind();
-
-  DisallowGarbageCollection no_gc;
-
-  // TODO(v8:11525): Handle sealed & frozen elements correctly. (Also: handle
-  // sealed & frozen objects.)
-  switch (elements_kind) {
-    case PACKED_SMI_ELEMENTS:
-    case PACKED_ELEMENTS:
-    case HOLEY_SMI_ELEMENTS:
-    case HOLEY_ELEMENTS:
-    case PACKED_SEALED_ELEMENTS:
-    case PACKED_FROZEN_ELEMENTS:
-    case HOLEY_SEALED_ELEMENTS:
-    case HOLEY_FROZEN_ELEMENTS: {
-      FixedArray elements = FixedArray::cast(object->elements());
-      for (int i = 0; i < elements.length(); ++i) {
-        Object object = elements.get(i);
-        if (!object.IsHeapObject()) continue;
-        discovery_queue_.push(handle(HeapObject::cast(object), isolate_));
-      }
-      break;
-    }
-    case DICTIONARY_ELEMENTS: {
-      Handle<NumberDictionary> dict(object->element_dictionary(), isolate_);
-      ReadOnlyRoots roots(isolate_);
-      for (InternalIndex index : dict->IterateEntries()) {
-        Handle<Object> key = handle(dict->KeyAt(index), isolate_);
-        if (!dict->IsKey(roots, *key)) {
-          continue;
-        }
-        DCHECK(key->IsNumber());
-        if (key->Number() > std::numeric_limits<uint32_t>::max()) {
-          // TODO(v8:11525): Support large element indices.
-          Throw("Large element indices not supported");
-          return;
-        }
-        Handle<Object> object = handle(dict->ValueAt(index), isolate_);
-        if (!object->IsHeapObject()) continue;
-        discovery_queue_.push(Handle<HeapObject>::cast(object));
-      }
-      break;
-    }
-    case PACKED_DOUBLE_ELEMENTS:
-    case HOLEY_DOUBLE_ELEMENTS: {
-      break;
-    }
-    default: {
-      Throw("Unsupported elements");
-      return;
-    }
-  }
-}
-
-void WebSnapshotSerializer::DiscoverArrayBuffer(
-    Handle<JSArrayBuffer> array_buffer) {
-  if (array_buffer->was_detached()) {
-    CHECK_EQ(array_buffer->GetByteLength(), 0);
-  }
-  uint32_t id;
-  if (InsertIntoIndexMap(array_buffer_ids_, *array_buffer, id)) {
-    return;
-  }
-  DCHECK_EQ(id, array_buffers_->Length());
-  array_buffers_ = ArrayList::Add(isolate_, array_buffers_, array_buffer);
-}
-
-void WebSnapshotSerializer::DiscoverDataView(Handle<JSDataView> data_view) {
-  uint32_t id;
-  if (InsertIntoIndexMap(data_view_ids_, *data_view, id)) {
-    return;
-  }
-  DCHECK_EQ(id, data_views_->Length());
-  data_views_ = ArrayList::Add(isolate_, data_views_, data_view);
-  discovery_queue_.push(handle(data_view->buffer(), isolate_));
-}
-
-void WebSnapshotSerializer::DiscoverTypedArray(
-    Handle<JSTypedArray> typed_array) {
-  uint32_t id;
-  if (InsertIntoIndexMap(typed_array_ids_, *typed_array, id)) {
-    return;
-  }
-  DCHECK_EQ(id, typed_arrays_->Length());
-  typed_arrays_ = ArrayList::Add(isolate_, typed_arrays_, typed_array);
-  discovery_queue_.push(typed_array->GetBuffer());
-}
-
-template <typename T>
-void WebSnapshotSerializer::DiscoverObjectPropertiesWithDictionaryMap(T dict) {
-  DisallowGarbageCollection no_gc;
-
-  ReadOnlyRoots roots(isolate_);
-  for (InternalIndex index : dict->IterateEntries()) {
-    Handle<Object> key = handle(dict->KeyAt(index), isolate_);
-    if (!dict->IsKey(roots, *key)) {
-      // Ignore deleted entries.
-      continue;
-    }
-    DiscoverPropertyKey(Handle<Name>::cast(key));
-    Handle<Object> value = handle(dict->ValueAt(index), isolate_);
-    if (!value->IsHeapObject()) {
-      continue;
-    } else {
-      discovery_queue_.push(Handle<HeapObject>::cast(value));
-    }
-  }
-}
-
-void WebSnapshotSerializer::DiscoverObject(Handle<JSObject> object) {
-  if (GetExternalId(*object)) {
-    return;
-  }
-  if (DiscoverIfBuiltinObject(object)) {
-    return;
-  }
-
-  uint32_t id;
-  if (InsertIntoIndexMap(object_ids_, *object, id)) return;
-
-  DCHECK_EQ(id, objects_->Length());
-  objects_ = ArrayList::Add(isolate_, objects_, object);
-
-  // TODO(v8:11525): After we allow "non-map" objects which are small
-  // enough to have a fast map, we should remove this. Although we support
-  // objects with dictionary map now, we still check the property count is
-  // bigger than kMaxNumberOfDescriptors when deserializing dictionary map and
-  // then removing this will break deserializing prototype objects having a
-  // dictionary map with few properties.
-  JSObject::MigrateSlowToFast(object, 0, "Web snapshot");
-
-  Handle<Map> map(object->map(), isolate_);
-  DiscoverMap(map);
-
-  // Discover __proto__.
-  discovery_queue_.push(handle(map->prototype(), isolate_));
-
-  if (object->HasFastProperties()) {
-    // Discover property values.
-    for (InternalIndex i : map->IterateOwnDescriptors()) {
-      PropertyDetails details =
-          map->instance_descriptors(kRelaxedLoad).GetDetails(i);
-      FieldIndex field_index = FieldIndex::ForDetails(*map, details);
-      Handle<Object> value = JSObject::FastPropertyAt(
-          isolate_, object, details.representation(), field_index);
-      if (!value->IsHeapObject()) continue;
-      discovery_queue_.push(Handle<HeapObject>::cast(value));
-    }
-  } else {
-    ReadOnlyRoots roots(isolate_);
-    if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOL) {
-      Handle<SwissNameDictionary> swiss_dictionary =
-          handle(object->property_dictionary_swiss(), isolate_);
-      DiscoverObjectPropertiesWithDictionaryMap(swiss_dictionary);
-    } else {
-      Handle<NameDictionary> dictionary =
-          handle(object->property_dictionary(), isolate_);
-      DiscoverObjectPropertiesWithDictionaryMap(dictionary);
-    }
-  }
-
-  DiscoverElements(object);
-}
-
-bool WebSnapshotSerializer::DiscoverIfBuiltinObject(Handle<HeapObject> object) {
-  // TODO(v8:11525): Consider speccing a set of fixed builtins (such as
-  // Object.prototype) for objects which are almost always included in the
-  // snapshot.
-  uint32_t name_index;
-  if (!GetBuiltinObjectNameIndex(*object, name_index)) {
-    return false;
-  }
-  CHECK_LT(name_index, builtin_object_name_strings_->length());
-  Handle<String> name_string = handle(
-      String::cast(builtin_object_name_strings_->get(name_index)), isolate_);
-  DiscoverString(name_string, AllowInPlace::No);
-
-  // Ensure the builtin object reference gets included in the snapshot.
-  uint32_t id;
-  if (InsertIntoIndexMap(builtin_object_ids_, *object, id)) {
-    // The builtin object is already referred to by something else.
-    return true;
-  }
-  DCHECK_EQ(id, builtin_objects_.size());
-
-  bool in_place = false;
-  uint32_t name_id = GetStringId(name_string, in_place);
-  DCHECK(!in_place);
-  USE(in_place);
-  builtin_objects_.push_back(name_id);
-  return true;
-}
-
-void WebSnapshotSerializer::DiscoverSymbol(Handle<Symbol> symbol) {
-  if (symbol->is_well_known_symbol()) {
-    // TODO(v8:11525): Support well-known Symbols.
-    Throw("Well known Symbols aren't supported");
-    return;
-  }
-  uint32_t id;
-  if (InsertIntoIndexMap(symbol_ids_, *symbol, id)) return;
-
-  DCHECK_EQ(id, symbols_->Length());
-  symbols_ = ArrayList::Add(isolate_, symbols_, symbol);
-
-  if (!symbol->description().IsUndefined()) {
-    DiscoverString(handle(String::cast(symbol->description()), isolate_));
-  }
-}
-
-void WebSnapshotSerializer::DiscoverBigInt(Handle<BigInt> bigint) {
-  uint32_t id;
-  if (InsertIntoIndexMap(bigint_ids_, *bigint, id)) return;
-
-  DCHECK_EQ(id, bigints_->Length());
-  bigints_ = ArrayList::Add(isolate_, bigints_, bigint);
-}
-
-// Format (serialized function):
-// - 0 if there's no context, 1 + context id otherwise
-// - String id (source snippet)
-// - Start position in the source snippet
-// - Length in the source snippet
-// - Formal parameter count
-// - Flags (see FunctionFlags)
-// - 0 if there's no map, 1 + map id otherwise
-// - For each function property
-//   - Serialized value
-// - Function prototype
-// TODO(v8:11525): Investigate whether the length is really needed.
-void WebSnapshotSerializer::SerializeFunction(Handle<JSFunction> function) {
-  SerializeFunctionInfo(function, function_serializer_);
-  SerializeFunctionProperties(function, function_serializer_);
-  WriteValue(handle(function->map().prototype(), isolate_),
-             function_serializer_);
-}
-
-// Format (serialized class):
-// - 1 + context id
-// - String id (source snippet)
-// - Start position in the source snippet
-// - Length in the source snippet
-// - Formal parameter count
-// - Flags (see FunctionFlags)
-// - 0 if there's no map, 1 + map id otherwise
-// - For each function property
-//   - Serialized value
-// - Function prototype
-void WebSnapshotSerializer::SerializeClass(Handle<JSFunction> function) {
-  SerializeFunctionInfo(function, class_serializer_);
-  SerializeFunctionProperties(function, class_serializer_);
-  WriteValue(handle(function->map().prototype(), isolate_), class_serializer_);
-  // TODO(v8:11525): Support class members.
-}
-
-// Format (serialized context):
-// - 0 if there's no parent context, 1 + parent context id otherwise
-// - Variable count
-// - For each variable:
-//   - String id (name)
-// - For each variable:
-//   - Serialized value
-void WebSnapshotSerializer::SerializeContext(Handle<Context> context,
-                                             uint32_t id) {
-  uint32_t parent_context_id = 0;
-  if (!context->previous().IsNativeContext() &&
-      !context->previous().IsScriptContext()) {
-    parent_context_id = GetContextId(context->previous());
-    DCHECK_LT(parent_context_id, id);
-    ++parent_context_id;  // 0 is reserved for "no parent context".
-  }
-
-  // TODO(v8:11525): Use less space for encoding the context type.
-  if (context->IsFunctionContext()) {
-    context_serializer_.WriteUint32(ContextType::FUNCTION);
-  } else if (context->IsBlockContext()) {
-    context_serializer_.WriteUint32(ContextType::BLOCK);
-  } else {
-    Throw("Unsupported context type");
-    return;
-  }
-
-  context_serializer_.WriteUint32(parent_context_id);
-
-  Handle<ScopeInfo> scope_info(context->scope_info(), isolate_);
-  int count = scope_info->ContextLocalCount();
-  context_serializer_.WriteUint32(count);
-
-  for (auto it : ScopeInfo::IterateLocalNames(scope_info)) {
-    // TODO(v8:11525): support parameters
-    // TODO(v8:11525): distinguish variable modes
-    WriteStringId(handle(it->name(), isolate_), context_serializer_);
-  }
-  for (auto it : ScopeInfo::IterateLocalNames(scope_info)) {
-    Handle<Object> value(
-        context->get(scope_info->ContextHeaderLength() + it->index()),
-        isolate_);
-    WriteValue(value, context_serializer_);
-  }
-}
-
-template <typename T>
-void WebSnapshotSerializer::SerializeObjectPropertiesWithDictionaryMap(T dict) {
-  DisallowGarbageCollection no_gc;
-
-  std::vector<uint8_t> attributes;
-  attributes.reserve(dict->NumberOfElements());
-  HandleScope scope(isolate_);
-  int first_custom_index = -1;
-
-  ReadOnlyRoots roots(isolate_);
-  for (InternalIndex index : dict->IterateEntries()) {
-    if (!dict->IsKey(roots, dict->KeyAt(index))) {
-      continue;
-    }
-    PropertyDetails details = dict->DetailsAt(index);
-    if (first_custom_index >= 0 || details.IsReadOnly() ||
-        !details.IsConfigurable() || details.IsDontEnum()) {
-      if (first_custom_index == -1) first_custom_index = index.as_int();
-      attributes.push_back(AttributesToFlags(details));
-    }
-  }
-  object_serializer_.WriteUint32(first_custom_index == -1
-                                     ? PropertyAttributesType::DEFAULT
-                                     : PropertyAttributesType::CUSTOM);
-  object_serializer_.WriteUint32(dict->NumberOfElements());
-
-  uint8_t default_flags = GetDefaultAttributeFlags();
-  for (InternalIndex index : dict->IterateEntries()) {
-    Object key = dict->KeyAt(index);
-    if (!dict->IsKey(roots, key)) {
-      continue;
-    }
-    WriteValue(handle(key, isolate_), object_serializer_);
-    WriteValue(handle(dict->ValueAt(index), isolate_), object_serializer_);
-    if (first_custom_index >= 0) {
-      if (index.as_int() < first_custom_index) {
-        object_serializer_.WriteByte(default_flags);
-      } else {
-        object_serializer_.WriteByte(
-            attributes[index.as_int() - first_custom_index]);
-      }
-    }
-  }
-}
-
-// Format (serialized object):
-// - 0 if there's no shape (dictionary map), 1 + shape id otherwise
-// If has shape
-//   - For each property:
-//     - Serialized value
-// Else (dictionary map)
-//   - PropertyAttributesType
-//   - Property count
-//   - For each property
-//     - Name: STRING_ID + String id or SYMBOL_ID + Symbol id or in-place string
-//     - Serialized value
-//     - If the PropertyAttributesType is CUSTOM: attributes
-//   - __proto__: serialized value
-// - Elements (see serialized array)
-// TODO(v8:11525): Support packed elements with a denser format.
-void WebSnapshotSerializer::SerializeObject(Handle<JSObject> object) {
-  Handle<Map> map(object->map(), isolate_);
-  if (map->is_dictionary_map()) {
-    object_serializer_.WriteUint32(0);
-  } else {
-    uint32_t map_id = GetMapId(*map);
-    object_serializer_.WriteUint32(map_id + 1);
-  }
-
-  if (object->HasFastProperties()) {
-    // Properties.
-    for (InternalIndex i : map->IterateOwnDescriptors()) {
-      PropertyDetails details =
-          map->instance_descriptors(kRelaxedLoad).GetDetails(i);
-      FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
-      Handle<Object> value = JSObject::FastPropertyAt(
-          isolate_, object, details.representation(), field_index);
-      WriteValue(value, object_serializer_);
-    }
-  } else {
-    if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOL) {
-      Handle<SwissNameDictionary> swiss_dictionary =
-          handle(object->property_dictionary_swiss(), isolate_);
-      SerializeObjectPropertiesWithDictionaryMap(swiss_dictionary);
-    } else {
-      Handle<NameDictionary> dictionary =
-          handle(object->property_dictionary(), isolate_);
-      SerializeObjectPropertiesWithDictionaryMap(dictionary);
-    }
-    WriteValue(handle(map->prototype(), isolate_), object_serializer_);
-  }
-
-  // Elements.
-  ElementsKind kind = object->GetElementsKind();
-  // We only serialize the actual elements excluding the slack part.
-  DCHECK(!IsDoubleElementsKind(kind));
-  if (!IsDictionaryElementsKind(kind)) {
-    uint32_t elements_length = object->elements().length();
-    if (IsHoleyElementsKindForRead(kind)) {
-      uint32_t max_element_index = 0;
-      FixedArray elements = FixedArray::cast(object->elements());
-      for (int i = elements_length - 1; i >= 0; i--) {
-        if (!elements.is_the_hole(isolate_, i)) {
-          max_element_index = i + 1;
-          break;
-        }
-      }
-      return SerializeElements(object, object_serializer_,
-                               Just(max_element_index));
-    } else {
-      return SerializeElements(object, object_serializer_,
-                               Just(elements_length));
-    }
-  }
-  SerializeElements(object, object_serializer_, Nothing<uint32_t>());
-}
-
-// Format (serialized array):
-// - Elements type (dense or sparse)
-// - Length
-// If dense array
-//   - For each element:
-//     - Serialized value
-// If sparse array
-//   - For each element:
-//     - Element index
-//     - Serialized value
-void WebSnapshotSerializer::SerializeArray(Handle<JSArray> array) {
-  uint32_t length;
-  if (!array->length().ToUint32(&length)) {
-    Throw("Invalid array length");
-    return;
-  }
-  SerializeElements(array, array_serializer_, Just(length));
-}
-
-void WebSnapshotSerializer::SerializeElements(Handle<JSObject> object,
-                                              ValueSerializer& serializer,
-                                              Maybe<uint32_t> length) {
-  // TODO(v8:11525): Handle sealed & frozen elements correctly. (Also: handle
-  // sealed & frozen objects.)
-
-  // TODO(v8:11525): Sometimes it would make sense to serialize dictionary
-  // mode elements as dense (the number of elements is large but the array is
-  // densely filled).
-
-  // TODO(v8:11525): Sometimes it would make sense to serialize packed mode
-  // elements as sparse (if there are a considerable amount of holes in it).
-  ReadOnlyRoots roots(isolate_);
-  auto elements_kind = object->GetElementsKind();
-  switch (elements_kind) {
-    case PACKED_SMI_ELEMENTS:
-    case PACKED_ELEMENTS:
-    case HOLEY_SMI_ELEMENTS:
-    case HOLEY_ELEMENTS:
-    case PACKED_FROZEN_ELEMENTS:
-    case PACKED_SEALED_ELEMENTS:
-    case HOLEY_FROZEN_ELEMENTS:
-    case HOLEY_SEALED_ELEMENTS: {
-      serializer.WriteUint32(ElementsType::kDense);
-      Handle<FixedArray> elements =
-          handle(FixedArray::cast(object->elements()), isolate_);
-      serializer.WriteUint32(length.ToChecked());
-      for (uint32_t i = 0; i < length.ToChecked(); ++i) {
-        WriteValue(handle(elements->get(i), isolate_), serializer);
-      }
-      break;
-    }
-    case PACKED_DOUBLE_ELEMENTS:
-    case HOLEY_DOUBLE_ELEMENTS: {
-      serializer.WriteUint32(ElementsType::kDense);
-      Handle<FixedDoubleArray> elements =
-          handle(FixedDoubleArray::cast(object->elements()), isolate_);
-      serializer.WriteUint32(length.ToChecked());
-      for (uint32_t i = 0; i < length.ToChecked(); ++i) {
-        if (!elements->is_the_hole(i)) {
-          double double_value = elements->get_scalar(i);
-          Handle<Object> element_value =
-              isolate_->factory()->NewNumber(double_value);
-          WriteValue(element_value, serializer);
-        } else {
-          WriteValue(handle(roots.the_hole_value(), isolate_), serializer);
-        }
-      }
-      break;
-    }
-    case DICTIONARY_ELEMENTS: {
-      DisallowGarbageCollection no_gc;
-      serializer.WriteUint32(ElementsType::kSparse);
-
-      auto dict = object->element_dictionary();
-      serializer.WriteUint32(dict.NumberOfElements());
-
-      for (InternalIndex index : dict.IterateEntries()) {
-        Object key = dict.KeyAt(index);
-        if (!dict.IsKey(roots, key)) {
-          continue;
-        }
-        CHECK(key.IsNumber());
-        // This case is checked by DiscoverElements.
-        // TODO(v8:11525): Support large element indices.
-        CHECK_LE(key.Number(), std::numeric_limits<uint32_t>::max());
-        uint32_t element_index = static_cast<uint32_t>(key.Number());
-        serializer.WriteUint32(element_index);
-        WriteValue(handle(dict.ValueAt(index), isolate_), serializer);
-      }
-      break;
-    }
-    default: {
-      Throw("Unsupported elements");
-      return;
-    }
-  }
-}
-uint8_t WebSnapshotSerializerDeserializer::ArrayBufferKindToFlags(
-    Handle<JSArrayBuffer> array_buffer) {
-  return DetachedBitField::encode(array_buffer->was_detached()) |
-         SharedBitField::encode(array_buffer->is_shared()) |
-         ResizableBitField::encode(array_buffer->is_resizable_by_js());
-}
-
-uint32_t WebSnapshotSerializerDeserializer::BigIntSignAndLengthToFlags(
-    Handle<BigInt> bigint) {
-  uint32_t bitfield = bigint->GetBitfieldForSerialization();
-  int byte_length = BigInt::DigitsByteLengthForBitfield(bitfield);
-  int sign = BigInt::SignBits::decode(bitfield);
-
-  return BigIntSignBitField::encode(sign) |
-         BigIntLengthBitField::encode(byte_length);
-}
-
-uint32_t WebSnapshotSerializerDeserializer::BigIntFlagsToBitField(
-    uint32_t flags) {
-  int byte_length = BigIntLengthBitField::decode(flags);
-  int sign = BigIntSignBitField::decode(flags);
-  return BigInt::SignBits::encode(sign) |
-         BigInt::LengthBits::encode(byte_length);
-}
-
-// Format (serialized array buffer):
-// - ArrayBufferFlags, including was_detached, is_shared and is_resizable_by_js.
-// - Byte length
-// - if is_resizable_by_js
-//   - Max byte length
-// - Raw bytes
-void WebSnapshotSerializer::SerializeArrayBuffer(
-    Handle<JSArrayBuffer> array_buffer) {
-  size_t byte_length = array_buffer->GetByteLength();
-  if (byte_length > std::numeric_limits<uint32_t>::max()) {
-    Throw("Too large array buffer");
-    return;
-  }
-  array_buffer_serializer_.WriteByte(ArrayBufferKindToFlags(array_buffer));
-
-  array_buffer_serializer_.WriteUint32(static_cast<uint32_t>(byte_length));
-  if (array_buffer->is_resizable_by_js()) {
-    size_t max_byte_length = array_buffer->max_byte_length();
-    if (max_byte_length > std::numeric_limits<uint32_t>::max()) {
-      Throw("Too large resizable array buffer");
-      return;
-    }
-    array_buffer_serializer_.WriteUint32(
-        static_cast<uint32_t>(array_buffer->max_byte_length()));
-  }
-  array_buffer_serializer_.WriteRawBytes(array_buffer->backing_store(),
-                                         byte_length);
-}
-
-uint8_t WebSnapshotSerializerDeserializer::ArrayBufferViewKindToFlags(
-    Handle<JSArrayBufferView> array_buffer_view) {
-  return LengthTrackingBitField::encode(
-      array_buffer_view->is_length_tracking());
-}
-
-// static
-ExternalArrayType
-WebSnapshotSerializerDeserializer::TypedArrayTypeToExternalArrayType(
-    TypedArrayType type) {
-  switch (type) {
-#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype) \
-  case k##Type##Array:                            \
-    return kExternal##Type##Array;
-    TYPED_ARRAYS(TYPED_ARRAY_CASE)
-#undef TYPED_ARRAY_CASE
-  }
-  UNREACHABLE();
-}
-
-// static
-WebSnapshotSerializerDeserializer::TypedArrayType
-WebSnapshotSerializerDeserializer::ExternalArrayTypeToTypedArrayType(
-    ExternalArrayType type) {
-  switch (type) {
-#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype) \
-  case kExternal##Type##Array:                    \
-    return TypedArrayType::k##Type##Array;
-    TYPED_ARRAYS(TYPED_ARRAY_CASE)
-#undef TYPED_ARRAY_CASE
-  }
-  UNREACHABLE();
-}
-
-// Format (serialized array buffer view):
-// - Serialized ArrayBuffer
-// - ArrayBufferViewFlags, including is_length_tracking
-// - Byte offset
-// - If not is_length_tracking
-//   - Byte length
-void WebSnapshotSerializer::SerializeArrayBufferView(
-    Handle<JSArrayBufferView> array_buffer_view, ValueSerializer& serializer) {
-  WriteValue(handle(array_buffer_view->buffer(), isolate_), serializer);
-  // TODO(v8:11525): Implement WriteByte.
-  serializer.WriteByte(ArrayBufferViewKindToFlags(array_buffer_view));
-  if (array_buffer_view->byte_offset() > std::numeric_limits<uint32_t>::max()) {
-    Throw("Too large byte offset in TypedArray");
-    return;
-  }
-  serializer.WriteUint32(
-      static_cast<uint32_t>(array_buffer_view->byte_offset()));
-  if (array_buffer_view->byte_length() > std::numeric_limits<uint32_t>::max()) {
-    Throw("Too large byte length in TypedArray");
-    return;
-  }
-  if (!array_buffer_view->is_length_tracking()) {
-    serializer.WriteUint32(
-        static_cast<uint32_t>(array_buffer_view->byte_length()));
-  }
-}
-
-// Format (serialized typed array):
-// - TypedArrayType
-// - ArrayBufferView
-void WebSnapshotSerializer::SerializeTypedArray(
-    Handle<JSTypedArray> typed_array) {
-  TypedArrayType typed_array_type =
-      ExternalArrayTypeToTypedArrayType(typed_array->type());
-  typed_array_serializer_.WriteUint32(typed_array_type);
-  SerializeArrayBufferView(typed_array, typed_array_serializer_);
-}
-
-// Format (serialized data view):
-// - ArrayBufferView
-void WebSnapshotSerializer::SerializeDataView(Handle<JSDataView> data_view) {
-  SerializeArrayBufferView(data_view, data_view_serializer_);
-}
-
-// Format (serialized export):
-// - String id (export name)
-// - Serialized value (export value)
-void WebSnapshotSerializer::SerializeExport(Handle<Object> object,
-                                            Handle<String> export_name) {
-  ++export_count_;
-  WriteStringId(export_name, export_serializer_);
-  if (object->IsJSPrimitiveWrapper()) {
-    Handle<JSPrimitiveWrapper> wrapper =
-        Handle<JSPrimitiveWrapper>::cast(object);
-    Handle<Object> export_value = handle(wrapper->value(), isolate_);
-    WriteValue(export_value, export_serializer_);
-  } else {
-    WriteValue(object, export_serializer_);
-  }
-}
-
-// Format (serialized value):
-// - Type id (ValueType enum)
-// - Value or id (interpretation depends on the type)
-void WebSnapshotSerializer::WriteValue(Handle<Object> object,
-                                       ValueSerializer& serializer) {
-  if (object->IsSmi()) {
-    serializer.WriteByte(ValueType::INTEGER);
-    serializer.WriteZigZag<int32_t>(Smi::cast(*object).value());
-    return;
-  }
-
-  uint32_t id;
-  if (GetExternalId(HeapObject::cast(*object), &id)) {
-    serializer.WriteByte(ValueType::EXTERNAL_ID);
-    serializer.WriteUint32(id);
-    return;
-  }
-
-  if (GetBuiltinObjectId(HeapObject::cast(*object), id)) {
-    serializer.WriteByte(ValueType::BUILTIN_OBJECT_ID);
-    serializer.WriteUint32(id);
-    return;
-  }
-
-  DCHECK(object->IsHeapObject());
-  Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object);
-  switch ((*heap_object).map().instance_type()) {
-    case ODDBALL_TYPE:
-      switch (Oddball::cast(*heap_object).kind()) {
-        case Oddball::kFalse:
-          serializer.WriteByte(ValueType::FALSE_CONSTANT);
-          return;
-        case Oddball::kTrue:
-          serializer.WriteByte(ValueType::TRUE_CONSTANT);
-          return;
-        case Oddball::kNull:
-          serializer.WriteByte(ValueType::NULL_CONSTANT);
-          return;
-        case Oddball::kUndefined:
-          serializer.WriteByte(ValueType::UNDEFINED_CONSTANT);
-          return;
-        case Oddball::kTheHole:
-          serializer.WriteByte(ValueType::NO_ELEMENT_CONSTANT);
-          return;
-        default:
-          UNREACHABLE();
-      }
-    case HEAP_NUMBER_TYPE:
-      // TODO(v8:11525): Handle possible endianness mismatch.
-      serializer.WriteByte(ValueType::DOUBLE);
-      serializer.WriteDouble(HeapNumber::cast(*heap_object).value());
-      break;
-    case JS_FUNCTION_TYPE:
-      serializer.WriteByte(ValueType::FUNCTION_ID);
-      serializer.WriteUint32(GetFunctionId(JSFunction::cast(*heap_object)));
-      break;
-    case JS_CLASS_CONSTRUCTOR_TYPE:
-      serializer.WriteByte(ValueType::CLASS_ID);
-      serializer.WriteUint32(GetClassId(JSFunction::cast(*heap_object)));
-      break;
-    case JS_OBJECT_TYPE:
-      serializer.WriteByte(ValueType::OBJECT_ID);
-      serializer.WriteUint32(GetObjectId(JSObject::cast(*heap_object)));
-      break;
-    case JS_ARRAY_TYPE:
-      serializer.WriteByte(ValueType::ARRAY_ID);
-      serializer.WriteUint32(GetArrayId(JSArray::cast(*heap_object)));
-      break;
-    case SYMBOL_TYPE:
-      serializer.WriteByte(ValueType::SYMBOL_ID);
-      serializer.WriteUint32(GetSymbolId(Symbol::cast(*heap_object)));
-      break;
-    case BIGINT_TYPE:
-      serializer.WriteByte(ValueType::BIGINT_ID);
-      serializer.WriteUint32(GetBigIntId(BigInt::cast(*heap_object)));
-      break;
-    case JS_REG_EXP_TYPE: {
-      Handle<JSRegExp> regexp = Handle<JSRegExp>::cast(heap_object);
-      if (regexp->map() != isolate_->regexp_function()->initial_map()) {
-        Throw("Unsupported RegExp map");
-        return;
-      }
-      serializer.WriteByte(ValueType::REGEXP);
-      Handle<String> pattern = handle(regexp->source(), isolate_);
-      WriteStringId(pattern, serializer);
-      Handle<String> flags_string =
-          JSRegExp::StringFromFlags(isolate_, regexp->flags());
-      WriteStringId(flags_string, serializer);
-      break;
-    }
-    case JS_ARRAY_BUFFER_TYPE: {
-      Handle<JSArrayBuffer> array_buffer =
-          Handle<JSArrayBuffer>::cast(heap_object);
-      serializer.WriteByte(ValueType::ARRAY_BUFFER_ID);
-      serializer.WriteUint32(GetArrayBufferId(*array_buffer));
-      break;
-    }
-    case JS_TYPED_ARRAY_TYPE: {
-      Handle<JSTypedArray> typed_array =
-          Handle<JSTypedArray>::cast(heap_object);
-      serializer.WriteByte(ValueType::TYPED_ARRAY_ID);
-      serializer.WriteUint32(GetTypedArrayId(*typed_array));
-      break;
-    }
-    case JS_DATA_VIEW_TYPE: {
-      Handle<JSDataView> data_view = Handle<JSDataView>::cast(heap_object);
-      serializer.WriteUint32(ValueType::DATA_VIEW_ID);
-      serializer.WriteUint32(GetDataViewId(*data_view));
-      break;
-    }
-    default:
-      if (heap_object->IsString()) {
-        // Write strings which are referred to only once as in-place strings.
-        WriteStringMaybeInPlace(Handle<String>::cast(heap_object), serializer);
-      } else {
-        Throw("Unsupported object");
-      }
-  }
-  // TODO(v8:11525): Support more types.
-}
-
-void WebSnapshotSerializer::WriteStringMaybeInPlace(
-    Handle<String> string, ValueSerializer& serializer) {
-  // If the string is only referred to by one location, write it in-place.
-  bool in_place = false;
-  uint32_t id = GetStringId(string, in_place);
-  if (in_place) {
-    serializer.WriteByte(ValueType::IN_PLACE_STRING_ID);
-    SerializeString(string, serializer);
-  } else {
-    serializer.WriteByte(ValueType::STRING_ID);
-    serializer.WriteUint32(id);
-  }
-}
-
-void WebSnapshotSerializer::WriteStringId(Handle<String> string,
-                                          ValueSerializer& serializer) {
-  bool in_place = false;
-  uint32_t id = GetStringId(string, in_place);
-  CHECK(!in_place);  // The string must have an ID.
-  serializer.WriteUint32(id);
-}
-
-uint32_t WebSnapshotSerializer::GetStringId(Handle<String> string,
-                                            bool& in_place) {
-  // Internalize strings so that they're unique.
-  string = factory()->InternalizeString(string);
-
-  // Strings referred to more than one places are inserted in string_ids_.
-  // Strings referred to by only one place aren't.
-#ifdef DEBUG
-  auto result = all_strings_.FindOrInsert(string);
-  DCHECK(result.already_exists);
-#endif
-  int id = 0;
-  in_place = !string_ids_.Lookup(*string, &id);
-  return static_cast<uint32_t>(id);
-}
-
-uint32_t WebSnapshotSerializer::GetSymbolId(Symbol symbol) {
-  int id;
-  bool return_value = symbol_ids_.Lookup(symbol, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(id);
-}
-
-uint32_t WebSnapshotSerializer::GetBigIntId(BigInt bigint) {
-  int id;
-  bool return_value = bigint_ids_.Lookup(bigint, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(id);
-}
-
-uint32_t WebSnapshotSerializer::GetMapId(Map map) {
-  int id;
-  bool return_value = map_ids_.Lookup(map, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(id);
-}
-
-uint32_t WebSnapshotSerializer::GetFunctionId(JSFunction function) {
-  int id;
-  bool return_value = function_ids_.Lookup(function, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(function_ids_.size() - 1 - id);
-}
-
-uint32_t WebSnapshotSerializer::GetClassId(JSFunction function) {
-  int id;
-  bool return_value = class_ids_.Lookup(function, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(class_ids_.size() - 1 - id);
-}
-
-uint32_t WebSnapshotSerializer::GetContextId(Context context) {
-  int id;
-  bool return_value = context_ids_.Lookup(context, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(id);
-}
-
-uint32_t WebSnapshotSerializer::GetArrayId(JSArray array) {
-  int id;
-  bool return_value = array_ids_.Lookup(array, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(array_ids_.size() - 1 - id);
-}
-
-uint32_t WebSnapshotSerializer::GetTypedArrayId(JSTypedArray typed_array) {
-  int id;
-  bool return_value = typed_array_ids_.Lookup(typed_array, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(typed_array_ids_.size() - 1 - id);
-}
-
-uint32_t WebSnapshotSerializer::GetDataViewId(JSDataView data_view) {
-  int id;
-  bool return_value = data_view_ids_.Lookup(data_view, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(data_view_ids_.size() - 1 - id);
-}
-
-uint32_t WebSnapshotSerializer::GetArrayBufferId(JSArrayBuffer array_buffer) {
-  int id;
-  bool return_value = array_buffer_ids_.Lookup(array_buffer, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(array_buffer_ids_.size() - 1 - id);
-}
-
-uint32_t WebSnapshotSerializer::GetObjectId(JSObject object) {
-  int id;
-  bool return_value = object_ids_.Lookup(object, &id);
-  DCHECK(return_value);
-  USE(return_value);
-  return static_cast<uint32_t>(object_ids_.size() - 1 - id);
-}
-
-bool WebSnapshotSerializer::GetExternalId(HeapObject object, uint32_t* id) {
-  int id_int;
-  bool return_value = external_object_ids_.Lookup(object, &id_int);
-  if (id != nullptr) {
-    *id = static_cast<uint32_t>(id_int);
-  }
-  return return_value;
-}
-
-bool WebSnapshotSerializer::GetBuiltinObjectNameIndex(HeapObject object,
-                                                      uint32_t& index) {
-  int index_int = 0;
-  bool return_value = builtin_object_to_name_.Lookup(object, &index_int);
-  index = static_cast<uint32_t>(index_int);
-  return return_value;
-}
-
-bool WebSnapshotSerializer::GetBuiltinObjectId(HeapObject object,
-                                               uint32_t& id) {
-  int id_int;
-  bool return_value = builtin_object_ids_.Lookup(object, &id_int);
-  id = static_cast<uint32_t>(id_int);
-  return return_value;
-}
-
-Handle<FixedArray> WebSnapshotSerializer::GetExternals() {
-  return external_object_ids_.Values(isolate_);
-}
-
-WebSnapshotDeserializer::WebSnapshotDeserializer(v8::Isolate* isolate,
-                                                 const uint8_t* data,
-                                                 size_t buffer_size)
-    : WebSnapshotDeserializer(reinterpret_cast<i::Isolate*>(isolate),
-                              Handle<Object>(), {data, buffer_size}) {}
-
-WebSnapshotDeserializer::WebSnapshotDeserializer(
-    Isolate* isolate, Handle<Script> snapshot_as_script)
-    : WebSnapshotSerializerDeserializer(isolate),
-      script_name_(handle(snapshot_as_script->name(), isolate_)),
-      roots_(isolate) {
-  auto [data, buffer_size, buffer_owned] =
-      ExtractScriptBuffer(isolate, snapshot_as_script);
-  deserializer_.reset(new ValueDeserializer(isolate_, data, buffer_size));
-  if (buffer_owned) {
-    owned_data_.reset(data);
-  }
-}
-
-WebSnapshotDeserializer::WebSnapshotDeserializer(
-    Isolate* isolate, Handle<Object> script_name,
-    base::Vector<const uint8_t> buffer)
-    : WebSnapshotSerializerDeserializer(isolate),
-      script_name_(script_name),
-      deserializer_(
-          new ValueDeserializer(isolate_, buffer.data(), buffer.length())),
-      roots_(isolate) {
-  Handle<FixedArray> empty_array = factory()->empty_fixed_array();
-  strings_handle_ = empty_array;
-  symbols_handle_ = empty_array;
-  bigints_handle_ = empty_array;
-  builtin_objects_handle_ = empty_array;
-  maps_handle_ = empty_array;
-  contexts_handle_ = empty_array;
-  functions_handle_ = empty_array;
-  classes_handle_ = empty_array;
-  arrays_handle_ = empty_array;
-  array_buffers_handle_ = empty_array;
-  typed_arrays_handle_ = empty_array;
-  data_views_handle_ = empty_array;
-  objects_handle_ = empty_array;
-  external_references_handle_ = empty_array;
-  isolate_->heap()->AddGCEpilogueCallback(UpdatePointersCallback,
-                                          v8::kGCTypeAll, this);
-}
-
-WebSnapshotDeserializer::~WebSnapshotDeserializer() {
-  isolate_->heap()->RemoveGCEpilogueCallback(UpdatePointersCallback, this);
-}
-
-void WebSnapshotDeserializer::UpdatePointers() {
-  strings_ = *strings_handle_;
-  symbols_ = *symbols_handle_;
-  bigints_ = *bigints_handle_;
-  builtin_objects_ = *builtin_objects_handle_;
-  maps_ = *maps_handle_;
-  contexts_ = *contexts_handle_;
-  functions_ = *functions_handle_;
-  classes_ = *classes_handle_;
-  arrays_ = *arrays_handle_;
-  array_buffers_ = *array_buffers_handle_;
-  typed_arrays_ = *typed_arrays_handle_;
-  data_views_ = *data_views_handle_;
-  objects_ = *objects_handle_;
-  external_references_ = *external_references_handle_;
-}
-
-// static
-std::tuple<const uint8_t*, uint32_t, bool>
-WebSnapshotDeserializer::ExtractScriptBuffer(
-    Isolate* isolate, Handle<Script> snapshot_as_script) {
-  Handle<String> source =
-      handle(String::cast(snapshot_as_script->source()), isolate);
-  if (source->IsExternalOneByteString()) {
-    const v8::String::ExternalOneByteStringResource* resource =
-        ExternalOneByteString::cast(*source).resource();
-    return std::make_tuple(reinterpret_cast<const uint8_t*>(resource->data()),
-                           resource->length(), false);
-  } else if (source->IsSeqOneByteString()) {
-    SeqOneByteString source_as_seq = SeqOneByteString::cast(*source);
-    size_t length = source_as_seq.length();
-    std::unique_ptr<uint8_t[]> data_copy(new uint8_t[length]);
-    {
-      DisallowGarbageCollection no_gc;
-      uint8_t* data = source_as_seq.GetChars(no_gc);
-      memcpy(data_copy.get(), data, length);
-    }
-    return std::make_tuple(data_copy.release(), length, true);
-  } else if (source->IsExternalTwoByteString()) {
-    // TODO(v8:11525): Implement end-to-end snapshot processing which gets rid
-    // of the need to copy the data here.
-    const v8::String::ExternalStringResource* resource =
-        ExternalTwoByteString::cast(*source).resource();
-    size_t length = resource->length();
-    std::unique_ptr<uint8_t[]> data_copy(new uint8_t[length]);
-    {
-      DisallowGarbageCollection no_gc;
-      const uint16_t* data = resource->data();
-      uint8_t* data_copy_ptr = data_copy.get();
-      for (size_t i = 0; i < length; ++i) {
-        data_copy_ptr[i] = static_cast<uint8_t>(data[i]);
-      }
-    }
-    return std::make_tuple(data_copy.release(), length, true);
-  } else if (source->IsSeqTwoByteString()) {
-    SeqTwoByteString source_as_seq = SeqTwoByteString::cast(*source);
-    size_t length = source_as_seq.length();
-    std::unique_ptr<uint8_t[]> data_copy(new uint8_t[length]);
-    {
-      DisallowGarbageCollection no_gc;
-      uint16_t* data = source_as_seq.GetChars(no_gc);
-      uint8_t* data_copy_ptr = data_copy.get();
-      for (size_t i = 0; i < length; ++i) {
-        data_copy_ptr[i] = static_cast<uint8_t>(data[i]);
-      }
-    }
-    return std::make_tuple(data_copy.release(), length, true);
-  }
-  UNREACHABLE();
-}
-
-void WebSnapshotDeserializer::Throw(const char* message) {
-  string_count_ = 0;
-  symbol_count_ = 0;
-  bigint_count_ = 0;
-  map_count_ = 0;
-  builtin_object_count_ = 0;
-  context_count_ = 0;
-  class_count_ = 0;
-  function_count_ = 0;
-  object_count_ = 0;
-  deferred_references_->SetLength(0);
-
-  // Make sure we don't read any more data
-  deserializer_->position_ = deserializer_->end_;
-
-  WebSnapshotSerializerDeserializer::Throw(message);
-}
-
-bool WebSnapshotDeserializer::Deserialize(
-    MaybeHandle<FixedArray> external_references, bool skip_exports) {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize);
-  if (external_references.ToHandle(&external_references_handle_)) {
-    external_references_ = *external_references_handle_;
-  } else {
-    external_references_handle_ = roots_.empty_fixed_array_handle();
-  }
-
-  if (deserialized_) {
-    Throw("Can't reuse WebSnapshotDeserializer");
-    return false;
-  }
-  deserialized_ = true;
-  auto buffer_size = deserializer_->end_ - deserializer_->position_;
-
-  base::ElapsedTimer timer;
-  if (v8_flags.trace_web_snapshot) {
-    timer.Start();
-  }
-  if (!DeserializeSnapshot(skip_exports)) {
-    return false;
-  }
-  if (!DeserializeScript()) {
-    return false;
-  }
-
-  if (v8_flags.trace_web_snapshot) {
-    double ms = timer.Elapsed().InMillisecondsF();
-    PrintF("[Deserializing snapshot (%zu bytes) took %0.3f ms]\n", buffer_size,
-           ms);
-  }
-  return true;
-}
-
-#ifdef VERIFY_HEAP
-void WebSnapshotDeserializer::VerifyObjects() {
-  for (int i = 0; i < strings_.length(); i++) {
-    String::cast(strings_.get(i)).StringVerify(isolate_);
-  }
-  for (int i = 0; i < symbols_.length(); i++) {
-    Symbol::cast(symbols_.get(i)).SymbolVerify(isolate_);
-  }
-  for (int i = 0; i < builtin_objects_.length(); i++) {
-    builtin_objects_.get(i).ObjectVerify(isolate_);
-  }
-  for (int i = 0; i < maps_.length(); i++) {
-    Map::cast(maps_.get(i)).MapVerify(isolate_);
-  }
-  for (int i = 0; i < contexts_.length(); i++) {
-    Context::cast(contexts_.get(i)).ContextVerify(isolate_);
-  }
-  for (int i = 0; i < functions_.length(); i++) {
-    JSFunction::cast(functions_.get(i)).JSFunctionVerify(isolate_);
-  }
-  for (int i = 0; i < arrays_.length(); i++) {
-    JSArray::cast(arrays_.get(i)).JSArrayVerify(isolate_);
-  }
-  for (int i = 0; i < array_buffers_.length(); i++) {
-    JSArrayBuffer::cast(array_buffers_.get(i)).JSArrayBufferVerify(isolate_);
-  }
-  for (int i = 0; i < typed_arrays_.length(); i++) {
-    JSTypedArray::cast(typed_arrays_.get(i)).JSTypedArrayVerify(isolate_);
-  }
-  for (int i = 0; i < data_views_.length(); i++) {
-    JSDataView::cast(data_views_.get(i)).JSDataViewVerify(isolate_);
-  }
-  for (int i = 0; i < objects_.length(); i++) {
-    JSObject::cast(objects_.get(i)).JSObjectVerify(isolate_);
-  }
-  for (int i = 0; i < classes_.length(); i++) {
-    JSFunction::cast(classes_.get(i)).JSFunctionVerify(isolate_);
-  }
-}
-#endif
-
-bool WebSnapshotDeserializer::DeserializeSnapshot(bool skip_exports) {
-  CollectBuiltinObjects();
-
-  deferred_references_ = ArrayList::New(isolate_, 30);
-
-  const void* magic_bytes;
-  if (!deserializer_->ReadRawBytes(sizeof(kMagicNumber), &magic_bytes) ||
-      memcmp(magic_bytes, kMagicNumber, sizeof(kMagicNumber)) != 0) {
-    Throw("Invalid magic number");
-    return false;
-  }
-
-  DeserializeStrings();
-  DeserializeSymbols();
-  DeserializeBigInts();
-  DeserializeBuiltinObjects();
-  DeserializeMaps();
-  DeserializeContexts();
-  DeserializeFunctions();
-  DeserializeArrays();
-  DeserializeArrayBuffers();
-  DeserializeTypedArrays();
-  DeserializeDataViews();
-  DeserializeObjects();
-  DeserializeClasses();
-  ProcessDeferredReferences();
-  DeserializeExports(skip_exports);
-  DCHECK_EQ(0, deferred_references_->Length());
-
-#ifdef VERIFY_HEAP
-  // Verify the objects we produced during deserializing snapshot.
-  if (v8_flags.verify_heap && !has_error()) {
-    VerifyObjects();
-  }
-#endif
-
-  return !has_error();
-}
-
-void WebSnapshotDeserializer::CollectBuiltinObjects() {
-  // TODO(v8:11525): Look up the builtin objects from the global object.
-  builtin_object_name_to_object_ =
-      ObjectHashTable::New(isolate_, kBuiltinObjectCount);
-#if DEBUG
-  int i = 0;
-#endif
-  IterateBuiltinObjects([&](Handle<String> name, Handle<HeapObject> object) {
-    auto new_builtin_object_name_to_object =
-        ObjectHashTable::Put(builtin_object_name_to_object_, name, object);
-    USE(new_builtin_object_name_to_object);
-    // We preallocated the correct size, so the hash table doesn't grow.
-    DCHECK_EQ(*new_builtin_object_name_to_object,
-              *builtin_object_name_to_object_);
-#if DEBUG
-    ++i;
-#endif
-  });
-  DCHECK_EQ(i, kBuiltinObjectCount);
-}
-
-bool WebSnapshotDeserializer::DeserializeScript() {
-  // If there is more data, treat it as normal JavaScript.
-  DCHECK_LE(deserializer_->position_, deserializer_->end_);
-  auto remaining_bytes = deserializer_->end_ - deserializer_->position_;
-  if (remaining_bytes > 0 && remaining_bytes < v8::String::kMaxLength) {
-    v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
-    v8::Local<v8::String> source =
-        v8::String::NewFromUtf8(
-            v8_isolate, reinterpret_cast<const char*>(deserializer_->position_),
-            NewStringType::kNormal, static_cast<int>(remaining_bytes))
-            .ToLocalChecked();
-
-    ScriptOrigin origin(v8_isolate, Utils::ToLocal(script_name_));
-
-    ScriptCompiler::Source script_source(source, origin);
-    Local<UnboundScript> script;
-    if (!ScriptCompiler::CompileUnboundScript(v8_isolate, &script_source)
-             .ToLocal(&script)) {
-      // The exception has already been reported.
-      DCHECK(!isolate_->has_pending_exception());
-      return false;
-    }
-    Local<Value> result;
-    if (!script->BindToCurrentContext()
-             ->Run(v8_isolate->GetCurrentContext())
-             .ToLocal(&result)) {
-      // The exception has already been reported.
-      DCHECK(!isolate_->has_pending_exception());
-      return false;
-    }
-  }
-
-  return !has_error();
-}
-
-void WebSnapshotDeserializer::DeserializeStrings() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Strings);
-  if (!ReadCount(string_count_)) {
-    Throw("Malformed string table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  strings_handle_ = factory()->NewFixedArray(string_count_);
-  strings_ = *strings_handle_;
-  for (uint32_t i = 0; i < string_count_; ++i) {
-    MaybeHandle<String> maybe_string =
-        deserializer_->ReadUtf8String(AllocationType::kOld);
-    Handle<String> string;
-    if (!maybe_string.ToHandle(&string)) {
-      Throw("Malformed string");
-      return;
-    }
-    strings_.set(i, *string);
-  }
-}
-
-String WebSnapshotDeserializer::ReadString(
-    InternalizeStrings internalize_strings) {
-  DCHECK(!strings_handle_->is_null());
-  uint32_t string_id;
-  if (!deserializer_->ReadUint32(&string_id) || string_id >= string_count_) {
-    Throw("malformed string id\n");
-    return roots_.empty_string();
-  }
-  String string = String::cast(strings_.get(string_id));
-  if (internalize_strings == InternalizeStrings::kYes &&
-      !string.IsInternalizedString(isolate_)) {
-    string = *factory()->InternalizeString(handle(string, isolate_));
-    strings_.set(string_id, string);
-  }
-  return string;
-}
-
-String WebSnapshotDeserializer::ReadInPlaceString(
-    InternalizeStrings internalize_strings) {
-  MaybeHandle<String> maybe_string =
-      deserializer_->ReadUtf8String(AllocationType::kOld);
-  Handle<String> string;
-  if (!maybe_string.ToHandle(&string)) {
-    Throw("Malformed string");
-    return roots_.empty_string();
-  }
-  if (internalize_strings == InternalizeStrings::kYes) {
-    string = factory()->InternalizeString(string);
-  }
-  return *string;
-}
-
-Object WebSnapshotDeserializer::ReadSymbol() {
-  DCHECK(!symbols_handle_->is_null());
-  uint32_t symbol_id;
-  if (!deserializer_->ReadUint32(&symbol_id) || symbol_id >= symbol_count_) {
-    Throw("malformed symbol id\n");
-    return roots_.undefined_value();
-  }
-  return symbols_.get(symbol_id);
-}
-
-Object WebSnapshotDeserializer::ReadBigInt() {
-  DCHECK(!bigints_handle_->is_null());
-  uint32_t bigint_id;
-  if (!deserializer_->ReadUint32(&bigint_id) || bigint_id >= bigint_count_) {
-    Throw("malformed bigint id\n");
-    return roots_.undefined_value();
-  }
-  return bigints_.get(bigint_id);
-}
-
-void WebSnapshotDeserializer::DeserializeBigInts() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_BigInts);
-  if (!ReadCount(bigint_count_)) {
-    Throw("Malformed bigint table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  bigints_handle_ = factory()->NewFixedArray(bigint_count_);
-  bigints_ = *bigints_handle_;
-  for (uint32_t i = 0; i < bigint_count_; ++i) {
-    uint32_t flags;
-    if (!deserializer_->ReadUint32(&flags)) {
-      Throw("malformed bigint flag");
-      return;
-    }
-    int byte_length = BigIntLengthBitField::decode(flags);
-    base::Vector<const uint8_t> digits_storage;
-    if (!deserializer_->ReadRawBytes(byte_length).To(&digits_storage)) {
-      Throw("malformed bigint");
-      return;
-    }
-    Handle<BigInt> bigint;
-    // BigIntFlags are browser independent, so we explicity convert BigIntFlags
-    // to BigInt bitfield here though they are same now.
-    if (!BigInt::FromSerializedDigits(isolate_, BigIntFlagsToBitField(flags),
-                                      digits_storage)
-             .ToHandle(&bigint)) {
-      Throw("malformed bigint");
-      return;
-    }
-    bigints_.set(i, *bigint);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeSymbols() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Symbols);
-  if (!ReadCount(symbol_count_)) {
-    Throw("Malformed symbol table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  symbols_handle_ = factory()->NewFixedArray(symbol_count_);
-  symbols_ = *symbols_handle_;
-  for (uint32_t i = 0; i < symbol_count_; ++i) {
-    uint32_t symbol_type;
-    if (!deserializer_->ReadUint32(&symbol_type) || symbol_type > 2) {
-      Throw("malformed symbol\n");
-    }
-
-    Handle<Symbol> symbol;
-    if (symbol_type == SymbolType::kNonGlobalNoDesription) {
-      symbol = factory()->NewSymbol();
-    } else {  // Symbol with description
-      uint32_t string_id;
-      if (!deserializer_->ReadUint32(&string_id) ||
-          string_id >= string_count_) {
-        Throw("malformed string id\n");
-      }
-      if (symbol_type == SymbolType::kNonGlobal) {
-        symbol = factory()->NewSymbol();
-        symbol->set_description(String::cast(strings_.get(string_id)));
-      } else {
-        DCHECK_EQ(SymbolType::kGlobal, symbol_type);
-        symbol = isolate_->SymbolFor(
-            RootIndex::kPublicSymbolTable,
-            handle(String::cast(strings_.get(string_id)), isolate_), false);
-      }
-    }
-    symbols_.set(i, *symbol);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeMaps() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Maps);
-  if (!ReadCount(map_count_)) {
-    Throw("Malformed shape table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  maps_handle_ = factory()->NewFixedArray(map_count_);
-  maps_ = *maps_handle_;
-  for (uint32_t i = 0; i < map_count_; ++i) {
-    bool has_custom_property_attributes = ReadMapType();
-
-    uint32_t property_count;
-    if (!deserializer_->ReadUint32(&property_count)) {
-      Throw("Malformed shape");
-      return;
-    }
-    // TODO(v8:11525): Consider passing the upper bound as a param and
-    // systematically enforcing it on the ValueSerializer side.
-    // TODO(v8:11525): Allow "objects with map" which need to be turned to
-    // dictionary mode objects.
-    // TODO(v8:11525): Create map trees.
-    if (property_count > kMaxNumberOfDescriptors) {
-      Throw("Malformed shape: too many properties");
-      return;
-    }
-
-    if (property_count == 0) {
-      Handle<Map> map = DeserializeObjectPrototypeAndCreateEmptyMap();
-      maps_.set(i, *map);
-      continue;
-    }
-
-    Handle<DescriptorArray> descriptors =
-        factory()->NewDescriptorArray(property_count, 0);
-    for (InternalIndex i : InternalIndex::Range(property_count)) {
-      // No deferred references here, since strings and symbols have already
-      // been deserialized.
-      Object key = std::get<0>(
-          ReadValue(Handle<HeapObject>(), 0, InternalizeStrings::kYes));
-      DisallowGarbageCollection no_gc;
-      if (!key.IsName()) {
-        Throw("Invalid map key");
-        return;
-      }
-      PropertyAttributes attributes = PropertyAttributes::NONE;
-      if (has_custom_property_attributes) {
-        uint8_t flags;
-        if (!deserializer_->ReadByte(&flags)) {
-          Throw("Malformed property attributes");
-          return;
-        }
-        attributes = FlagsToAttributes(flags);
-      }
-      // Use the "none" representation until we see the first object having this
-      // map. At that point, modify the representation.
-      Descriptor desc =
-          Descriptor::DataField(isolate_, handle(Name::cast(key), isolate_),
-                                i.as_int(), attributes, Representation::None());
-      descriptors->Set(i, &desc);
-    }
-    DCHECK_EQ(descriptors->number_of_descriptors(), property_count);
-    descriptors->Sort();
-
-    Handle<Map> map = factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize,
-                                        HOLEY_ELEMENTS, 0);
-    map->InitializeDescriptors(isolate_, *descriptors);
-    // TODO(v8:11525): Set 'constructor'.
-    DeserializeObjectPrototype(map);
-    maps_.set(i, *map);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeBuiltinObjects() {
-  RCS_SCOPE(isolate_,
-            RuntimeCallCounterId::kWebSnapshotDeserialize_BuiltinObjects);
-  if (!ReadCount(builtin_object_count_)) {
-    Throw("Malformed builtin object table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  builtin_objects_handle_ = factory()->NewFixedArray(builtin_object_count_);
-  builtin_objects_ = *builtin_objects_handle_;
-  for (uint32_t i = 0; i < builtin_object_count_; ++i) {
-    Handle<String> name = handle(ReadString(), isolate_);
-    builtin_objects_.set(static_cast<int>(i),
-                         builtin_object_name_to_object_->Lookup(name));
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeContexts() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Contexts);
-  if (!ReadCount(context_count_)) {
-    Throw("Malformed context table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  contexts_handle_ = factory()->NewFixedArray(context_count_);
-  contexts_ = *contexts_handle_;
-  for (uint32_t i = 0; i < context_count_; ++i) {
-    uint32_t context_type;
-    if (!deserializer_->ReadUint32(&context_type)) {
-      Throw("Malformed context type");
-      return;
-    }
-
-    uint32_t parent_context_id;
-    // Parent context is serialized before child context. Note: not >= on
-    // purpose, we're going to subtract 1 later.
-    if (!deserializer_->ReadUint32(&parent_context_id) ||
-        parent_context_id > i) {
-      Throw("Malformed context");
-      return;
-    }
-
-    uint32_t variable_count;
-    if (!deserializer_->ReadUint32(&variable_count)) {
-      Throw("Malformed context");
-      return;
-    }
-    const bool has_inlined_local_names =
-        variable_count < kScopeInfoMaxInlinedLocalNamesSize;
-    // TODO(v8:11525): Enforce upper limit for variable count.
-    Handle<ScopeInfo> scope_info = CreateScopeInfo(
-        variable_count, parent_context_id > 0,
-        static_cast<ContextType>(context_type), has_inlined_local_names);
-
-    Handle<Context> parent_context;
-    if (parent_context_id > 0) {
-      parent_context =
-          handle(Context::cast(contexts_.get(parent_context_id - 1)), isolate_);
-      scope_info->set_outer_scope_info(parent_context->scope_info());
-    } else {
-      parent_context = handle(isolate_->context(), isolate_);
-    }
-
-    const int local_names_container_size =
-        has_inlined_local_names ? variable_count : 1;
-    const int context_local_base = ScopeInfo::kVariablePartIndex;
-    const int context_local_info_base =
-        context_local_base + local_names_container_size;
-
-    for (int variable_index = 0;
-         variable_index < static_cast<int>(variable_count); ++variable_index) {
-      {
-        String name = ReadString(InternalizeStrings::kYes);
-        if (has_inlined_local_names) {
-          scope_info->set(context_local_base + variable_index, name);
-        } else {
-          Handle<NameToIndexHashTable> local_names_hashtable(
-              scope_info->context_local_names_hashtable(), isolate_);
-
-          Handle<NameToIndexHashTable> new_table =
-              NameToIndexHashTable::Add(isolate_, local_names_hashtable,
-                                        handle(name, isolate_), variable_index);
-          // The hash table didn't grow, since it was preallocated to
-          // be large enough in CreateScopeInfo.
-          DCHECK_EQ(*new_table, *local_names_hashtable);
-          USE(new_table);
-        }
-      }
-      // TODO(v8:11525): Support variable modes etc.
-      uint32_t info =
-          ScopeInfo::VariableModeBits::encode(VariableMode::kLet) |
-          ScopeInfo::InitFlagBit::encode(
-              InitializationFlag::kNeedsInitialization) |
-          ScopeInfo::MaybeAssignedFlagBit::encode(
-              MaybeAssignedFlag::kMaybeAssigned) |
-          ScopeInfo::ParameterNumberBits::encode(
-              ScopeInfo::ParameterNumberBits::kMax) |
-          ScopeInfo::IsStaticFlagBit::encode(IsStaticFlag::kNotStatic);
-      scope_info->set(context_local_info_base + variable_index,
-                      Smi::FromInt(info));
-    }
-
-    // Allocate the FunctionContext after setting up the ScopeInfo to avoid
-    // pointing to a ScopeInfo which is not set up yet.
-    Handle<Context> context;
-    switch (context_type) {
-      case ContextType::FUNCTION:
-        context = factory()->NewFunctionContext(parent_context, scope_info);
-        break;
-      case ContextType::BLOCK:
-        context = factory()->NewBlockContext(parent_context, scope_info);
-        break;
-      default:
-        Throw("Unsupported context type");
-        return;
-    }
-    for (int variable_index = 0;
-         variable_index < static_cast<int>(variable_count); ++variable_index) {
-      int context_index = scope_info->ContextHeaderLength() + variable_index;
-      Object value = std::get<0>(ReadValue(context, context_index));
-      context->set(context_index, value);
-    }
-    contexts_.set(i, *context);
-  }
-}
-
-Handle<ScopeInfo> WebSnapshotDeserializer::CreateScopeInfo(
-    uint32_t variable_count, bool has_parent, ContextType context_type,
-    bool has_inlined_local_names) {
-  // TODO(v8:11525): Decide how to handle language modes. (The code below sets
-  // the language mode as strict.)
-  // TODO(v8:11525): Support (context-allocating) receiver.
-  // TODO(v8:11525): Support function variable & function name.
-  // TODO(v8:11525): Support classes.
-
-  ScopeType scope_type;
-  int flags =
-      ScopeInfo::SloppyEvalCanExtendVarsBit::encode(false) |
-      ScopeInfo::LanguageModeBit::encode(LanguageMode::kStrict) |
-      ScopeInfo::DeclarationScopeBit::encode(false) |
-      ScopeInfo::ReceiverVariableBits::encode(VariableAllocationInfo::NONE) |
-      ScopeInfo::ClassScopeHasPrivateBrandBit::encode(false) |
-      ScopeInfo::HasSavedClassVariableBit::encode(false) |
-      ScopeInfo::HasNewTargetBit::encode(false) |
-      ScopeInfo::FunctionVariableBits::encode(VariableAllocationInfo::NONE) |
-      ScopeInfo::HasInferredFunctionNameBit::encode(false) |
-      ScopeInfo::IsAsmModuleBit::encode(false) |
-      ScopeInfo::HasSimpleParametersBit::encode(false) |
-      ScopeInfo::FunctionKindBits::encode(FunctionKind::kNormalFunction) |
-      ScopeInfo::HasOuterScopeInfoBit::encode(has_parent) |
-      ScopeInfo::IsDebugEvaluateScopeBit::encode(false) |
-      ScopeInfo::ForceContextAllocationBit::encode(false) |
-      ScopeInfo::PrivateNameLookupSkipsOuterClassBit::encode(false) |
-      ScopeInfo::HasContextExtensionSlotBit::encode(false) |
-      ScopeInfo::IsReplModeScopeBit::encode(false) |
-      ScopeInfo::HasLocalsBlockListBit::encode(false);
-  switch (context_type) {
-    case ContextType::FUNCTION:
-      scope_type = ScopeType::FUNCTION_SCOPE;
-      flags |= ScopeInfo::DeclarationScopeBit::encode(true) |
-               ScopeInfo::HasSimpleParametersBit::encode(true);
-      break;
-    case ContextType::BLOCK:
-      scope_type = ScopeType::CLASS_SCOPE;
-      flags |= ScopeInfo::ForceContextAllocationBit::encode(true);
-      break;
-    default:
-      // Default to a CLASS_SCOPE, so that the rest of the code can be executed
-      // without failures.
-      scope_type = ScopeType::CLASS_SCOPE;
-      Throw("Unsupported context type");
-  }
-  flags |= ScopeInfo::ScopeTypeBits::encode(scope_type);
-  const int local_names_container_size =
-      has_inlined_local_names ? variable_count : 1;
-  const int length = ScopeInfo::kVariablePartIndex +
-                     (ScopeInfo::NeedsPositionInfo(scope_type)
-                          ? ScopeInfo::kPositionInfoEntries
-                          : 0) +
-                     (has_parent ? 1 : 0) + local_names_container_size +
-                     variable_count;
-  Handle<NameToIndexHashTable> local_names_hashtable;
-  if (!has_inlined_local_names) {
-    local_names_hashtable = NameToIndexHashTable::New(isolate_, variable_count,
-                                                      AllocationType::kOld);
-  }
-  Handle<ScopeInfo> scope_info = factory()->NewScopeInfo(length);
-  {
-    DisallowGarbageCollection no_gc;
-    ScopeInfo raw = *scope_info;
-
-    raw.set_flags(flags);
-    DCHECK(!raw.IsEmpty());
-
-    raw.set_context_local_count(variable_count);
-    // TODO(v8:11525): Support parameters.
-    raw.set_parameter_count(0);
-    if (raw.HasPositionInfo()) {
-      raw.SetPositionInfo(0, 0);
-    }
-    if (!has_inlined_local_names) {
-      raw.set_context_local_names_hashtable(*local_names_hashtable);
-    }
-  }
-  return scope_info;
-}
-
-Handle<JSFunction> WebSnapshotDeserializer::CreateJSFunction(
-    int shared_function_info_index, uint32_t start_position, uint32_t length,
-    uint32_t parameter_count, uint8_t flags, uint32_t context_id) {
-  // TODO(v8:11525): Deduplicate the SFIs for class methods.
-  FunctionKind kind = FunctionFlagsToFunctionKind(flags);
-  Handle<SharedFunctionInfo> shared = factory()->NewSharedFunctionInfo(
-      factory()->empty_string(), MaybeHandle<InstructionStream>(),
-      Builtin::kCompileLazy, kind);
-  Handle<UncompiledData> uncompiled_data =
-      factory()->NewUncompiledDataWithoutPreparseData(
-          roots_.empty_string_handle(), start_position,
-          start_position + length);
-  {
-    DisallowGarbageCollection no_gc;
-    SharedFunctionInfo raw = *shared;
-    if (IsConciseMethod(kind)) {
-      raw.set_syntax_kind(FunctionSyntaxKind::kAccessorOrMethod);
-    }
-    raw.set_script(*script_);
-    raw.set_function_literal_id(shared_function_info_index);
-    raw.set_internal_formal_parameter_count(JSParameterCount(parameter_count));
-    // TODO(v8:11525): Decide how to handle language modes.
-    raw.set_language_mode(LanguageMode::kStrict);
-    raw.set_uncompiled_data(*uncompiled_data);
-    raw.set_allows_lazy_compilation(true);
-    shared_function_infos_.Set(shared_function_info_index,
-                               HeapObjectReference::Weak(raw));
-  }
-  shared_function_info_table_ = ObjectHashTable::Put(
-      shared_function_info_table_,
-      handle(Smi::FromInt(start_position), isolate_),
-      handle(Smi::FromInt(shared_function_info_index), isolate_));
-
-  Handle<JSFunction> function =
-      Factory::JSFunctionBuilder(isolate_, shared, isolate_->native_context())
-          .Build();
-  if (context_id > 0) {
-    DCHECK_LT(context_id - 1, context_count_);
-    // Guards raw pointer "context" below.
-    DisallowHeapAllocation no_heap_access;
-    Context context = Context::cast(contexts_.get(context_id - 1));
-    function->set_context(context);
-    shared->set_outer_scope_info(context.scope_info());
-  }
-  return function;
-}
-
-void WebSnapshotDeserializer::DeserializeFunctionProperties(
-    Handle<JSFunction> function) {
-  uint32_t map_id;
-  if (!deserializer_->ReadUint32(&map_id) || map_id >= map_count_ + 1) {
-    Throw("Malformed function");
-    return;
-  }
-
-  if (map_id > 0) {
-    map_id--;  // Subtract 1 to get the real map_id.
-    Handle<Map> map(Map::cast(maps_.get(map_id)), isolate_);
-    int no_properties = map->NumberOfOwnDescriptors();
-    Handle<DescriptorArray> descriptors =
-        handle(map->instance_descriptors(kRelaxedLoad), isolate_);
-    Handle<PropertyArray> property_array =
-        DeserializePropertyArray(descriptors, no_properties);
-    // This function map was already deserialized completely and can be
-    // directly used.
-    auto iter = deserialized_function_maps_.find(map_id);
-    if (iter != deserialized_function_maps_.end()) {
-      function->set_map(*iter->second, kReleaseStore);
-      function->set_raw_properties_or_hash(*property_array);
-    } else {
-      // TODO(v8:11525): In-object properties.
-      Handle<Map> function_map = Map::Copy(
-          isolate_, handle(function->map(), isolate_), "Web Snapshot");
-      Map::EnsureDescriptorSlack(isolate_, function_map,
-                                 descriptors->number_of_descriptors());
-      {
-        for (InternalIndex i : map->IterateOwnDescriptors()) {
-          Descriptor d = Descriptor::DataField(
-              isolate_, handle(descriptors->GetKey(i), isolate_),
-              descriptors->GetDetails(i).field_index(),
-              descriptors->GetDetails(i).attributes(),
-              descriptors->GetDetails(i).representation());
-          function_map->instance_descriptors().Append(&d);
-          if (d.GetKey()->IsInterestingSymbol()) {
-            function_map->set_may_have_interesting_symbols(true);
-          }
-        }
-        function_map->SetNumberOfOwnDescriptors(
-            function_map->NumberOfOwnDescriptors() +
-            descriptors->number_of_descriptors());
-        function->set_map(*function_map, kReleaseStore);
-        function->set_raw_properties_or_hash(*property_array);
-      }
-      deserialized_function_maps_.insert(std::make_pair(map_id, function_map));
-    }
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeFunctions() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Functions);
-  if (!ReadCount(function_count_)) {
-    Throw("Malformed function table");
-    return;
-  }
-  static_assert(kMaxItemCount + 1 <= FixedArray::kMaxLength);
-  functions_handle_ = factory()->NewFixedArray(function_count_);
-  functions_ = *functions_handle_;
-
-  // Overallocate the array for SharedFunctionInfos; functions which we
-  // deserialize soon will create more SharedFunctionInfos when called.
-  shared_function_infos_handle_ = factory()->NewWeakFixedArray(
-      WeakArrayList::CapacityForLength(function_count_ + 1),
-      AllocationType::kOld);
-  shared_function_infos_ = *shared_function_infos_handle_;
-  shared_function_info_table_ = ObjectHashTable::New(isolate_, function_count_);
-  script_ = factory()->NewScript(factory()->empty_string());
-  {
-    DisallowGarbageCollection no_gc;
-    Script raw = *script_;
-    raw.set_type(Script::TYPE_WEB_SNAPSHOT);
-    raw.set_shared_function_infos(shared_function_infos_);
-    raw.set_shared_function_info_table(*shared_function_info_table_);
-  }
-
-  for (; current_function_count_ < function_count_; ++current_function_count_) {
-    uint32_t context_id;
-    // Note: > (not >= on purpose, we will subtract 1).
-    if (!deserializer_->ReadUint32(&context_id) ||
-        context_id > context_count_) {
-      Throw("Malformed function");
-      return;
-    }
-    {
-      String source = ReadString();
-      DisallowGarbageCollection no_gc;
-      if (current_function_count_ == 0) {
-        script_->set_source(source);
-      } else {
-        // TODO(v8:11525): Support multiple source snippets.
-        DCHECK_EQ(script_->source(), source);
-      }
-    }
-
-    uint32_t start_position;
-    uint32_t length;
-    uint32_t parameter_count;
-    uint8_t flags;
-    if (!deserializer_->ReadUint32(&start_position) ||
-        !deserializer_->ReadUint32(&length) ||
-        !deserializer_->ReadUint32(&parameter_count) ||
-        !deserializer_->ReadByte(&flags)) {
-      Throw("Malformed function");
-      return;
-    }
-
-    // Index 0 is reserved for top-level shared function info (which web
-    // snapshot scripts don't have).
-    Handle<JSFunction> function =
-        CreateJSFunction(current_function_count_ + 1, start_position, length,
-                         parameter_count, flags, context_id);
-    functions_.set(current_function_count_, *function);
-
-    ReadFunctionPrototype(function);
-    DeserializeFunctionProperties(function);
-    DeserializeObjectPrototypeForFunction(function);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeClasses() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Classes);
-  if (!ReadCount(class_count_)) {
-    Throw("Malformed class table");
-    return;
-  }
-  static_assert(kMaxItemCount + 1 <= FixedArray::kMaxLength);
-  classes_handle_ = factory()->NewFixedArray(class_count_);
-  classes_ = *classes_handle_;
-
-  // Grow the array for SharedFunctionInfos.
-  shared_function_infos_handle_ = WeakFixedArray::EnsureSpace(
-      isolate_, shared_function_infos_handle_,
-      WeakArrayList::CapacityForLength(function_count_ + 1 + class_count_));
-  shared_function_infos_ = *shared_function_infos_handle_;
-  script_->set_shared_function_infos(shared_function_infos_);
-
-  for (; current_class_count_ < class_count_; ++current_class_count_) {
-    uint32_t context_id;
-    // Note: > (not >= on purpose, we will subtract 1).
-    if (!deserializer_->ReadUint32(&context_id) ||
-        context_id > context_count_) {
-      Throw("Malformed class");
-      return;
-    }
-
-    {
-      String source = ReadString();
-      if (current_function_count_ + current_class_count_ == 0) {
-        script_->set_source(source);
-      } else {
-        // TODO(v8:11525): Support multiple source snippets.
-        DCHECK_EQ(script_->source(), source);
-      }
-    }
-
-    uint32_t start_position;
-    uint32_t length;
-    uint32_t parameter_count;
-    uint8_t flags;
-    if (!deserializer_->ReadUint32(&start_position) ||
-        !deserializer_->ReadUint32(&length) ||
-        !deserializer_->ReadUint32(&parameter_count) ||
-        !deserializer_->ReadByte(&flags)) {
-      Throw("Malformed class");
-      return;
-    }
-
-    // Index 0 is reserved for top-level shared function info (which web
-    // snapshot scripts don't have).
-    Handle<JSFunction> function = CreateJSFunction(
-        function_count_ + current_class_count_ + 1, start_position, length,
-        parameter_count, flags, context_id);
-
-    ReadFunctionPrototype(function);
-    // TODO(v8:11525): Use serialized start_position and length to add
-    // ClassPositions property to class.
-    DeserializeFunctionProperties(function);
-    DeserializeObjectPrototypeForFunction(function);
-    classes_.set(current_class_count_, *function);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeObjectPrototype(Handle<Map> map) {
-  auto result = ReadValue(map, 0, InternalizeStrings::kNo);
-  Object prototype = std::get<0>(result);
-  bool was_deferred = std::get<1>(result);
-  if (!was_deferred) {
-    SetPrototype(map, handle(prototype, isolate_));
-  }
-}
-
-bool WebSnapshotDeserializer::IsInitialFunctionPrototype(Object prototype) {
-  return prototype == isolate_->context().function_prototype() ||
-         // Asyncfunction prototype.
-         prototype == isolate_->context()
-                          .async_function_constructor()
-                          .instance_prototype() ||
-         // GeneratorFunction prototype.
-         prototype == JSFunction::cast(isolate_->context()
-                                           .generator_function_map()
-                                           .constructor_or_back_pointer())
-                          .instance_prototype() ||
-         // AsyncGeneratorFunction prototype
-         prototype == JSFunction::cast(isolate_->context()
-                                           .async_generator_function_map()
-                                           .constructor_or_back_pointer())
-                          .instance_prototype();
-}
-
-void WebSnapshotDeserializer::DeserializeObjectPrototypeForFunction(
-    Handle<JSFunction> function) {
-  Handle<Map> map(function->map(), isolate_);
-  // If the function prototype is not the initial function prototype, then the
-  // map must not be the canonical maps because we already copy the map when
-  // deserializaing the map for the function. And so we don't need to copy the
-  // map.
-  // TODO(v8:11525): Ensure we create the same map tree as for non-websnapshot
-  // functions + add a test.
-  auto result = ReadValue(map, 0, InternalizeStrings::kNo);
-  Object prototype = std::get<0>(result);
-  bool was_deferred = std::get<1>(result);
-  // If we got a deferred reference, the prototype cannot be a builtin; those
-  // references aren't deferred.
-  // TODO(v8:11525): if the object order is relaxed, it's possible to have a
-  // deferred reference to Function.prototype, and we'll need to recognize and
-  // handle that case.
-  if (IsInitialFunctionPrototype(prototype)) {
-    DCHECK(IsInitialFunctionPrototype(function->map().prototype()));
-    return;
-  }
-  if (!was_deferred) {
-    SetPrototype(map, handle(prototype, isolate_));
-  }
-}
-
-Handle<Map>
-WebSnapshotDeserializer::DeserializeObjectPrototypeAndCreateEmptyMap() {
-  Handle<Map> map = factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize,
-                                      HOLEY_ELEMENTS, 0);
-  auto result = ReadValue(map, 0, InternalizeStrings::kNo);
-  Object prototype = std::get<0>(result);
-  bool was_deferred = std::get<1>(result);
-  // If we got a deferred reference, the prototype cannot be a builtin; those
-  // references aren't deferred.
-  // TODO(v8:11525): if the object order is relaxed, it's possible to have a
-  // deferred reference to Object.prototype, and we'll need to recognize and
-  // handle that case.
-  if (prototype == isolate_->context().initial_object_prototype()) {
-    // TODO(v8:11525): Avoid map creation (above) in this case.
-    // TODO(v8:11525): Should the __proto__ be a property of the map or a
-    // property of the object? Investigate which solution is better for the
-    // other JS engines.
-    return handle(isolate_->native_context()->object_function().initial_map(),
-                  isolate_);
-  }
-  if (!was_deferred) {
-    SetPrototype(map, handle(prototype, isolate_));
-  }
-  return map;
-}
-
-void WebSnapshotDeserializer::SetPrototype(Handle<Map> map,
-                                           Handle<Object> prototype) {
-  if (prototype->IsJSObject()) {
-    HeapObject::cast(*prototype).map().set_is_prototype_map(true);
-    Map::SetPrototype(isolate_, map, Handle<JSObject>::cast(prototype));
-  } else if (prototype->IsNull(isolate_)) {
-    map->set_prototype(HeapObject::cast(*prototype));
-  } else {
-    Throw("Invalid prototype");
-  }
-}
-
-template <typename T>
-void WebSnapshotDeserializer::DeserializeObjectPropertiesWithDictionaryMap(
-    T dict, uint32_t property_count, bool has_custom_property_attributes) {
-  for (uint32_t i = 0; i < property_count; i++) {
-    Handle<Object> key(std::get<0>(ReadValue(Handle<HeapObject>(), 0,
-                                             InternalizeStrings::kYes)),
-                       isolate_);
-    if (!key->IsName()) {
-      Throw("Invalid map key");
-      return;
-    }
-    Handle<Object> value(std::get<0>(ReadValue()), isolate_);
-    PropertyAttributes attributes = PropertyAttributes::NONE;
-    if (has_custom_property_attributes) {
-      uint8_t flags;
-      if (!deserializer_->ReadByte(&flags)) {
-        Throw("Malformed property attributes");
-        return;
-      }
-      attributes = FlagsToAttributes(flags);
-    }
-
-    PropertyDetails details(PropertyKind::kData, attributes,
-                            PropertyDetails::kConstIfDictConstnessTracking);
-    auto new_dict =
-        dict->Add(isolate_, dict, Handle<Name>::cast(key), value, details);
-    // The dictionary didn't grow, since it was preallocated to be large enough
-    // in DeserializeObjects.
-    DCHECK_EQ(*new_dict, *dict);
-    USE(new_dict);
-  }
-}
-
-bool WebSnapshotDeserializer::ReadMapType() {
-  uint32_t map_type;
-  if (!deserializer_->ReadUint32(&map_type)) {
-    Throw("Malformed shape");
-    return false;
-  }
-
-  switch (map_type) {
-    case PropertyAttributesType::DEFAULT:
-      return false;
-    case PropertyAttributesType::CUSTOM:
-      return true;
-    default:
-      Throw("Unsupported map type");
-      return false;
-  }
-}
-
-Handle<PropertyArray> WebSnapshotDeserializer::DeserializePropertyArray(
-    Handle<DescriptorArray> descriptors, int no_properties) {
-  Handle<PropertyArray> property_array =
-      factory()->NewPropertyArray(no_properties);
-  for (int i = 0; i < no_properties; ++i) {
-    Object value = std::get<0>(ReadValue(property_array, i));
-    DisallowGarbageCollection no_gc;
-    // Read the representation from the map.
-    DescriptorArray raw_descriptors = *descriptors;
-    PropertyDetails details = raw_descriptors.GetDetails(InternalIndex(i));
-    CHECK_EQ(details.location(), PropertyLocation::kField);
-    CHECK_EQ(PropertyKind::kData, details.kind());
-    Representation r = details.representation();
-    if (r.IsNone()) {
-      // Switch over to wanted_representation.
-      details = details.CopyWithRepresentation(Representation::Tagged());
-      raw_descriptors.SetDetails(InternalIndex(i), details);
-    } else if (!r.Equals(Representation::Tagged())) {
-      // TODO(v8:11525): Support this case too.
-      UNREACHABLE();
-    }
-    property_array->set(i, value);
-  }
-  return property_array;
-}
-
-void WebSnapshotDeserializer::DeserializeObjects() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Objects);
-  if (!ReadCount(object_count_)) {
-    Throw("Malformed objects table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  objects_handle_ = factory()->NewFixedArray(object_count_);
-  objects_ = *objects_handle_;
-  bool map_from_snapshot = false;
-  for (; current_object_count_ < object_count_; ++current_object_count_) {
-    uint32_t map_id;
-    if (!deserializer_->ReadUint32(&map_id) || map_id >= map_count_ + 1) {
-      Throw("Malformed object");
-      return;
-    }
-    Handle<JSObject> object;
-    if (map_id > 0) {
-      map_id--;  // Subtract 1 to get the real map_id.
-      Map raw_map = Map::cast(maps_.get(map_id));
-      map_from_snapshot = true;
-      Handle<DescriptorArray> descriptors =
-          handle(raw_map.instance_descriptors(kRelaxedLoad), isolate_);
-      int no_properties = raw_map.NumberOfOwnDescriptors();
-      // TODO(v8:11525): In-object properties.
-      Handle<Map> map(raw_map, isolate_);
-      Handle<PropertyArray> property_array =
-          DeserializePropertyArray(descriptors, no_properties);
-      object = factory()->NewJSObjectFromMap(map);
-      object->set_raw_properties_or_hash(*property_array, kRelaxedStore);
-    } else {
-      Handle<Map> map = factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize,
-                                          HOLEY_ELEMENTS, 0);
-      map->set_may_have_interesting_symbols(true);
-      map->set_is_dictionary_map(true);
-
-      bool has_custom_property_attributes = ReadMapType();
-
-      uint32_t property_count;
-      if (!deserializer_->ReadUint32(&property_count)) {
-        Throw("Malformed object");
-        return;
-      }
-      // TODO(v8:11525): Allow "non-map" objects which are small enough to have
-      // a fast map.
-      if (property_count <= kMaxNumberOfDescriptors) {
-        Throw("Malformed object: too few properties for 'no map' object");
-        return;
-      }
-
-      if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOL) {
-        Handle<SwissNameDictionary> swiss_dictionary =
-            isolate_->factory()->NewSwissNameDictionary(property_count);
-        DeserializeObjectPropertiesWithDictionaryMap(
-            swiss_dictionary, property_count, has_custom_property_attributes);
-        object = factory()->NewJSObjectFromMap(map);
-        object->SetProperties(*swiss_dictionary);
-      } else {
-        Handle<NameDictionary> dictionary =
-            isolate_->factory()->NewNameDictionary(property_count);
-        DeserializeObjectPropertiesWithDictionaryMap(
-            dictionary, property_count, has_custom_property_attributes);
-        object = factory()->NewJSObjectFromMap(map);
-        object->SetProperties(*dictionary);
-      }
-      DeserializeObjectPrototype(map);
-    }
-    DCHECK(!object->is_null());
-
-    DeserializeObjectElements(object, map_from_snapshot);
-    objects_.set(static_cast<int>(current_object_count_), *object);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeObjectElements(
-    Handle<JSObject> object, bool map_from_snapshot) {
-  auto [elements, elements_kind, length] = DeserializeElements();
-  USE(length);
-  // Ensure objects always get HOLEY_ELEMENTS or DICTIONARY_ELEMENTS: don't
-  // change the elements kind if it's holey.
-  DCHECK(object->HasHoleyElements());
-  if (IsDictionaryElementsKind(elements_kind)) {
-    DCHECK_GT(length, 0);
-    Handle<Map> map(object->map(), isolate_);
-    if (map_from_snapshot) {
-      // Copy the map so that we don't end up modifying the maps coming from
-      // the web snapshot, since they might get reused.
-      // TODO(v8:11525): Is it reasonable to encode the elements kind to the
-      // map? Investigate what other JS engines do.
-      // TODO(v8:11525): Add a test where two objects share the map but have
-      // different elements kinds.
-      map = Map::Copy(isolate_, map, "Web Snapshot");
-      object->set_map(*map, kReleaseStore);
-    }
-    map->set_elements_kind(elements_kind);
-  }
-  object->set_elements(*elements);
-  DCHECK(object->HasHoleyElements() || object->HasDictionaryElements());
-}
-
-WebSnapshotDeserializer::ElementsType
-WebSnapshotDeserializer::ReadElementsType() {
-  uint32_t elements_type;
-  if (!deserializer_->ReadUint32(&elements_type)) {
-    Throw("Malformed elements type");
-    return ElementsType::kDense;
-  }
-  if (elements_type != ElementsType::kDense &&
-      elements_type != ElementsType::kSparse) {
-    Throw("Unknown elements type");
-    return ElementsType::kDense;
-  }
-  return static_cast<ElementsType>(elements_type);
-}
-
-std::tuple<Handle<FixedArrayBase>, ElementsKind, uint32_t>
-WebSnapshotDeserializer::DeserializeElements() {
-  uint32_t length;
-  ElementsType elements_type = ReadElementsType();
-  if (!deserializer_->ReadUint32(&length) || length > kMaxItemCount) {
-    Throw("Malformed elements");
-    return std::make_tuple(factory()->NewFixedArray(0), PACKED_SMI_ELEMENTS, 0);
-  }
-  if (elements_type == ElementsType::kDense) {
-    // TODO(v8:11525): we need to convert the elements to dictionary mode if
-    // there are too many elements for packed elements.
-    return ReadDenseElements(length);
-  } else {
-    // TODO(v8:11525): we need to convert sparse elements to packed elements
-    // (including double elements) if the elements fit into packed elements
-    // kind.
-    return ReadSparseElements(length);
-  }
-}
-
-std::tuple<Handle<FixedArrayBase>, ElementsKind, uint32_t>
-WebSnapshotDeserializer::ReadDenseElements(uint32_t length) {
-  Handle<FixedArray> elements = factory()->NewFixedArray(length);
-  ElementsKind elements_kind = PACKED_SMI_ELEMENTS;
-  bool has_hole = false;
-  bool has_non_number = false;
-  for (uint32_t i = 0; i < length; ++i) {
-    Object value = std::get<0>(ReadValue(elements, i));
-    DisallowGarbageCollection no_gc;
-    if (!value.IsSmi()) {
-      elements_kind = PACKED_ELEMENTS;
-    }
-    if (!value.IsNumber()) {
-      has_non_number = true;
-    }
-    if (value.IsTheHole()) {
-      has_hole = true;
-    }
-    elements->set(static_cast<int>(i), value);
-  }
-  if (has_hole) {
-    elements_kind =
-        elements_kind == PACKED_ELEMENTS ? HOLEY_ELEMENTS : HOLEY_SMI_ELEMENTS;
-  }
-  // If all elements are number and not all elements are smi, we could convert
-  // the array to double array.
-  if (!has_non_number && !IsSmiElementsKind(elements_kind)) {
-    DCHECK(IsObjectElementsKind(elements_kind));
-    ElementsKind new_elements_kind =
-        has_hole ? HOLEY_DOUBLE_ELEMENTS : PACKED_DOUBLE_ELEMENTS;
-    Handle<FixedArrayBase> new_elements =
-        isolate_->factory()->NewFixedDoubleArray(length);
-    ElementsAccessor* element_accessor =
-        ElementsAccessor::ForKind(new_elements_kind);
-    element_accessor->CopyElements(isolate_, elements, elements_kind,
-                                   new_elements, length);
-    return std::make_tuple(new_elements, new_elements_kind, length);
-  }
-  return std::make_tuple(elements, elements_kind, length);
-}
-
-std::tuple<Handle<FixedArrayBase>, ElementsKind, uint32_t>
-WebSnapshotDeserializer::ReadSparseElements(uint32_t length) {
-  Handle<NumberDictionary> dict = NumberDictionary::New(isolate_, length);
-  uint32_t max_element_index = 0;
-  for (uint32_t i = 0; i < length; ++i) {
-    uint32_t element_index;
-    if (!deserializer_->ReadUint32(&element_index)) {
-      Throw("Malformed element index in sparse elements");
-      return std::make_tuple(dict, DICTIONARY_ELEMENTS, 0);
-    }
-    Object value = std::get<0>(ReadValue(dict, element_index));
-    Handle<NumberDictionary> new_dict =
-        dict->Set(isolate_, dict, element_index, handle(value, isolate_));
-    // The number dictionary didn't grow, since it was preallocated to be
-    // large enough before.
-    DCHECK_EQ(*new_dict, *dict);
-    USE(new_dict);
-    if (element_index > max_element_index) {
-      max_element_index = element_index;
-    }
-  }
-  // Bypasses JSObject::RequireSlowElements which is fine when we're setting up
-  // objects from the web snapshot.
-  dict->UpdateMaxNumberKey(max_element_index, Handle<JSObject>());
-  return std::make_tuple(dict, DICTIONARY_ELEMENTS, max_element_index + 1);
-}
-
-void WebSnapshotDeserializer::DeserializeArrays() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Arrays);
-  if (!ReadCount(array_count_)) {
-    Throw("Malformed array table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  arrays_handle_ = factory()->NewFixedArray(array_count_);
-  arrays_ = *arrays_handle_;
-  for (; current_array_count_ < array_count_; ++current_array_count_) {
-    auto [elements, elements_kind, length] = DeserializeElements();
-    Handle<JSArray> array;
-
-    if (IsDictionaryElementsKind(elements_kind)) {
-      array = isolate_->factory()->NewJSArray(0);
-
-      Handle<Object> array_length =
-          isolate_->factory()->NewNumberFromUint(length);
-      Handle<Map> map =
-          JSObject::GetElementsTransitionMap(array, DICTIONARY_ELEMENTS);
-      array->set_length(*array_length);
-      array->set_elements(*elements);
-      array->set_map(*map, kReleaseStore);
-    } else {
-      array =
-          factory()->NewJSArrayWithElements(elements, elements_kind, length);
-    }
-    DCHECK(!array->is_null());
-    arrays_.set(static_cast<int>(current_array_count_), *array);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeArrayBuffers() {
-  RCS_SCOPE(isolate_,
-            RuntimeCallCounterId::kWebSnapshotDeserialize_ArrayBuffers);
-  if (!ReadCount(array_buffer_count_)) {
-    Throw("Malformed array buffer table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  array_buffers_handle_ = factory()->NewFixedArray(array_buffer_count_);
-  array_buffers_ = *array_buffers_handle_;
-  for (; current_array_buffer_count_ < array_buffer_count_;
-       ++current_array_buffer_count_) {
-    uint8_t flags;
-    uint32_t byte_length;
-    if (!deserializer_->ReadByte(&flags) ||
-        !deserializer_->ReadUint32(&byte_length) ||
-        byte_length > static_cast<size_t>(deserializer_->end_ -
-                                          deserializer_->position_)) {
-      Throw("Malformed array buffer");
-      return;
-    }
-
-    uint32_t mask = DetachedBitField::kMask | SharedBitField::kMask |
-                    ResizableBitField::kMask;
-    if ((flags | mask) != mask) {
-      Throw("Malformed array buffer");
-      return;
-    }
-    bool was_detached = DetachedBitField::decode(flags);
-    CHECK_IMPLIES(was_detached, (byte_length == 0));
-    SharedFlag shared = SharedBitField::decode(flags) ? SharedFlag::kShared
-                                                      : SharedFlag::kNotShared;
-    CHECK_IMPLIES(was_detached, (shared == SharedFlag::kNotShared));
-    ResizableFlag resizable = ResizableBitField::decode(flags)
-                                  ? ResizableFlag::kResizable
-                                  : ResizableFlag::kNotResizable;
-    uint32_t max_byte_length = byte_length;
-    if (resizable == ResizableFlag::kResizable) {
-      if (!deserializer_->ReadUint32(&max_byte_length)) {
-        Throw("Malformed array buffer");
-        return;
-      }
-      CHECK_GE(max_byte_length, byte_length);
-    }
-
-    Handle<Map> map;
-    if (shared == SharedFlag::kNotShared) {
-      map = handle(
-          isolate_->raw_native_context().array_buffer_fun().initial_map(),
-          isolate_);
-    } else {
-      map = handle(isolate_->raw_native_context()
-                       .shared_array_buffer_fun()
-                       .initial_map(),
-                   isolate_);
-    }
-    Handle<JSArrayBuffer> array_buffer = Handle<JSArrayBuffer>::cast(
-        isolate_->factory()->NewJSObjectFromMap(map, AllocationType::kYoung));
-    array_buffer->Setup(shared, resizable, nullptr, isolate_);
-
-    std::unique_ptr<BackingStore> backing_store;
-    if (was_detached) {
-      array_buffer->set_was_detached(true);
-    } else {
-      if (resizable == ResizableFlag::kNotResizable) {
-        backing_store = BackingStore::Allocate(isolate_, byte_length, shared,
-                                               InitializedFlag::kUninitialized);
-      } else {
-        size_t page_size, initial_pages, max_pages;
-        if (JSArrayBuffer::GetResizableBackingStorePageConfiguration(
-                isolate_, byte_length, max_byte_length, kThrowOnError,
-                &page_size, &initial_pages, &max_pages)
-                .IsNothing()) {
-          Throw("Create array buffer failed");
-          return;
-        }
-        backing_store = BackingStore::TryAllocateAndPartiallyCommitMemory(
-            isolate_, byte_length, max_byte_length, page_size, initial_pages,
-            max_pages, WasmMemoryFlag::kNotWasm, shared);
-      }
-      if (!backing_store) {
-        Throw("Create array buffer failed");
-        return;
-      }
-      array_buffer->Attach(std::move(backing_store));
-    }
-
-    array_buffer->set_max_byte_length(max_byte_length);
-
-    if (byte_length > 0) {
-      memcpy(array_buffer->backing_store(), deserializer_->position_,
-             byte_length);
-    }
-    deserializer_->position_ += byte_length;
-    array_buffers_.set(static_cast<int>(current_array_buffer_count_),
-                       *array_buffer);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeDataViews() {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_DataViews);
-  if (!ReadCount(data_view_count_)) {
-    Throw("Malformed data view table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  data_views_handle_ = factory()->NewFixedArray(data_view_count_);
-  data_views_ = *data_views_handle_;
-  for (; current_data_view_count_ < data_view_count_;
-       ++current_data_view_count_) {
-    Handle<JSArrayBuffer> array_buffer(
-        JSArrayBuffer::cast(std::get<0>(ReadValue())), isolate_);
-    uint32_t byte_offset = 0;
-    uint8_t flags = 0;
-    if (!deserializer_->ReadByte(&flags) ||
-        !deserializer_->ReadUint32(&byte_offset)) {
-      Throw("Malformed data view");
-      return;
-    }
-
-    Handle<Map> map(
-        isolate_->raw_native_context().data_view_fun().initial_map(), isolate_);
-    uint32_t mask = LengthTrackingBitField::kMask;
-    if ((flags | mask) != mask) {
-      Throw("Malformed data view");
-      return;
-    }
-
-    uint32_t byte_length = 0;
-    bool is_length_tracking = LengthTrackingBitField::decode(flags);
-
-    if (is_length_tracking) {
-      CHECK(array_buffer->is_resizable_by_js());
-    } else {
-      if (!deserializer_->ReadUint32(&byte_length)) {
-        Throw("Malformed data view");
-        return;
-      }
-    }
-
-    Handle<JSDataView> data_view =
-        Handle<JSDataView>::cast(factory()->NewJSArrayBufferView(
-            map, factory()->empty_fixed_array(), array_buffer, byte_offset,
-            byte_length));
-
-    {
-      DisallowGarbageCollection no_gc;
-      JSDataView raw_data_view = *data_view;
-      JSArrayBuffer raw_array_buffer = *array_buffer;
-      raw_data_view.set_data_pointer(
-          isolate_, static_cast<uint8_t*>(raw_array_buffer.backing_store()) +
-                        byte_offset);
-      raw_data_view.set_is_length_tracking(is_length_tracking);
-      raw_data_view.set_is_backed_by_rab(!raw_array_buffer.is_shared() &&
-                                         raw_array_buffer.is_resizable_by_js());
-    }
-
-    data_views_.set(static_cast<int>(current_data_view_count_), *data_view);
-  }
-}
-
-bool WebSnapshotDeserializer::ReadCount(uint32_t& count) {
-  return deserializer_->ReadUint32(&count) && count <= kMaxItemCount;
-}
-
-void WebSnapshotDeserializer::DeserializeTypedArrays() {
-  RCS_SCOPE(isolate_,
-            RuntimeCallCounterId::kWebSnapshotDeserialize_TypedArrays);
-  if (!ReadCount(typed_array_count_)) {
-    Throw("Malformed typed array table");
-    return;
-  }
-  static_assert(kMaxItemCount <= FixedArray::kMaxLength);
-  typed_arrays_handle_ = factory()->NewFixedArray(typed_array_count_);
-  typed_arrays_ = *typed_arrays_handle_;
-  for (; current_typed_array_count_ < typed_array_count_;
-       ++current_typed_array_count_) {
-    uint32_t typed_array_type;
-    if (!deserializer_->ReadUint32(&typed_array_type)) {
-      Throw("Malformed array buffer");
-      return;
-    }
-    Handle<JSArrayBuffer> array_buffer(
-        JSArrayBuffer::cast(std::get<0>(ReadValue())), isolate_);
-    uint32_t byte_offset = 0;
-    uint8_t flags = 0;
-    if (!deserializer_->ReadByte(&flags) ||
-        !deserializer_->ReadUint32(&byte_offset)) {
-      Throw("Malformed typed array");
-      return;
-    }
-    size_t element_size = 0;
-    ElementsKind element_kind = UINT8_ELEMENTS;
-    JSTypedArray::ForFixedTypedArray(
-        TypedArrayTypeToExternalArrayType(
-            static_cast<TypedArrayType>(typed_array_type)),
-        &element_size, &element_kind);
-
-    Handle<Map> map(
-        isolate_->raw_native_context().TypedArrayElementsKindToCtorMap(
-            element_kind),
-        isolate_);
-    uint32_t mask = LengthTrackingBitField::kMask;
-    if ((flags | mask) != mask) {
-      Throw("Malformed typed array");
-      return;
-    }
-
-    if (byte_offset % element_size != 0) {
-      Throw("Malformed typed array");
-      return;
-    }
-
-    uint32_t byte_length = 0;
-    size_t length = 0;
-    bool is_length_tracking = LengthTrackingBitField::decode(flags);
-
-    if (is_length_tracking) {
-      CHECK(array_buffer->is_resizable_by_js());
-    } else {
-      if (!deserializer_->ReadUint32(&byte_length)) {
-        Throw("Malformed typed array");
-        return;
-      }
-      if (byte_length % element_size != 0) {
-        Throw("Malformed typed array");
-        return;
-      }
-      length = byte_length / element_size;
-      if (length > JSTypedArray::kMaxLength) {
-        Throw("Too large typed array");
-        return;
-      }
-    }
-
-    bool rabGsab = array_buffer->is_resizable_by_js() &&
-                   (!array_buffer->is_shared() || is_length_tracking);
-    if (rabGsab) {
-      map = handle(
-          isolate_->raw_native_context().TypedArrayElementsKindToRabGsabCtorMap(
-              element_kind),
-          isolate_);
-    }
-
-    Handle<JSTypedArray> typed_array =
-        Handle<JSTypedArray>::cast(factory()->NewJSArrayBufferView(
-            map, factory()->empty_byte_array(), array_buffer, byte_offset,
-            byte_length));
-
-    {
-      DisallowGarbageCollection no_gc;
-      JSTypedArray raw = *typed_array;
-      raw.set_length(length);
-      raw.SetOffHeapDataPtr(isolate_, array_buffer->backing_store(),
-                            byte_offset);
-      raw.set_is_length_tracking(is_length_tracking);
-      raw.set_is_backed_by_rab(array_buffer->is_resizable_by_js() &&
-                               !array_buffer->is_shared());
-    }
-
-    typed_arrays_.set(static_cast<int>(current_typed_array_count_),
-                      *typed_array);
-  }
-}
-
-void WebSnapshotDeserializer::DeserializeExports(bool skip_exports) {
-  RCS_SCOPE(isolate_, RuntimeCallCounterId::kWebSnapshotDeserialize_Exports);
-  uint32_t count;
-  if (!ReadCount(count)) {
-    Throw("Malformed export table");
-    return;
-  }
-
-  if (skip_exports) {
-    // In the skip_exports mode, we read the exports but don't do anything about
-    // them. This is useful for stress testing; otherwise the GlobalDictionary
-    // handling below dominates.
-    for (uint32_t i = 0; i < count; ++i) {
-      Handle<String> export_name(ReadString(InternalizeStrings::kYes),
-                                 isolate_);
-      // No deferred references should occur at this point, since all objects
-      // have been deserialized.
-      Object export_value = std::get<0>(ReadValue());
-#ifdef VERIFY_HEAP
-      if (v8_flags.verify_heap) {
-        export_value.ObjectVerify(isolate_);
-      }
-#endif
-      USE(export_name);
-      USE(export_value);
-    }
-    return;
-  }
-
-  // Pre-reserve the space for the properties we're going to add to the global
-  // object.
-  Handle<JSGlobalObject> global = isolate_->global_object();
-  Handle<GlobalDictionary> dictionary(
-      global->global_dictionary(isolate_, kAcquireLoad), isolate_);
-
-  dictionary = GlobalDictionary::EnsureCapacity(
-      isolate_, dictionary, dictionary->NumberOfElements() + count,
-      AllocationType::kYoung);
-  bool has_exported_values = false;
-
-  // TODO(v8:11525): The code below skips checks, in particular
-  // LookupIterator::UpdateProtectors and
-  // LookupIterator::ExtendingNonExtensible.
-  InternalIndex entry = InternalIndex::NotFound();
-  for (uint32_t i = 0; i < count; ++i) {
-    Handle<String> export_name(ReadString(InternalizeStrings::kYes), isolate_);
-    // No deferred references should occur at this point, since all objects have
-    // been deserialized.
-    Object export_value = std::get<0>(ReadValue());
-#ifdef VERIFY_HEAP
-    if (v8_flags.verify_heap) {
-      export_value.ObjectVerify(isolate_);
-    }
-#endif
-
-    if (export_name->length() == 0 && i == 0) {
-      // Hack: treat the first empty-string-named export value as a return value
-      // from the deserializer.
-      CHECK_EQ(i, 0);
-      return_value_ = handle(export_value, isolate_);
-      continue;
-    }
-
-    DisallowGarbageCollection no_gc;
-    // Check for the correctness of the snapshot (thus far) before producing
-    // something observable. TODO(v8:11525): Strictly speaking, we should
-    // produce observable effects only when we know that the whole snapshot is
-    // correct.
-    if (has_error()) return;
-
-    PropertyDetails property_details =
-        PropertyDetails(PropertyKind::kData, NONE,
-                        PropertyCell::InitialType(isolate_, export_value));
-    Handle<Object> export_value_handle(export_value, isolate_);
-    AllowGarbageCollection allow_gc;
-    Handle<PropertyCell> transition_cell = factory()->NewPropertyCell(
-        export_name, property_details, export_value_handle);
-    dictionary =
-        GlobalDictionary::Add(isolate_, dictionary, export_name,
-                              transition_cell, property_details, &entry);
-    has_exported_values = true;
-  }
-
-  if (!has_exported_values) return;
-
-  global->set_global_dictionary(*dictionary, kReleaseStore);
-  JSObject::InvalidatePrototypeChains(global->map(isolate_));
-}
-
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadValue(
-    Handle<HeapObject> container, uint32_t container_index,
-    InternalizeStrings internalize_strings) {
-  uint8_t value_type;
-  if (!deserializer_->ReadByte(&value_type)) {
-    Throw("Malformed variable");
-    // Return a placeholder "value" so that the "keep on trucking" error
-    // handling won't fail.
-    return std::make_tuple(Smi::zero(), false);
-  }
-  switch (value_type) {
-    case ValueType::FALSE_CONSTANT:
-      return std::make_tuple(roots_.false_value(), false);
-    case ValueType::TRUE_CONSTANT:
-      return std::make_tuple(roots_.true_value(), false);
-    case ValueType::NULL_CONSTANT:
-      return std::make_tuple(roots_.null_value(), false);
-    case ValueType::UNDEFINED_CONSTANT:
-      return std::make_tuple(roots_.undefined_value(), false);
-    case ValueType::NO_ELEMENT_CONSTANT:
-      return std::make_tuple(roots_.the_hole_value(), false);
-    case ValueType::INTEGER:
-      return std::make_tuple(ReadInteger(), false);
-    case ValueType::DOUBLE:
-      return std::make_tuple(ReadNumber(), false);
-    case ValueType::STRING_ID:
-      return std::make_tuple(ReadString(internalize_strings), false);
-    case ValueType::ARRAY_ID:
-      return ReadArray(container, container_index);
-    case ValueType::OBJECT_ID:
-      return ReadObject(container, container_index);
-    case ValueType::FUNCTION_ID:
-      return ReadFunction(container, container_index);
-    case ValueType::CLASS_ID:
-      return ReadClass(container, container_index);
-    case ValueType::REGEXP:
-      return std::make_tuple(ReadRegexp(), false);
-    case ValueType::SYMBOL_ID:
-      return std::make_tuple(ReadSymbol(), false);
-    case ValueType::BIGINT_ID:
-      return std::make_tuple(ReadBigInt(), false);
-    case ValueType::EXTERNAL_ID:
-      return std::make_tuple(ReadExternalReference(), false);
-    case ValueType::BUILTIN_OBJECT_ID:
-      return std::make_tuple(ReadBuiltinObjectReference(), false);
-    case ValueType::IN_PLACE_STRING_ID:
-      return std::make_tuple(ReadInPlaceString(internalize_strings), false);
-    case ValueType::ARRAY_BUFFER_ID:
-      return ReadArrayBuffer(container, container_index);
-    case ValueType::TYPED_ARRAY_ID:
-      return ReadTypedArray(container, container_index);
-    case ValueType::DATA_VIEW_ID:
-      return ReadDataView(container, container_index);
-    default:
-      // TODO(v8:11525): Handle other value types.
-      Throw("Unsupported value type");
-      return std::make_tuple(Smi::zero(), false);
-  }
-}
-
-Object WebSnapshotDeserializer::ReadInteger() {
-  Maybe<int32_t> number = deserializer_->ReadZigZag<int32_t>();
-  if (number.IsNothing()) {
-    Throw("Malformed integer");
-    return Smi::zero();
-  }
-  return *factory()->NewNumberFromInt(number.FromJust());
-}
-
-Object WebSnapshotDeserializer::ReadNumber() {
-  double number;
-  if (!deserializer_->ReadDouble(&number)) {
-    Throw("Malformed double");
-    return Smi::zero();
-  }
-  return *factory()->NewNumber(number);
-}
-
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadArray(
-    Handle<HeapObject> container, uint32_t index) {
-  uint32_t array_id;
-  if (!deserializer_->ReadUint32(&array_id) || array_id >= kMaxItemCount) {
-    Throw("Malformed variable");
-    return std::make_tuple(Smi::zero(), false);
-  }
-  if (array_id < current_array_count_) {
-    return std::make_tuple(arrays_.get(array_id), false);
-  }
-  // The array hasn't been deserialized yet.
-  return std::make_tuple(
-      AddDeferredReference(container, index, ARRAY_ID, array_id), true);
-}
-
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadArrayBuffer(
-    Handle<HeapObject> container, uint32_t index) {
-  uint32_t array_buffer_id;
-  if (!deserializer_->ReadUint32(&array_buffer_id) ||
-      array_buffer_id >= kMaxItemCount) {
-    Throw("Malformed variable");
-    return std::make_tuple(Smi::zero(), false);
-  }
-  if (array_buffer_id < current_array_buffer_count_) {
-    return std::make_tuple(array_buffers_.get(array_buffer_id), false);
-  }
-  // The array buffer hasn't been deserialized yet.
-  return std::make_tuple(
-      AddDeferredReference(container, index, ARRAY_BUFFER_ID, array_buffer_id),
-      true);
-}
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadTypedArray(
-    Handle<HeapObject> container, uint32_t index) {
-  uint32_t typed_array_id;
-  if (!deserializer_->ReadUint32(&typed_array_id) ||
-      typed_array_id >= kMaxItemCount) {
-    Throw("Malformed variable");
-    return std::make_tuple(Smi::zero(), false);
-  }
-  if (typed_array_id < current_typed_array_count_) {
-    return std::make_tuple(typed_arrays_.get(typed_array_id), false);
-  }
-  // The typed array hasn't been deserialized yet.
-  return std::make_tuple(
-      AddDeferredReference(container, index, TYPED_ARRAY_ID, typed_array_id),
-      true);
-}
-
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadDataView(
-    Handle<HeapObject> container, uint32_t index) {
-  uint32_t data_view_id;
-  if (!deserializer_->ReadUint32(&data_view_id) ||
-      data_view_id >= kMaxItemCount) {
-    Throw("Malformed variable");
-    return std::make_tuple(Smi::zero(), false);
-  }
-  if (data_view_id < current_data_view_count_) {
-    return std::make_tuple(data_views_.get(data_view_id), false);
-  }
-  // The data view hasn't been deserialized yet.
-  return std::make_tuple(
-      AddDeferredReference(container, index, DATA_VIEW_ID, data_view_id), true);
-}
-
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadObject(
-    Handle<HeapObject> container, uint32_t index) {
-  uint32_t object_id;
-  if (!deserializer_->ReadUint32(&object_id) || object_id > kMaxItemCount) {
-    Throw("Malformed variable");
-    return std::make_tuple(Smi::zero(), false);
-  }
-  if (object_id < current_object_count_) {
-    return std::make_tuple(objects_.get(object_id), false);
-  }
-  // The object hasn't been deserialized yet.
-  return std::make_tuple(
-      AddDeferredReference(container, index, OBJECT_ID, object_id), true);
-}
-
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadFunction(
-    Handle<HeapObject> container, uint32_t index) {
-  uint32_t function_id;
-  if (!deserializer_->ReadUint32(&function_id)) {
-    Throw("Malformed object property");
-    return std::make_tuple(Smi::zero(), false);
-  }
-  if (function_id < current_function_count_) {
-    return std::make_tuple(functions_.get(function_id), false);
-  }
-  // The function hasn't been deserialized yet.
-  return std::make_tuple(
-      AddDeferredReference(container, index, FUNCTION_ID, function_id), true);
-}
-
-std::tuple<Object, bool> WebSnapshotDeserializer::ReadClass(
-    Handle<HeapObject> container, uint32_t index) {
-  uint32_t class_id;
-  if (!deserializer_->ReadUint32(&class_id) || class_id >= kMaxItemCount) {
-    Throw("Malformed object property");
-    return std::make_tuple(Smi::zero(), false);
-  }
-  if (class_id < current_class_count_) {
-    return std::make_tuple(classes_.get(class_id), false);
-  }
-  // The class hasn't been deserialized yet.
-  return std::make_tuple(
-      AddDeferredReference(container, index, CLASS_ID, class_id), true);
-}
-
-Object WebSnapshotDeserializer::ReadRegexp() {
-  Handle<String> pattern(ReadString(), isolate_);
-  Handle<String> flags_string(ReadString(), isolate_);
-  base::Optional<JSRegExp::Flags> flags =
-      JSRegExp::FlagsFromString(isolate_, flags_string);
-  if (!flags.has_value()) {
-    Throw("Malformed flags in regular expression");
-    return Smi::zero();
-  }
-  MaybeHandle<JSRegExp> maybe_regexp =
-      JSRegExp::New(isolate_, pattern, flags.value());
-  Handle<JSRegExp> regexp;
-  if (!maybe_regexp.ToHandle(&regexp)) {
-    Throw("Malformed RegExp");
-    return Smi::zero();
-  }
-  return *regexp;
-}
-
-Object WebSnapshotDeserializer::ReadExternalReference() {
-  uint32_t ref_id;
-  if (!deserializer_->ReadUint32(&ref_id) ||
-      ref_id >= static_cast<uint32_t>(external_references_.length())) {
-    Throw("Invalid external reference");
-    return Smi::zero();
-  }
-  return external_references_.get(ref_id);
-}
-
-Object WebSnapshotDeserializer::ReadBuiltinObjectReference() {
-  uint32_t ref_id;
-  if (!deserializer_->ReadUint32(&ref_id) ||
-      ref_id >= static_cast<uint32_t>(builtin_objects_.length())) {
-    Throw("Invalid builtin object reference");
-    return Smi::zero();
-  }
-  return builtin_objects_.get(ref_id);
-}
-
-void WebSnapshotDeserializer::ReadFunctionPrototype(
-    Handle<JSFunction> function) {
-  uint32_t object_id;
-
-  if (!deserializer_->ReadUint32(&object_id) || object_id > kMaxItemCount + 1) {
-    Throw("Malformed class / function");
-    return;
-  }
-  if (object_id == 0) {
-    // No prototype.
-    return;
-  }
-  --object_id;
-  if (object_id < current_object_count_) {
-    if (!SetFunctionPrototype(*function,
-                              JSReceiver::cast(objects_.get(object_id)))) {
-      Throw("Can't reuse function prototype");
-      return;
-    }
-  } else {
-    // The object hasn't been deserialized yet.
-    AddDeferredReference(function, 0, OBJECT_ID, object_id);
-  }
-}
-
-bool WebSnapshotDeserializer::SetFunctionPrototype(JSFunction function,
-                                                   JSReceiver prototype) {
-  DisallowGarbageCollection no_gc;
-  // TODO(v8:11525): Enforce the invariant that no two prototypes share a map.
-  Map map = prototype.map();
-  map.set_is_prototype_map(true);
-  if (!map.constructor_or_back_pointer().IsNullOrUndefined(isolate_)) {
-    return false;
-  }
-  map.set_constructor_or_back_pointer(function);
-  function.set_prototype_or_initial_map(prototype, kReleaseStore);
-  return true;
-}
-
-HeapObject WebSnapshotDeserializer::AddDeferredReference(
-    Handle<HeapObject> container, uint32_t index, ValueType target_type,
-    uint32_t target_index) {
-  if (container.is_null()) {
-    const char* message = "Invalid reference";
-    switch (target_type) {
-      case ARRAY_ID:
-        message = "Invalid array reference";
-        break;
-      case OBJECT_ID:
-        message = "Invalid object reference";
-        break;
-      case CLASS_ID:
-        message = "Invalid class reference";
-        break;
-      case FUNCTION_ID:
-        message = "Invalid function reference";
-        break;
-      default:
-        break;
-    }
-    Throw(message);
-    return roots_.undefined_value();
-  }
-  DCHECK(container->IsPropertyArray() || container->IsContext() ||
-         container->IsFixedArray() || container->IsJSFunction() ||
-         container->IsMap());
-  deferred_references_ = ArrayList::Add(
-      isolate_, deferred_references_, container, Smi::FromInt(index),
-      Smi::FromInt(target_type), Smi::FromInt(target_index));
-  // Use HeapObject as placeholder since this might break elements kinds.
-  return roots_.undefined_value();
-}
-
-void WebSnapshotDeserializer::ProcessDeferredReferences() {
-  // Check for error now, since the FixedArrays below might not have been
-  // created if there was an error.
-  if (has_error()) return;
-
-  DisallowGarbageCollection no_gc;
-  ArrayList raw_deferred_references = *deferred_references_;
-
-  // Deferred references is a list of (object, index, target type, target index)
-  // tuples.
-  for (int i = 0; i < raw_deferred_references.Length() - 3; i += 4) {
-    HeapObject container = HeapObject::cast(raw_deferred_references.Get(i));
-    int index = raw_deferred_references.Get(i + 1).ToSmi().value();
-    ValueType target_type = static_cast<ValueType>(
-        raw_deferred_references.Get(i + 2).ToSmi().value());
-    int target_index = raw_deferred_references.Get(i + 3).ToSmi().value();
-    Object target;
-    switch (target_type) {
-      case FUNCTION_ID:
-        if (static_cast<uint32_t>(target_index) >= function_count_) {
-          // Throw can allocate, but it's ok, since we're not using the raw
-          // pointers after that.
-          AllowGarbageCollection allow_gc;
-          Throw("Invalid function reference");
-          return;
-        }
-        target = functions_.get(target_index);
-        break;
-      case CLASS_ID:
-        if (static_cast<uint32_t>(target_index) >= class_count_) {
-          AllowGarbageCollection allow_gc;
-          Throw("Invalid class reference");
-          return;
-        }
-        target = classes_.get(target_index);
-        break;
-      case ARRAY_ID:
-        if (static_cast<uint32_t>(target_index) >= array_count_) {
-          AllowGarbageCollection allow_gc;
-          Throw("Invalid array reference");
-          return;
-        }
-        target = arrays_.get(target_index);
-        break;
-      case ARRAY_BUFFER_ID:
-        if (static_cast<uint32_t>(target_index) >= array_buffer_count_) {
-          AllowGarbageCollection allow_gc;
-          Throw("Invalid array buffer reference");
-          return;
-        }
-        target = array_buffers_.get(target_index);
-        break;
-      case TYPED_ARRAY_ID:
-        if (static_cast<uint32_t>(target_index) >= typed_array_count_) {
-          AllowGarbageCollection allow_gc;
-          Throw("Invalid typed array reference");
-          return;
-        }
-        target = typed_arrays_.get(target_index);
-        break;
-      case DATA_VIEW_ID:
-        if (static_cast<uint32_t>(target_index) >= data_view_count_) {
-          AllowGarbageCollection allow_gc;
-          Throw("Invalid data view reference");
-          return;
-        }
-        target = data_views_.get(target_index);
-        break;
-      case OBJECT_ID:
-        if (static_cast<uint32_t>(target_index) >= object_count_) {
-          AllowGarbageCollection allow_gc;
-          Throw("Invalid object reference");
-          return;
-        }
-        target = objects_.get(target_index);
-        break;
-      default:
-        UNREACHABLE();
-    }
-    InstanceType instance_type = container.map().instance_type();
-    if (InstanceTypeChecker::IsPropertyArray(instance_type)) {
-      PropertyArray::cast(container).set(index, target);
-    } else if (InstanceTypeChecker::IsContext(instance_type)) {
-      Context::cast(container).set(index, target);
-    } else if (InstanceTypeChecker::IsNumberDictionary(instance_type)) {
-      // NumberDictionary::Set may need create HeapNumber for index.
-      AllowGarbageCollection allow_gc;
-      Handle<NumberDictionary> new_container = NumberDictionary::Set(
-          isolate_, handle(NumberDictionary::cast(container), isolate_), index,
-          handle(target, isolate_));
-      // The number dictionary didn't grow, since it was preallocated to be
-      // large enough in DeserializeArrays.
-      DCHECK_EQ(*new_container, container);
-      USE(new_container);
-      // We also need to reload raw_deferred_references because
-      // NumberDictionary::Set may allocate.
-      raw_deferred_references = *deferred_references_;
-    } else if (InstanceTypeChecker::IsFixedArray(instance_type)) {
-      FixedArray::cast(container).set(index, target);
-    } else if (InstanceTypeChecker::IsJSFunction(instance_type)) {
-      // The only deferred reference allowed for a JSFunction is the function
-      // prototype.
-      DCHECK_EQ(index, 0);
-      DCHECK(target.IsJSReceiver());
-      if (!SetFunctionPrototype(JSFunction::cast(container),
-                                JSReceiver::cast(target))) {
-        AllowGarbageCollection allow_gc;
-        Throw("Can't reuse function prototype");
-        return;
-      }
-    } else if (InstanceTypeChecker::IsMap(instance_type)) {
-      // The only deferred reference allowed for a Map is the __proto__.
-      DCHECK_EQ(index, 0);
-      DCHECK(target.IsJSReceiver());
-      AllowGarbageCollection allow_gc;
-      SetPrototype(handle(Map::cast(container), isolate_),
-                   handle(target, isolate_));
-      raw_deferred_references = *deferred_references_;
-    } else {
-      UNREACHABLE();
-    }
-  }
-  deferred_references_->SetLength(0);
-}
-
-}  // namespace internal
-}  // namespace v8
diff --git a/src/web-snapshot/web-snapshot.h b/src/web-snapshot/web-snapshot.h
deleted file mode 100644
index 1de4efa46b..0000000000
--- a/src/web-snapshot/web-snapshot.h
+++ /dev/null
@@ -1,669 +0,0 @@
-// Copyright 2021 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.
-
-#ifndef V8_WEB_SNAPSHOT_WEB_SNAPSHOT_H_
-#define V8_WEB_SNAPSHOT_WEB_SNAPSHOT_H_
-
-#include <queue>
-
-#include "src/handles/handles.h"
-#include "src/objects/bigint.h"
-#include "src/objects/value-serializer.h"
-#include "src/snapshot/serializer.h"  // For ObjectCacheIndexMap
-
-namespace v8 {
-
-class Context;
-class Isolate;
-
-template <typename T>
-class Local;
-
-namespace internal {
-
-class Context;
-class Map;
-class Object;
-class String;
-
-struct WebSnapshotData : public std::enable_shared_from_this<WebSnapshotData> {
-  uint8_t* buffer = nullptr;
-  size_t buffer_size = 0;
-  WebSnapshotData() = default;
-  WebSnapshotData(const WebSnapshotData&) = delete;
-  WebSnapshotData& operator=(const WebSnapshotData&) = delete;
-  ~WebSnapshotData() { free(buffer); }
-};
-
-class WebSnapshotSerializerDeserializer {
- public:
-  inline bool has_error() const { return error_message_ != nullptr; }
-  const char* error_message() const { return error_message_; }
-
-  enum ValueType : uint8_t {
-    FALSE_CONSTANT,
-    TRUE_CONSTANT,
-    NULL_CONSTANT,
-    UNDEFINED_CONSTANT,
-    // It corresponds to the hole value.
-    NO_ELEMENT_CONSTANT,
-    INTEGER,
-    DOUBLE,
-    REGEXP,
-    STRING_ID,
-    ARRAY_ID,
-    OBJECT_ID,
-    FUNCTION_ID,
-    CLASS_ID,
-    SYMBOL_ID,
-    EXTERNAL_ID,
-    BUILTIN_OBJECT_ID,
-    IN_PLACE_STRING_ID,
-    ARRAY_BUFFER_ID,
-    TYPED_ARRAY_ID,
-    DATA_VIEW_ID,
-    BIGINT_ID
-  };
-
-  enum SymbolType : uint8_t {
-    kNonGlobalNoDesription = 0,
-    kNonGlobal = 1,
-    kGlobal = 2
-  };
-
-  enum ElementsType : uint8_t { kDense = 0, kSparse = 1 };
-
-  enum TypedArrayType : uint8_t {
-    kInt8Array,
-    kUint8Array,
-    kUint8ClampedArray,
-    kInt16Array,
-    kUint16Array,
-    kInt32Array,
-    kUint32Array,
-    kFloat32Array,
-    kFloat64Array,
-    kBigInt64Array,
-    kBigUint64Array,
-  };
-
-  static inline ExternalArrayType TypedArrayTypeToExternalArrayType(
-      TypedArrayType type);
-  static inline TypedArrayType ExternalArrayTypeToTypedArrayType(
-      ExternalArrayType type);
-
-  static constexpr uint8_t kMagicNumber[4] = {'+', '+', '+', ';'};
-
-  enum ContextType : uint8_t { FUNCTION, BLOCK };
-
-  enum PropertyAttributesType : uint8_t { DEFAULT, CUSTOM };
-
-  uint8_t FunctionKindToFunctionFlags(FunctionKind kind);
-  FunctionKind FunctionFlagsToFunctionKind(uint8_t flags);
-  bool IsFunctionOrMethod(uint8_t flags);
-  bool IsConstructor(uint8_t flags);
-
-  uint8_t GetDefaultAttributeFlags();
-  uint8_t AttributesToFlags(PropertyDetails details);
-  PropertyAttributes FlagsToAttributes(uint8_t flags);
-
-  uint8_t ArrayBufferViewKindToFlags(
-      Handle<JSArrayBufferView> array_buffer_view);
-
-  uint8_t ArrayBufferKindToFlags(Handle<JSArrayBuffer> array_buffer);
-
-  uint32_t BigIntSignAndLengthToFlags(Handle<BigInt> bigint);
-  uint32_t BigIntFlagsToBitField(uint32_t flags);
-  // The maximum count of items for each value type (strings, objects etc.)
-  static constexpr uint32_t kMaxItemCount =
-      static_cast<uint32_t>(FixedArray::kMaxLength - 1);
-  // This ensures indices and lengths can be converted between uint32_t and int
-  // without problems:
-  static_assert(kMaxItemCount <
-                static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
-
- protected:
-  explicit WebSnapshotSerializerDeserializer(Isolate* isolate)
-      : isolate_(isolate) {}
-  // Not virtual, on purpose (because it doesn't need to be).
-  void Throw(const char* message);
-
-  void IterateBuiltinObjects(
-      std::function<void(Handle<String>, Handle<HeapObject>)> func);
-
-  static constexpr int kBuiltinObjectCount = 12;
-
-  inline Factory* factory() const { return isolate_->factory(); }
-
-  Isolate* isolate_;
-  const char* error_message_ = nullptr;
-
-  // Encode JSArrayBufferFlags, including was_detached, is_shared, is_resizable.
-  // DetachedBitField indicates whether the ArrayBuffer was detached.
-  using DetachedBitField = base::BitField<bool, 0, 1, uint8_t>;
-  // SharedBitField indicates whether the ArrayBuffer is SharedArrayBuffer.
-  using SharedBitField = DetachedBitField::Next<bool, 1>;
-  // ResizableBitField indicates whether the ArrayBuffer is ResizableArrayBuffer
-  // or GrowableSharedArrayBuffer.
-  using ResizableBitField = SharedBitField::Next<bool, 1>;
-
-  // Encode JSArrayBufferViewFlags, including is_length_tracking, see
-  // https://github.com/tc39/proposal-resizablearraybuffer.
-  // LengthTrackingBitField indicates whether the ArrayBufferView should track
-  // the length of the backing buffer, that is whether the ArrayBufferView is
-  // constructed without the specified length argument.
-  using LengthTrackingBitField = base::BitField<bool, 0, 1, uint8_t>;
-
-  // Encode BigInt's sign and digits length.
-  using BigIntSignBitField = base::BitField<bool, 0, 1>;
-  using BigIntLengthBitField =
-      BigIntSignBitField::Next<int, BigInt::kLengthFieldBits>;
-  static_assert(BigIntLengthBitField::kSize == BigInt::LengthBits::kSize);
-
- private:
-  WebSnapshotSerializerDeserializer(const WebSnapshotSerializerDeserializer&) =
-      delete;
-  WebSnapshotSerializerDeserializer& operator=(
-      const WebSnapshotSerializerDeserializer&) = delete;
-
-  using AsyncFunctionBitField = base::BitField<bool, 0, 1, uint8_t>;
-  using GeneratorFunctionBitField = AsyncFunctionBitField::Next<bool, 1>;
-  using ArrowFunctionBitField = GeneratorFunctionBitField::Next<bool, 1>;
-  using MethodBitField = ArrowFunctionBitField::Next<bool, 1>;
-  using StaticBitField = MethodBitField::Next<bool, 1>;
-  using ClassConstructorBitField = StaticBitField::Next<bool, 1>;
-  using DefaultConstructorBitField = ClassConstructorBitField::Next<bool, 1>;
-  using DerivedConstructorBitField = DefaultConstructorBitField::Next<bool, 1>;
-
-  using ReadOnlyBitField = base::BitField<bool, 0, 1, uint8_t>;
-  using ConfigurableBitField = ReadOnlyBitField::Next<bool, 1>;
-  using EnumerableBitField = ConfigurableBitField::Next<bool, 1>;
-};
-
-class V8_EXPORT WebSnapshotSerializer
-    : public WebSnapshotSerializerDeserializer {
- public:
-  explicit WebSnapshotSerializer(v8::Isolate* isolate);
-  explicit WebSnapshotSerializer(Isolate* isolate);
-
-  ~WebSnapshotSerializer();
-
-  bool TakeSnapshot(v8::Local<v8::Context> context,
-                    v8::Local<v8::PrimitiveArray> exports,
-                    WebSnapshotData& data_out);
-  bool TakeSnapshot(Handle<Object> object, MaybeHandle<FixedArray> block_list,
-                    WebSnapshotData& data_out);
-
-  // For inspecting the state after taking a snapshot.
-  uint32_t string_count() const {
-    return static_cast<uint32_t>(string_ids_.size());
-  }
-
-  uint32_t symbol_count() const {
-    return static_cast<uint32_t>(symbol_ids_.size());
-  }
-
-  uint32_t bigint_count() const {
-    return static_cast<uint32_t>(bigint_ids_.size());
-  }
-
-  uint32_t map_count() const { return static_cast<uint32_t>(map_ids_.size()); }
-
-  uint32_t builtin_object_count() const {
-    return static_cast<uint32_t>(builtin_object_ids_.size());
-  }
-
-  uint32_t context_count() const {
-    return static_cast<uint32_t>(context_ids_.size());
-  }
-
-  uint32_t function_count() const {
-    return static_cast<uint32_t>(function_ids_.size());
-  }
-
-  uint32_t class_count() const {
-    return static_cast<uint32_t>(class_ids_.size());
-  }
-
-  uint32_t array_count() const {
-    return static_cast<uint32_t>(array_ids_.size());
-  }
-
-  uint32_t array_buffer_count() const {
-    return static_cast<uint32_t>(array_buffer_ids_.size());
-  }
-
-  uint32_t typed_array_count() const {
-    return static_cast<uint32_t>(typed_array_ids_.size());
-  }
-
-  uint32_t data_view_count() const {
-    return static_cast<uint32_t>(data_view_ids_.size());
-  }
-
-  uint32_t object_count() const {
-    return static_cast<uint32_t>(object_ids_.size());
-  }
-
-  uint32_t external_object_count() const {
-    return static_cast<uint32_t>(external_object_ids_.size());
-  }
-
-  Handle<FixedArray> GetExternals();
-
- private:
-  WebSnapshotSerializer(const WebSnapshotSerializer&) = delete;
-  WebSnapshotSerializer& operator=(const WebSnapshotSerializer&) = delete;
-
-  enum class AllowInPlace {
-    No,   // This reference cannot be replace with an in-place item.
-    Yes,  // This reference can be replaced with an in-place item.
-  };
-
-  void SerializePendingItems();
-  void WriteSnapshot(uint8_t*& buffer, size_t& buffer_size);
-  void WriteObjects(ValueSerializer& destination, size_t count,
-                    ValueSerializer& source, const char* name);
-
-  // Returns true if the object was already in the map, false if it was added.
-  bool InsertIntoIndexMap(ObjectCacheIndexMap& map, HeapObject heap_object,
-                          uint32_t& id);
-
-  void ShallowDiscoverExternals(FixedArray externals);
-  void ShallowDiscoverBuiltinObjects(v8::Local<v8::Context> context);
-  void Discover(Handle<HeapObject> object);
-  void DiscoverString(Handle<String> string,
-                      AllowInPlace can_be_in_place = AllowInPlace::No);
-  void DiscoverSymbol(Handle<Symbol> symbol);
-  void DiscoverBigInt(Handle<BigInt> bigint);
-  void DiscoverMap(Handle<Map> map, bool allow_property_in_descriptor = false);
-  void DiscoverPropertyKey(Handle<Name> key);
-  void DiscoverMapForFunction(Handle<JSFunction> function);
-  void DiscoverFunction(Handle<JSFunction> function);
-  void DiscoverClass(Handle<JSFunction> function);
-  void DiscoverContextAndPrototype(Handle<JSFunction> function);
-  void DiscoverContext(Handle<Context> context);
-  void DiscoverArray(Handle<JSArray> array);
-  void DiscoverTypedArray(Handle<JSTypedArray> typed_array);
-  void DiscoverDataView(Handle<JSDataView> data_view);
-  void DiscoverArrayBuffer(Handle<JSArrayBuffer> array_buffer);
-  void DiscoverElements(Handle<JSObject> object);
-  void DiscoverObject(Handle<JSObject> object);
-  bool DiscoverIfBuiltinObject(Handle<HeapObject> object);
-  void DiscoverSource(Handle<JSFunction> function);
-  template <typename T>
-  void DiscoverObjectPropertiesWithDictionaryMap(T dict);
-  bool ShouldBeSerialized(Handle<Name> key);
-  void ConstructSource();
-
-  void SerializeFunctionInfo(Handle<JSFunction> function,
-                             ValueSerializer& serializer);
-  void SerializeFunctionProperties(Handle<JSFunction> function,
-                                   ValueSerializer& serializer);
-  void SerializeString(Handle<String> string, ValueSerializer& serializer);
-  void SerializeSymbol(Handle<Symbol> symbol);
-  void SerializeBigInt(Handle<BigInt> bigint);
-  void SerializeMap(Handle<Map> map);
-  void SerializeBuiltinObject(uint32_t name_id);
-  void SerializeObjectPrototype(Handle<Map> map, ValueSerializer& serializer);
-
-  template <typename T>
-  void SerializeObjectPropertiesWithDictionaryMap(T dict);
-  void SerializeFunction(Handle<JSFunction> function);
-  void SerializeClass(Handle<JSFunction> function);
-  void SerializeContext(Handle<Context> context, uint32_t id);
-  void SerializeArray(Handle<JSArray> array);
-  void SerializeElements(Handle<JSObject> object, ValueSerializer& serializer,
-                         Maybe<uint32_t> length);
-  void SerializeObject(Handle<JSObject> object);
-  void SerializeArrayBufferView(Handle<JSArrayBufferView> array_buffer_view,
-                                ValueSerializer& serializer);
-  void SerializeArrayBuffer(Handle<JSArrayBuffer> array_buffer);
-  void SerializeTypedArray(Handle<JSTypedArray> typed_array);
-  void SerializeDataView(Handle<JSDataView> data_view);
-
-  void SerializeExport(Handle<Object> object, Handle<String> export_name);
-  void WriteValue(Handle<Object> object, ValueSerializer& serializer);
-  void WriteStringMaybeInPlace(Handle<String> string,
-                               ValueSerializer& serializer);
-  void WriteStringId(Handle<String> string, ValueSerializer& serializer);
-
-  uint32_t GetStringId(Handle<String> string, bool& in_place);
-  uint32_t GetSymbolId(Symbol symbol);
-  uint32_t GetBigIntId(BigInt bigint);
-  uint32_t GetMapId(Map map);
-  uint32_t GetFunctionId(JSFunction function);
-  uint32_t GetClassId(JSFunction function);
-  uint32_t GetContextId(Context context);
-  uint32_t GetArrayId(JSArray array);
-  uint32_t GetTypedArrayId(JSTypedArray typed_array);
-  uint32_t GetDataViewId(JSDataView data_view);
-  uint32_t GetArrayBufferId(JSArrayBuffer array_buffer);
-  uint32_t GetObjectId(JSObject object);
-  bool GetExternalId(HeapObject object, uint32_t* id = nullptr);
-  // Returns index into builtin_object_name_strings_.
-  bool GetBuiltinObjectNameIndex(HeapObject object, uint32_t& index);
-  bool GetBuiltinObjectId(HeapObject object, uint32_t& id);
-
-  ValueSerializer string_serializer_;
-  ValueSerializer symbol_serializer_;
-  ValueSerializer bigint_serializer_;
-  ValueSerializer map_serializer_;
-  ValueSerializer builtin_object_serializer_;
-  ValueSerializer context_serializer_;
-  ValueSerializer function_serializer_;
-  ValueSerializer class_serializer_;
-  ValueSerializer array_serializer_;
-  ValueSerializer typed_array_serializer_;
-  ValueSerializer array_buffer_serializer_;
-  ValueSerializer data_view_serializer_;
-  ValueSerializer object_serializer_;
-  ValueSerializer export_serializer_;
-
-  // These are needed for being able to serialize items in order.
-  Handle<ArrayList> strings_;
-  Handle<ArrayList> symbols_;
-  Handle<ArrayList> bigints_;
-  Handle<ArrayList> maps_;
-  Handle<ArrayList> contexts_;
-  Handle<ArrayList> functions_;
-  Handle<ArrayList> classes_;
-  Handle<ArrayList> arrays_;
-  Handle<ArrayList> typed_arrays_;
-  Handle<ArrayList> array_buffers_;
-  Handle<ArrayList> data_views_;
-  Handle<ArrayList> objects_;
-
-  // IndexMap to keep track of explicitly blocked external objects and
-  // non-serializable/not-supported objects (e.g. API Objects).
-  ObjectCacheIndexMap external_object_ids_;
-
-  // ObjectCacheIndexMap implements fast lookup item -> id. Some items (context,
-  // function, class, array, object) can point to other items and we serialize
-  // them in the reverse order. This ensures that the items this item points to
-  // have a lower ID and will be deserialized first.
-  ObjectCacheIndexMap string_ids_;
-  ObjectCacheIndexMap symbol_ids_;
-  ObjectCacheIndexMap bigint_ids_;
-  ObjectCacheIndexMap map_ids_;
-  ObjectCacheIndexMap context_ids_;
-  ObjectCacheIndexMap function_ids_;
-  ObjectCacheIndexMap class_ids_;
-  ObjectCacheIndexMap array_ids_;
-  ObjectCacheIndexMap typed_array_ids_;
-  ObjectCacheIndexMap array_buffer_ids_;
-  ObjectCacheIndexMap data_view_ids_;
-  ObjectCacheIndexMap object_ids_;
-  uint32_t export_count_ = 0;
-
-  // For handling references to builtin objects:
-  // --------------------------------
-  // String objects for the names of all known builtins.
-  Handle<FixedArray> builtin_object_name_strings_;
-
-  // Map object -> index in builtin_name_strings_ for all known builtins.
-  ObjectCacheIndexMap builtin_object_to_name_;
-
-  // Map object -> index in builtins_. Includes only builtins which will be
-  // incluced in the snapshot.
-  ObjectCacheIndexMap builtin_object_ids_;
-
-  // For creating the Builtin wrappers in the snapshot. Includes only builtins
-  // which will be incluced in the snapshot. Each element is the id of the
-  // builtin name string in the snapshot.
-  std::vector<uint32_t> builtin_objects_;
-  // --------------------------------
-
-  std::queue<Handle<HeapObject>> discovery_queue_;
-
-  // For keeping track of which strings have exactly one reference. Strings are
-  // inserted here when the first reference is discovered, and never removed.
-  // Strings which have more than one reference get an ID and are inserted to
-  // strings_.
-  IdentityMap<int, base::DefaultAllocationPolicy> all_strings_;
-
-  // For constructing the minimal, "compacted", source string to cover all
-  // function bodies.
-  // --------------------------------
-  // Script id -> offset of the script source code in full_source_.
-  std::map<int, int> script_offsets_;
-  Handle<String> full_source_;
-  uint32_t source_id_;
-  // Ordered set of (start, end) pairs of all functions we've discovered.
-  std::set<std::pair<int, int>> source_intervals_;
-  // Maps function positions in the real source code into the function positions
-  // in the constructed source code (which we'll include in the web snapshot).
-  std::unordered_map<int, int> source_offset_to_compacted_source_offset_;
-  // --------------------------------
-};
-
-class V8_EXPORT WebSnapshotDeserializer
-    : public WebSnapshotSerializerDeserializer {
- public:
-  WebSnapshotDeserializer(v8::Isolate* v8_isolate, const uint8_t* data,
-                          size_t buffer_size);
-  WebSnapshotDeserializer(Isolate* isolate, Handle<Script> snapshot_as_script);
-  ~WebSnapshotDeserializer();
-  bool Deserialize(MaybeHandle<FixedArray> external_references = {},
-                   bool skip_exports = false);
-
-  // For inspecting the state after deserializing a snapshot.
-  uint32_t string_count() const { return string_count_; }
-  uint32_t symbol_count() const { return symbol_count_; }
-  uint32_t map_count() const { return map_count_; }
-  uint32_t builtin_object_count() const { return builtin_object_count_; }
-  uint32_t context_count() const { return context_count_; }
-  uint32_t function_count() const { return function_count_; }
-  uint32_t class_count() const { return class_count_; }
-  uint32_t array_count() const { return array_count_; }
-  uint32_t object_count() const { return object_count_; }
-
-  static void UpdatePointersCallback(v8::Isolate* isolate, v8::GCType type,
-                                     v8::GCCallbackFlags flags,
-                                     void* deserializer) {
-    reinterpret_cast<WebSnapshotDeserializer*>(deserializer)->UpdatePointers();
-  }
-
-  void UpdatePointers();
-
-  MaybeHandle<Object> value() const { return return_value_; }
-
- private:
-  enum class InternalizeStrings {
-    kNo,
-    kYes,
-  };
-
-  WebSnapshotDeserializer(Isolate* isolate, Handle<Object> script_name,
-                          base::Vector<const uint8_t> buffer);
-  // Return value: {data, length, data_owned}.
-  std::tuple<const uint8_t*, uint32_t, bool> ExtractScriptBuffer(
-      Isolate* isolate, Handle<Script> snapshot_as_script);
-  bool DeserializeSnapshot(bool skip_exports);
-  void CollectBuiltinObjects();
-  bool DeserializeScript();
-
-  WebSnapshotDeserializer(const WebSnapshotDeserializer&) = delete;
-  WebSnapshotDeserializer& operator=(const WebSnapshotDeserializer&) = delete;
-
-  void DeserializeStrings();
-  void DeserializeSymbols();
-  void DeserializeBigInts();
-  void DeserializeMaps();
-  void DeserializeBuiltinObjects();
-  void DeserializeContexts();
-  Handle<ScopeInfo> CreateScopeInfo(uint32_t variable_count, bool has_parent,
-                                    ContextType context_type,
-                                    bool has_inlined_local_names);
-  Handle<JSFunction> CreateJSFunction(int index, uint32_t start,
-                                      uint32_t length, uint32_t parameter_count,
-                                      uint8_t flags, uint32_t context_id);
-  void DeserializeFunctionData(uint32_t count, uint32_t current_count);
-  void DeserializeFunctions();
-  void DeserializeClasses();
-  void DeserializeArrays();
-  void DeserializeArrayBuffers();
-  void DeserializeTypedArrays();
-  void DeserializeDataViews();
-  void DeserializeObjects();
-  void DeserializeObjectElements(Handle<JSObject> object,
-                                 bool map_from_snapshot);
-  void DeserializeExports(bool skip_exports);
-  void DeserializeObjectPrototype(Handle<Map> map);
-  Handle<Map> DeserializeObjectPrototypeAndCreateEmptyMap();
-  void DeserializeObjectPrototypeForFunction(Handle<JSFunction> function);
-  void SetPrototype(Handle<Map> map, Handle<Object> prototype);
-  void DeserializeFunctionProperties(Handle<JSFunction> function);
-  bool ReadCount(uint32_t& count);
-
-  bool IsInitialFunctionPrototype(Object prototype);
-
-  template <typename T>
-  void DeserializeObjectPropertiesWithDictionaryMap(
-      T dict, uint32_t property_count, bool has_custom_property_attributes);
-
-  Handle<PropertyArray> DeserializePropertyArray(
-      Handle<DescriptorArray> descriptors, int no_properties);
-
-  // Return value: (object, was_deferred)
-  std::tuple<Object, bool> ReadValue(
-      Handle<HeapObject> object_for_deferred_reference = Handle<HeapObject>(),
-      uint32_t index_for_deferred_reference = 0,
-      InternalizeStrings internalize_strings = InternalizeStrings::kNo);
-
-  Object ReadInteger();
-  Object ReadNumber();
-  String ReadString(
-      InternalizeStrings internalize_strings = InternalizeStrings::kNo);
-  String ReadInPlaceString(
-      InternalizeStrings internalize_strings = InternalizeStrings::kNo);
-  Object ReadSymbol();
-  Object ReadBigInt();
-  std::tuple<Object, bool> ReadArray(Handle<HeapObject> container,
-                                     uint32_t container_index);
-  std::tuple<Object, bool> ReadArrayBuffer(Handle<HeapObject> container,
-                                           uint32_t container_index);
-  std::tuple<Object, bool> ReadTypedArray(Handle<HeapObject> container,
-                                          uint32_t container_index);
-  std::tuple<Object, bool> ReadDataView(Handle<HeapObject> container,
-                                        uint32_t container_index);
-  std::tuple<Object, bool> ReadObject(Handle<HeapObject> container,
-                                      uint32_t container_index);
-  std::tuple<Object, bool> ReadFunction(Handle<HeapObject> container,
-                                        uint32_t container_index);
-  std::tuple<Object, bool> ReadClass(Handle<HeapObject> container,
-                                     uint32_t container_index);
-  Object ReadRegexp();
-  Object ReadBuiltinObjectReference();
-  Object ReadExternalReference();
-  bool ReadMapType();
-  std::tuple<Handle<FixedArrayBase>, ElementsKind, uint32_t>
-  DeserializeElements();
-  ElementsType ReadElementsType();
-  std::tuple<Handle<FixedArrayBase>, ElementsKind, uint32_t> ReadDenseElements(
-      uint32_t length);
-  std::tuple<Handle<FixedArrayBase>, ElementsKind, uint32_t> ReadSparseElements(
-      uint32_t length);
-
-  void ReadFunctionPrototype(Handle<JSFunction> function);
-  bool SetFunctionPrototype(JSFunction function, JSReceiver prototype);
-
-  HeapObject AddDeferredReference(Handle<HeapObject> container, uint32_t index,
-                                  ValueType target_type,
-                                  uint32_t target_object_index);
-  void ProcessDeferredReferences();
-  // Not virtual, on purpose (because it doesn't need to be).
-  void Throw(const char* message);
-  void VerifyObjects();
-
-  Handle<FixedArray> strings_handle_;
-  FixedArray strings_;
-
-  Handle<FixedArray> symbols_handle_;
-  FixedArray symbols_;
-
-  Handle<FixedArray> bigints_handle_;
-  FixedArray bigints_;
-
-  Handle<FixedArray> builtin_objects_handle_;
-  FixedArray builtin_objects_;
-
-  Handle<FixedArray> maps_handle_;
-  FixedArray maps_;
-  std::map<int, Handle<Map>> deserialized_function_maps_;
-
-  Handle<FixedArray> contexts_handle_;
-  FixedArray contexts_;
-
-  Handle<FixedArray> functions_handle_;
-  FixedArray functions_;
-
-  Handle<FixedArray> classes_handle_;
-  FixedArray classes_;
-
-  Handle<FixedArray> arrays_handle_;
-  FixedArray arrays_;
-
-  Handle<FixedArray> array_buffers_handle_;
-  FixedArray array_buffers_;
-
-  Handle<FixedArray> typed_arrays_handle_;
-  FixedArray typed_arrays_;
-
-  Handle<FixedArray> data_views_handle_;
-  FixedArray data_views_;
-
-  Handle<FixedArray> objects_handle_;
-  FixedArray objects_;
-
-  Handle<FixedArray> external_references_handle_;
-  FixedArray external_references_;
-
-  // Map: String -> builtin object.
-  Handle<ObjectHashTable> builtin_object_name_to_object_;
-
-  Handle<ArrayList> deferred_references_;
-
-  Handle<WeakFixedArray> shared_function_infos_handle_;
-  WeakFixedArray shared_function_infos_;
-
-  Handle<ObjectHashTable> shared_function_info_table_;
-
-  Handle<Script> script_;
-  Handle<Object> script_name_;
-
-  Handle<Object> return_value_;
-
-  uint32_t string_count_ = 0;
-  uint32_t symbol_count_ = 0;
-  uint32_t bigint_count_ = 0;
-  uint32_t map_count_ = 0;
-  uint32_t builtin_object_count_ = 0;
-  uint32_t context_count_ = 0;
-  uint32_t function_count_ = 0;
-  uint32_t current_function_count_ = 0;
-  uint32_t class_count_ = 0;
-  uint32_t current_class_count_ = 0;
-  uint32_t array_count_ = 0;
-  uint32_t current_array_count_ = 0;
-  uint32_t array_buffer_count_ = 0;
-  uint32_t current_array_buffer_count_ = 0;
-  uint32_t typed_array_count_ = 0;
-  uint32_t current_typed_array_count_ = 0;
-  uint32_t data_view_count_ = 0;
-  uint32_t current_data_view_count_ = 0;
-  uint32_t object_count_ = 0;
-  uint32_t current_object_count_ = 0;
-
-  std::unique_ptr<ValueDeserializer> deserializer_;
-  std::unique_ptr<const uint8_t[]> owned_data_;
-  ReadOnlyRoots roots_;
-
-  bool deserialized_ = false;
-};
-
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_WEB_SNAPSHOT_WEB_SNAPSHOT_H_
diff --git a/test/mjsunit/mjsunit.status b/test/mjsunit/mjsunit.status
index dba1a70ab1..e889ebdc09 100644
--- a/test/mjsunit/mjsunit.status
+++ b/test/mjsunit/mjsunit.status
@@ -39,7 +39,6 @@
   'wasm/wasm-module-builder': [SKIP],
   'compiler/fast-api-helpers': [SKIP],
   'typedarray-helpers': [SKIP],
-  'web-snapshot/web-snapshot-helpers': [SKIP],
 
   # All tests in the bug directory are expected to fail.
   'bugs/*': [FAIL],
diff --git a/test/mjsunit/web-snapshot/web-snapshot-array-buffer.js b/test/mjsunit/web-snapshot/web-snapshot-array-buffer.js
deleted file mode 100644
index ddf37d58c8..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-array-buffer.js
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --harmony-rab-gsab --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-
-(function TestSharedArrayBuffer() {
-  function createObjects() {
-    const growableArrayBuffer = new SharedArrayBuffer(5, { maxByteLength: 10 });
-    globalThis.growableArrayBuffer = growableArrayBuffer;
-    const array1 = new Uint8Array(growableArrayBuffer);
-    for (let i = 0; i < 5; i++) {
-      array1[i] = i;
-    }
-
-    const arrayBuffer = new SharedArrayBuffer(5);
-    globalThis.arrayBuffer = arrayBuffer;
-    const array2 = new Uint8Array(arrayBuffer);
-    for (let i = 0; i < 5; i++) {
-      array2[i] = i;
-    }
-  }
-  const { growableArrayBuffer, arrayBuffer } = takeAndUseWebSnapshot(createObjects, ['growableArrayBuffer', 'arrayBuffer']);
-  assertEquals(5, growableArrayBuffer.byteLength);
-  assertEquals(10, growableArrayBuffer.maxByteLength);
-  assertTrue(growableArrayBuffer.growable);
-  const array1 = new Uint8Array(growableArrayBuffer);
-  for (let i = 0; i < 5; i++) {
-    assertEquals(array1[i], i);
-  }
-
-  assertEquals(arrayBuffer.byteLength, 5);
-  assertEquals(arrayBuffer.maxByteLength, 5);
-  assertFalse(arrayBuffer.growable, false);
-  const array2 = new Uint8Array(arrayBuffer);
-  for (let i = 0; i < 5; i++) {
-    assertEquals(array2[i], i);
-  }
-})();
-
-(function TestArrayBuffer() {
-  function createObjects() {
-    const resizableArrayBuffer = new ArrayBuffer(5, {maxByteLength: 10});
-    globalThis.resizableArrayBuffer = resizableArrayBuffer;
-    const array1 = new Uint8Array(resizableArrayBuffer);
-    for (let i = 0; i < 5; i++) {
-      array1[i] = i;
-    }
-
-    const arrayBuffer = new ArrayBuffer(5);
-    globalThis.arrayBuffer = arrayBuffer;
-    const array2 = new Uint8Array(arrayBuffer);
-    for (let i = 0; i < 5; i++) {
-      array2[i] = i;
-    }
-
-    const detachedArrayBuffer = new ArrayBuffer(5);
-    %ArrayBufferDetach(detachedArrayBuffer);
-    globalThis.detachedArrayBuffer = detachedArrayBuffer;
-  }
-  const { resizableArrayBuffer, arrayBuffer, detachedArrayBuffer } = takeAndUseWebSnapshot(createObjects, ['resizableArrayBuffer', 'arrayBuffer', 'detachedArrayBuffer']);
-  assertEquals(5, resizableArrayBuffer.byteLength);
-  assertEquals(10, resizableArrayBuffer.maxByteLength);
-  assertTrue(resizableArrayBuffer.resizable)
-  const array1 = new Uint8Array(resizableArrayBuffer);
-  for (let i = 0; i < 5; i++) {
-    assertEquals(array1[i], i);
-  }
-
-  assertEquals(5, arrayBuffer.byteLength);
-  assertEquals(5, arrayBuffer.maxByteLength);
-  assertFalse(arrayBuffer.resizable)
-  const array2 = new Uint8Array(arrayBuffer);
-  for (let i = 0; i < 5; i++) {
-    assertEquals(array2[i], i);
-  }
-
-  assertEquals(0, detachedArrayBuffer.byteLength);
-  assertEquals(0, detachedArrayBuffer.maxByteLength);
-})()
diff --git a/test/mjsunit/web-snapshot/web-snapshot-array.js b/test/mjsunit/web-snapshot/web-snapshot-array.js
deleted file mode 100644
index d1d021ab8a..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-array.js
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestArray() {
-  function createObjects() {
-    globalThis.foo = {
-      array: [5, 6, 7]
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([5, 6, 7], foo.array);
-})();
-
-(function TestPackedDoubleElementsArray() {
-  function createObjects() {
-    globalThis.foo = [1.2, 2.3];
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1.2, 2.3], foo);
-})();
-
-(function TestArrayContainingDoubleAndSmi() {
-  function createObjects() {
-    globalThis.foo = [1.2, 1];
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1.2, 1], foo);
-})();
-
-(function TestArrayContainingDoubleAndObject() {
-  function createObjects() {
-    globalThis.foo = [1.2, {'key': 'value'}];
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1.2, {'key': 'value'}], foo);
-})();
-
-(function TestEmptyArray() {
-  function createObjects() {
-    globalThis.foo = {
-      array: []
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(0, foo.array.length);
-  assertEquals([], foo.array);
-})();
-
-(function TestArrayContainingArray() {
-  function createObjects() {
-    globalThis.foo = {
-      array: [[2, 3], [4, 5]]
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([[2, 3], [4, 5]], foo.array);
-})();
-
-(function TestArrayContainingObject() {
-  function createObjects() {
-    globalThis.foo = {
-      array: [{ a: 1 }, { b: 2 }]
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(1, foo.array[0].a);
-  assertEquals(2, foo.array[1].b);
-})();
-
-(function TestArrayContainingFunction() {
-  function createObjects() {
-    globalThis.foo = {
-      array: [function () { return 5; }]
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(5, foo.array[0]());
-})();
-
-(function TestInPlaceStringsInArray() {
-  function createObjects() {
-    globalThis.foo = {
-      array: ['foo', 'bar', 'baz']
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  // We cannot test that the strings are really in-place; that's covered by
-  // cctests.
-  assertEquals('foobarbaz', foo.array.join(''));
-})();
-
-(function TestRepeatedInPlaceStringsInArray() {
-  function createObjects() {
-    globalThis.foo = {
-      array: ['foo', 'bar', 'foo']
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  // We cannot test that the strings are really in-place; that's covered by
-  // cctests.
-  assertEquals('foobarfoo', foo.array.join(''));
-})();
-
-(function TestArrayWithSlackElements() {
-  function createObjects() {
-    globalThis.foo = {
-      array: [],
-      doubleArray: [],
-      objectArray: []
-    };
-    for (let i = 0; i < 100; ++i) {
-      globalThis.foo.array.push(i);
-      globalThis.foo.doubleArray.push(i + 0.1);
-      globalThis.foo.objectArray.push({});
-    }
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(100, foo.array.length);
-  assertEquals(100, foo.doubleArray.length);
-  assertEquals(100, foo.objectArray.length);
-  for (let i = 0; i < 100; ++i){
-    assertEquals(i, foo.array[i]);
-    assertEquals(i + 0.1, foo.doubleArray[i]);
-    assertEquals({}, foo.objectArray[i]);
-  }
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-base.js b/test/mjsunit/web-snapshot/web-snapshot-base.js
deleted file mode 100644
index 1a82b8f134..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-base.js
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright 2021 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestMinimal() {
-  function createObjects() {
-    globalThis.foo = {
-      str: 'hello',
-      n: 42,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('hello', foo.str);
-  assertEquals(42, foo.n);
-})();
-
-(function TestEmptyObject() {
-  function createObjects() {
-    globalThis.foo = {};
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([], Object.keys(foo));
-})();
-
-(function TestNumbers() {
-  function createObjects() {
-    globalThis.foo = {
-      a: 6,
-      b: -7,
-      c: 7.3,
-      d: NaN,
-      e: Number.POSITIVE_INFINITY,
-      f: Number.NEGATIVE_INFINITY,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(6, foo.a);
-  assertEquals(-7, foo.b);
-  assertEquals(7.3, foo.c);
-  assertEquals(NaN, foo.d);
-  assertEquals(Number.POSITIVE_INFINITY, foo.e);
-  assertEquals(Number.NEGATIVE_INFINITY, foo.f);
-})();
-
-(function TestTopLevelNumbers() {
-  function createObjects() {
-    globalThis.a = 6;
-    globalThis.b = -7;
-  }
-  const { a, b } = takeAndUseWebSnapshot(createObjects, ['a', 'b']);
-  assertEquals(6, a);
-  assertEquals(-7, b);
-})();
-
-(function TestOddballs() {
-  function createObjects() {
-    globalThis.foo = {
-      a: true,
-      b: false,
-      c: null,
-      d: undefined,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertTrue(foo.a);
-  assertFalse(foo.b);
-  assertEquals(null, foo.c);
-  assertEquals(undefined, foo.d);
-})();
-
-(function TestTopLevelOddballs() {
-  function createObjects() {
-    globalThis.a = true;
-    globalThis.b = false;
-  }
-  const { a, b } = takeAndUseWebSnapshot(createObjects, ['a', 'b']);
-  assertTrue(a);
-  assertFalse(b);
-})();
-
-(function TestStringWithNull() {
-  function createObjects() {
-    globalThis.s = 'l\0l';
-  }
-  const { s } = takeAndUseWebSnapshot(createObjects, ['s']);
-  assertEquals(108, s.charCodeAt(0));
-  assertEquals(0, s.charCodeAt(1));
-  assertEquals(108, s.charCodeAt(2));
-})();
-
-(function TestTwoByteString() {
-  function createObjects() {
-    globalThis.s = '\u{1F600}';
-  }
-  const { s } = takeAndUseWebSnapshot(createObjects, ['s']);
-  assertEquals('\u{1F600}', s);
-})();
-
-(function TestTwoByteStringWithNull() {
-  function createObjects() {
-    globalThis.s = 'l\0l\u{1F600}';
-  }
-  const { s } = takeAndUseWebSnapshot(createObjects, ['s']);
-  assertEquals(108, s.charCodeAt(0));
-  assertEquals(0, s.charCodeAt(1));
-  assertEquals(108, s.charCodeAt(2));
-})();
-
-(function TestRegExp() {
-  function createObjects() {
-    globalThis.foo = {
-      re: /ab+c/gi,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('/ab+c/gi', foo.re.toString());
-  assertTrue(foo.re.test('aBc'));
-  assertFalse(foo.re.test('ac'));
-})();
-
-(function TestRegExpNoFlags() {
-  function createObjects() {
-    globalThis.foo = {
-      re: /ab+c/,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('/ab+c/', foo.re.toString());
-  assertTrue(foo.re.test('abc'));
-  assertFalse(foo.re.test('ac'));
-})();
-
-(function TestTopLevelRegExp() {
-  function createObjects() {
-    globalThis.re = /ab+c/gi;
-  }
-  const { re } = takeAndUseWebSnapshot(createObjects, ['re']);
-  assertEquals('/ab+c/gi', re.toString());
-  assertTrue(re.test('aBc'));
-  assertFalse(re.test('ac'));
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-bigint.js b/test/mjsunit/web-snapshot/web-snapshot-bigint.js
deleted file mode 100644
index 3ad17da2f0..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-bigint.js
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestBigInt() {
-  function createObjects() {
-    const b = 100n;
-    const c = 2n ** 222n;
-    globalThis.foo = { bar: b, bar1: c };
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(100n, foo.bar);
-  assertEquals(2n ** 222n , foo.bar1)
-})();
-
-(function TestBigIntInArray() {
-  function createObjects() {
-    const b = 100n;
-    const c = 2n ** 222n;
-    globalThis.foo = [b, c];
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([100n, 2n ** 222n], foo)
-})();
-
-(function TestBigIntInFunctionContext() {
-  function createObjects() {
-    globalThis.foo = {
-      key: (function () {
-        const b = 100n;
-        const c = 2n ** 222n;
-        function inner() {
-          return [b, c];
-        }
-        return inner;
-      })()
-    };
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([100n, 2n**222n], foo.key());
-})();
-
-(function TestBigIntInFunctionContextWithParentContext() {
-  function createObjects() {
-    globalThis.foo = {
-      key: (function () {
-        const b = 100n;
-        function inner() {
-          const c = 2n ** 222n;
-          function innerinner() {
-            return [b, c]
-          }
-          return innerinner
-        }
-        return inner();
-      })()
-    };
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([100n, 2n**222n], foo.key());
-})();
-
-(function TestBigIntInTopLevelFunctionWithContext() {
-  function createObjects() {
-    globalThis.foo = (function () {
-      const b = 100n;
-      const c = 2n ** 222n;
-      function inner() { return [b, c]; }
-      return inner;
-    })();
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([100n, 2n**222n], foo());
-})();
-
-
-(function TestBigIntInClassStaticProperty() {
-  function createObjects() {
-    globalThis.foo = class Foo {
-      static b = 100n;
-      static c = 2n ** 222n;
-    };
-  }
-  const { foo: Foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([100n, 2n**222n], [Foo.b, Foo.c]);
-})();
-
-(function TestBigIntInClassWithConstructor() {
-  function createObjects() {
-    globalThis.foo = class Foo {
-      constructor() {
-        this.b = 100n;
-        this.c = 2n ** 222n;
-      }
-    };
-  }
-  const { foo: Foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  const foo = new Foo()
-  assertEquals([100n, 2n**222n], [foo.b, foo.c]);
-})();
-
-(async function TestBigIntInClassWithMethods() {
-  function createObjects() {
-    globalThis.foo = class Foo {
-      b() {
-        return 100n;
-      }
-      async c() {
-        return 2n ** 222n;
-      }
-    };
-  }
-  const { foo: Foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  const foo = new Foo()
-  assertEquals([100n, 2n**222n], [foo.b(), await foo.c()]);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-builtin.js b/test/mjsunit/web-snapshot/web-snapshot-builtin.js
deleted file mode 100644
index 12fb8c8d45..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-builtin.js
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestBuiltin() {
-  function createObjects() {
-    globalThis.obj1 = {'a': Error};
-    globalThis.obj2 = {'b': Error.prototype};
-  }
-  const realm = Realm.create();
-  const {obj1, obj2} = takeAndUseWebSnapshot(
-      createObjects, ['obj1', 'obj2'], realm);
-  assertSame(Realm.eval(realm, 'Error'), obj1.a);
-  assertSame(Realm.eval(realm, 'Error.prototype'), obj2.b);
-})();
-
-(function TestInheritFromBuiltin() {
-  function createObjects() {
-    function inherit(subclass, superclass) {
-      function middle() {}
-      middle.prototype = superclass.prototype;
-      subclass.prototype = new middle();
-      subclass.prototype.constructor = subclass;
-    };
-    function MyError() {}
-    inherit(MyError, Error);
-    globalThis.MyError = MyError;
-  }
-  const realm = Realm.create();
-  const {MyError} = takeAndUseWebSnapshot(createObjects, ['MyError'], realm);
-  const obj = new MyError();
-  assertSame(Realm.eval(realm, 'Error.prototype'), obj.__proto__.__proto__);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-circular-reference.js b/test/mjsunit/web-snapshot/web-snapshot-circular-reference.js
deleted file mode 100644
index a120d7afb5..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-circular-reference.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestCircularObjectReference() {
-  function createObjects() {
-    globalThis.foo = {
-      bar: {}
-    };
-    globalThis.foo.bar.circular = globalThis.foo;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertSame(foo, foo.bar.circular);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-class.js b/test/mjsunit/web-snapshot/web-snapshot-class.js
deleted file mode 100644
index 5b3ecc08ca..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-class.js
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestEmptyClass() {
-  function createObjects() {
-    globalThis.Foo = class Foo { };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  const x = new Foo();
-})();
-
-(function TestClassWithConstructor() {
-  function createObjects() {
-    globalThis.Foo = class {
-      constructor() {
-        this.n = 42;
-      }
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  const x = new Foo(2);
-  assertEquals(42, x.n);
-})();
-
-(function TestClassWithMethods() {
-  function createObjects() {
-    globalThis.Foo = class {
-      f() { return 7; };
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  const x = new Foo();
-  assertEquals(7, x.f());
-})();
-
-(function TestDerivedClass() {
-  function createObjects() {
-    globalThis.Base = class { f() { return 8; }};
-    globalThis.Foo = class extends Base { };
-  }
-  const realm = Realm.create();
-  const { Foo, Base } = takeAndUseWebSnapshot(createObjects, ['Foo', 'Base'], realm);
-  assertEquals(Base.prototype, Foo.prototype.__proto__);
-  assertEquals(Base, Foo.__proto__);
-  const x = new Foo();
-  assertEquals(8, x.f());
-})();
-
-(function TestDerivedClassWithConstructor() {
-  function createObjects() {
-    globalThis.Base = class { constructor() {this.m = 43;}};
-    globalThis.Foo = class extends Base{
-      constructor() {
-        super();
-        this.n = 42;
-      }
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  const x = new Foo();
-  assertEquals(42, x.n);
-  assertEquals(43, x.m);
-})();
-
-(async function TestClassWithAsyncMethods() {
-  function createObjects() {
-    globalThis.Foo = class {
-      async g() { return 6; };
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  const x = new Foo();
-  assertEquals(6, await x.g());
-})();
-
-(function TestClassWithProperties() {
-  function createObjects() {
-    globalThis.Foo = class Foo { };
-    Foo.key1 = 'value1';
-    Foo.key2 = 1;
-    Foo.key3 = 2.2;
-    Foo.key4 = function key4() {
-      return 'key4';
-    }
-    Foo.key5 = [1, 2];
-    Foo.key6 = {'key':'value'}
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  assertEquals('value1', Foo.key1);
-  assertEquals(1, Foo.key2);
-  assertEquals(2.2, Foo.key3);
-  assertEquals('key4', Foo.key4());
-  assertEquals([1, 2], Foo.key5);
-  assertEquals({ 'key': 'value' }, Foo.key6 );
-})();
-
-(function TestClassWithStaticProperties() {
-  function createObjects() {
-    globalThis.Foo = class Foo {
-      static key1 = 'value1';
-      static key2 = 1;
-      static key3 = 2.2;
-      static key4 = [1, 2];
-      static key5 = {'key':'value'}
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  assertEquals('value1', Foo.key1);
-  assertEquals(1, Foo.key2);
-  assertEquals(2.2, Foo.key3);
-  assertEquals([1, 2], Foo.key4);
-  assertEquals({'key': 'value'}, Foo.key5);
-})();
-
-(function TestClassWithStaticMethods() {
-  function createObjects() {
-    globalThis.Foo = class Foo {
-      static foo() {
-        return 'foo'
-      }
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  assertEquals('foo', Foo.foo());
-})();
-
-(async function TestClassWithStaticAsyncMethods() {
-  function createObjects() {
-    globalThis.Foo = class Foo {
-      static async foo() {
-        await Promise.resolve(1);
-        return 'foo'
-      }
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  assertEquals('foo', await Foo.foo());
-})();
-
-(function TestClassWithStaticGeneratorMethods() {
-  function createObjects() {
-    globalThis.Foo = class Foo {
-      static *foo() {
-        yield 'foo1'
-        return 'foo2'
-      }
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  const foo = Foo.foo()
-  assertEquals('foo1', foo.next().value);
-  assertEquals('foo2', foo.next().value);
-  assertEquals(true, foo.next().done);
-})();
-
-(async function TestClassWithStaticAsyncGeneratorMethods() {
-  function createObjects() {
-    globalThis.Foo = class Foo {
-      static async *foo() {
-        yield 'foo1'
-        return 'foo2'
-      }
-    };
-  }
-  const { Foo } = takeAndUseWebSnapshot(createObjects, ['Foo']);
-  const foo = Foo.foo()
-  assertEquals('foo1', (await foo.next()).value);
-  assertEquals('foo2', (await foo.next()).value);
-  assertEquals(true, (await foo.next()).done);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-data-view.js b/test/mjsunit/web-snapshot/web-snapshot-data-view.js
deleted file mode 100644
index 8e2d86134e..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-data-view.js
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --harmony-rab-gsab --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestDataView() {
-  function createObjects() {
-    const buffer = new ArrayBuffer(10);
-    const array1 = new DataView(buffer, 0, 5);
-    const array2 = new DataView(buffer, 5, 5);
-    const array3 = new DataView(buffer, 2, 5);
-    for (let i = 0; i < 5; i++) {
-      array1.setUint8(i, i);
-      array2.setUint8(i, i);
-    }
-    globalThis.array1 = array1;
-    globalThis.array2 = array2;
-    globalThis.array3 = array3;
-  }
-  const {array1, array2, array3} = takeAndUseWebSnapshot(createObjects, [
-    'array1',
-    'array2',
-    'array3'
-  ]);
-  assertEquals(5, array1.byteLength);
-  assertEquals(0, array1.byteOffset);
-  assertEquals(5, array2.byteLength);
-  assertEquals(5, array2.byteOffset);
-  assertEquals(5, array3.byteLength);
-  assertEquals(2, array3.byteOffset);
-
-  for (let i = 0; i < 5; i++) {
-    assertEquals(i, array1.getUint8(i));
-    assertEquals(i, array2.getUint8(i));
-  }
-  assertSame(array1.buffer, array2.buffer);
-  assertSame(array1.buffer, array3.buffer);
-
-  new DataView(array1.buffer).setUint8(2, 10);
-  assertTrue(array1.getUint8(2) === 10);
-  assertTrue(array3.getUint8(0) === 10);
-})();
-
-(function TestResizableDataView() {
-  function createObjects() {
-    let resizableArrayBuffer = new ArrayBuffer(1024, {
-      maxByteLength: 1024 * 2,
-    });
-    // 0 offset, auto length
-    let array1 = new DataView(resizableArrayBuffer);
-    globalThis.array1 = array1;
-
-    // Non-0 offset, auto length
-    let array2 = new DataView(resizableArrayBuffer, 256);
-    globalThis.array2 = array2;
-
-    // Non-0 offset, fixed length
-    let array3 = new DataView(resizableArrayBuffer, 128, 4);
-    globalThis.array3 = array3;
-  }
-  const {array1, array2, array3} = takeAndUseWebSnapshot(createObjects, [
-    'array1',
-    'array2',
-    'array3',
-  ]);
-  assertTrue(array1.buffer.resizable);
-  assertEquals(2048, array1.buffer.maxByteLength);
-  assertEquals(1024, array1.byteLength);
-  assertEquals(0, array1.byteOffset, 0);
-  assertEquals(768, array2.byteLength); // 1024 - 256
-  assertEquals(256, array2.byteOffset);
-  assertEquals(4, array3.byteLength);
-  assertEquals(128, array3.byteOffset);
-
-  array1.buffer.resize(1024 * 2);
-  assertEquals(2048, array1.byteLength);
-  assertEquals(1792, array2.byteLength);  // 2048 - 256
-  assertEquals(4, array3.byteLength);
-
-  assertSame(array1.buffer, array2.buffer);
-  assertSame(array1.buffer, array3.buffer);
-})();
-
-(function TestGrowableDataView() {
-  function createObjects() {
-    let resizableArrayBuffer = new SharedArrayBuffer(1024, {
-      maxByteLength: 1024 * 2,
-    });
-    // 0 offset, auto length
-    let array1 = new DataView(resizableArrayBuffer);
-    globalThis.array1 = array1;
-
-    // Non-0 offset, auto length
-    let array2 = new DataView(resizableArrayBuffer, 256);
-    globalThis.array2 = array2;
-
-    // Non-0 offset, fixed length
-    let array3 = new DataView(resizableArrayBuffer, 128, 4);
-    globalThis.array3 = array3;
-  }
-  const {array1, array2, array3} = takeAndUseWebSnapshot(createObjects, [
-    'array1',
-    'array2',
-    'array3',
-  ]);
-  assertTrue(array1.buffer.growable);
-  assertEquals(2048, array1.buffer.maxByteLength);
-  assertEquals(1024, array1.byteLength);
-  assertEquals(0, array1.byteOffset);
-  assertEquals(768, array2.byteLength); // 1024 - 256
-  assertEquals(256, array2.byteOffset);
-  assertEquals(4, array3.byteLength);
-  assertEquals(128, array3.byteOffset);
-
-  array1.buffer.grow(1024 * 2);
-  assertEquals(2048, array1.byteLength);
-  assertEquals(1792, array2.byteLength);  // 2048 - 256
-  assertEquals(4, array3.byteLength);
-
-  assertSame(array1.buffer, array2.buffer);
-  assertSame(array1.buffer, array3.buffer);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-externals.js b/test/mjsunit/web-snapshot/web-snapshot-externals.js
deleted file mode 100644
index 73bdd27b4b..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-externals.js
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2022 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: --experimental-web-snapshots --allow-natives-syntax --verify-heap
-
-const external_1 = {external: 1};
-const external_2 = {external: 2};
-const object = {
-  a: [1,2],
-  b: external_1,
-  c: [external_1, external_2],
-  d: { d_a: external_2 }
-};
-
-(function testNoExternals() {
-  const snapshot = WebSnapshot.serialize(object);
-  const deserialized = WebSnapshot.deserialize(snapshot);
-  %HeapObjectVerify(deserialized);
-  assertEquals(object, deserialized);
-  assertEquals(external_1, deserialized.b);
-  assertNotSame(external_1, deserialized.b);
-  assertEquals(external_2, deserialized.d.d_a);
-  assertNotSame(external_2, deserialized.d.d_a);
-})();
-
-(function testOneExternals() {
-  const externals = [external_1];
-  const snapshot = WebSnapshot.serialize(object, externals);
-  const replaced_externals = [{replacement:1}]
-  const deserialized = WebSnapshot.deserialize(snapshot, replaced_externals);
-  %HeapObjectVerify(deserialized);
-  assertEquals(object.a, deserialized.a);
-  assertSame(replaced_externals[0], deserialized.b);
-  assertArrayEquals([replaced_externals[0], external_2], deserialized.c);
-  assertSame(replaced_externals[0], deserialized.c[0]);
-  assertNotSame(external_2, deserialized.c[1]);
-  assertEquals(external_2, deserialized.d.d_a);
-  assertNotSame(external_2, deserialized.d.d_a);
-})();
-
-(function testTwoExternals() {
-  const externals = [external_1, external_2];
-  const snapshot = WebSnapshot.serialize(object, externals);
-  const replaced_externals = [{replacement:1}, {replacement:2}]
-  const deserialized = WebSnapshot.deserialize(snapshot, replaced_externals);
-  %HeapObjectVerify(deserialized);
-  assertEquals(object.a, deserialized.a);
-  assertSame(deserialized.b, replaced_externals[0]);
-  assertArrayEquals(replaced_externals, deserialized.c);
-  assertSame(replaced_externals[0], deserialized.c[0]);
-  assertSame(replaced_externals[1], deserialized.c[1]);
-  assertSame(replaced_externals[1], deserialized.d.d_a);
-})();
-
-(function testApiObject() {
-  const api_object = new d8.dom.Div();
-  const source_1 = [{}, api_object];
-  assertThrows(() => WebSnapshot.serialize(source_1));
-
-  let externals = [external_1]
-  const source_2 = [{}, external_1, api_object, api_object];
-  const snapshot_2 = WebSnapshot.serialize(source_2, externals);
-  %HeapObjectVerify(externals);
-  // Check that the unhandled api object is added to the externals.
-  assertArrayEquals([external_1, api_object], externals);
-
-  assertThrows(() => WebSnapshot.deserialize(snapshot_2));
-  assertThrows(() => WebSnapshot.deserialize(snapshot_2, []));
-  assertThrows(() => WebSnapshot.deserialize(snapshot_2, [external_1]));
-
-  const result_2 = WebSnapshot.deserialize(snapshot_2, [external_1, api_object]);
-  %HeapObjectVerify(externals);
-  %HeapObjectVerify(result_2);
-  assertArrayEquals(source_2, result_2);
-  assertNotSame(source_2[0], result_2[0]);
-  assertSame(external_1, result_2[1]);
-  assertSame(api_object, result_2[2]);
-  assertSame(api_object, result_2[3]);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-function-context.js b/test/mjsunit/web-snapshot/web-snapshot-function-context.js
deleted file mode 100644
index 88854d047d..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-function-context.js
+++ /dev/null
@@ -1,444 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestFunctionWithContext() {
-  function createObjects() {
-    globalThis.foo = {
-      key: (function () {
-        let result = 'bar';
-        function inner() { return result; }
-        return inner;
-      })(),
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('bar', foo.key());
-})();
-
-(function TestInnerFunctionWithContextAndParentContext() {
-  function createObjects() {
-    globalThis.foo = {
-      key: (function () {
-        let part1 = 'snap';
-        function inner() {
-          let part2 = 'shot';
-          function innerinner() {
-            return part1 + part2;
-          }
-          return innerinner;
-        }
-        return inner();
-      })()
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('snapshot', foo.key());
-})();
-
-(function TestTopLevelFunctionWithContext() {
-  function createObjects() {
-    globalThis.foo = (function () {
-      let result = 'bar';
-      function inner() { return result; }
-      return inner;
-    })();
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('bar', foo());
-})();
-
-(function TestContextTree() {
-  function createObjects() {
-    (function outer() {
-      let a = 10;
-      let b = 20;
-      (function inner1() {
-        let c = 5;
-        globalThis.f1 = function() { return a + b + c; };
-      })();
-      (function inner2() {
-        let d = 10;
-        globalThis.f2 = function() { return a - b - d; };
-      })();
-    })();
-  }
-  const {f1, f2} = takeAndUseWebSnapshot(createObjects, ['f1', 'f2']);
-  assertEquals(35, f1());
-  assertEquals(-20, f2());
-})();
-
-(function TestContextReferringToFunction() {
-  function createObjects() {
-    (function outer() {
-      let a = function() { return 10; }
-      globalThis.f = function() { return a(); };
-    })();
-  }
-  const {f} = takeAndUseWebSnapshot(createObjects, ['f']);
-  assertEquals(10, f());
-})();
-
-(function TestNonInlinedScopeInfoInContext() {
-  function createObjects() {
-    globalThis.bar = (function() {
-      let a1 = 1;
-      let a2 = 1;
-      let a3 = 1;
-      let a4 = 1;
-      let a5 = 1;
-      let a6 = 1;
-      let a7 = 1;
-      let a8 = 1;
-      let a9 = 1;
-      let a10 = 1;
-      let a11 = 1;
-      let a12 = 1;
-      let a13 = 1;
-      let a14 = 1;
-      let a15 = 1;
-      let a16 = 1;
-      let a17 = 1;
-      let a18 = 1;
-      let a19 = 1;
-      let a20 = 1;
-      let a21 = 1;
-      let a22 = 1;
-      let a23 = 1;
-      let a24 = 1;
-      let a25 = 1;
-      let a26 = 1;
-      let a27 = 1;
-      let a28 = 1;
-      let a29 = 1;
-      let a30 = 1;
-      let a31 = 1;
-      let a32 = 1;
-      let a33 = 1;
-      let a34 = 1;
-      let a35 = 1;
-      let a36 = 1;
-      let a37 = 1;
-      let a38 = 1;
-      let a39 = 1;
-      let a40 = 1;
-      let a41 = 1;
-      let a42 = 1;
-      let a43 = 1;
-      let a44 = 1;
-      let a45 = 1;
-      let a46 = 1;
-      let a47 = 1;
-      let a48 = 1;
-      let a49 = 1;
-      let a50 = 1;
-      let a51 = 1;
-      let a52 = 1;
-      let a53 = 1;
-      let a54 = 1;
-      let a55 = 1;
-      let a56 = 1;
-      let a57 = 1;
-      let a58 = 1;
-      let a59 = 1;
-      let a60 = 1;
-      let a61 = 1;
-      let a62 = 1;
-      let a63 = 1;
-      let a64 = 1;
-      let a65 = 1;
-      let a66 = 1;
-      let a67 = 1;
-      let a68 = 1;
-      let a69 = 1;
-      let a70 = 1;
-      let a71 = 1;
-      let a72 = 1;
-      let a73 = 1;
-      let a74 = 1;
-      let a75 = 1;
-      function inner1() {
-        return a1;
-      }
-      function inner2() {
-        return a2;
-      }
-      function inner3() {
-        return a3;
-      }
-      function inner4() {
-        return a4;
-      }
-      function inner5() {
-        return a5;
-      }
-      function inner6() {
-        return a6;
-      }
-      function inner7() {
-        return a7;
-      }
-      function inner8() {
-        return a8;
-      }
-      function inner9() {
-        return a9;
-      }
-      function inner10() {
-        return a10;
-      }
-      function inner11() {
-        return a11;
-      }
-      function inner12() {
-        return a12;
-      }
-      function inner13() {
-        return a13;
-      }
-      function inner14() {
-        return a14;
-      }
-      function inner15() {
-        return a15;
-      }
-      function inner16() {
-        return a16;
-      }
-      function inner17() {
-        return a17;
-      }
-      function inner18() {
-        return a18;
-      }
-      function inner19() {
-        return a19;
-      }
-      function inner20() {
-        return a20;
-      }
-      function inner21() {
-        return a21;
-      }
-      function inner22() {
-        return a22;
-      }
-      function inner23() {
-        return a23;
-      }
-      function inner24() {
-        return a24;
-      }
-      function inner25() {
-        return a25;
-      }
-      function inner26() {
-        return a26;
-      }
-      function inner27() {
-        return a27;
-      }
-      function inner28() {
-        return a28;
-      }
-      function inner29() {
-        return a29;
-      }
-      function inner30() {
-        return a30;
-      }
-      function inner31() {
-        return a31;
-      }
-      function inner32() {
-        return a32;
-      }
-      function inner33() {
-        return a33;
-      }
-      function inner34() {
-        return a34;
-      }
-      function inner35() {
-        return a35;
-      }
-      function inner36() {
-        return a36;
-      }
-      function inner37() {
-        return a37;
-      }
-      function inner38() {
-        return a38;
-      }
-      function inner39() {
-        return a39;
-      }
-      function inner40() {
-        return a40;
-      }
-      function inner41() {
-        return a41;
-      }
-      function inner42() {
-        return a42;
-      }
-      function inner43() {
-        return a43;
-      }
-      function inner44() {
-        return a44;
-      }
-      function inner45() {
-        return a45;
-      }
-      function inner46() {
-        return a46;
-      }
-      function inner47() {
-        return a47;
-      }
-      function inner48() {
-        return a48;
-      }
-      function inner49() {
-        return a49;
-      }
-      function inner50() {
-        return a50;
-      }
-      function inner51() {
-        return a51;
-      }
-      function inner52() {
-        return a52;
-      }
-      function inner53() {
-        return a53;
-      }
-      function inner54() {
-        return a54;
-      }
-      function inner55() {
-        return a55;
-      }
-      function inner56() {
-        return a56;
-      }
-      function inner57() {
-        return a57;
-      }
-      function inner58() {
-        return a58;
-      }
-      function inner59() {
-        return a59;
-      }
-      function inner60() {
-        return a60;
-      }
-      function inner61() {
-        return a61;
-      }
-      function inner62() {
-        return a62;
-      }
-      function inner63() {
-        return a63;
-      }
-      function inner64() {
-        return a64;
-      }
-      function inner65() {
-        return a65;
-      }
-      function inner66() {
-        return a66;
-      }
-      function inner67() {
-        return a67;
-      }
-      function inner68() {
-        return a68;
-      }
-      function inner69() {
-        return a69;
-      }
-      function inner70() {
-        return a70;
-      }
-      function inner71() {
-        return a71;
-      }
-      function inner72() {
-        return a72;
-      }
-      function inner73() {
-        return a73;
-      }
-      function inner74() {
-        return a74;
-      }
-      function inner75() {
-        return a75;
-      }
-      return inner1;
-    })()
-  }
-  const {bar} = takeAndUseWebSnapshot(createObjects, ['bar']);
-  assertEquals(1, bar());
-})();
-
-(function TestMoreThanOneScopeLocalInContext() {
-  function createObjects() {
-    globalThis.foo = (function() {
-      let result = 'bar';
-      let a = '1';
-      function inner() {
-        return result;
-      }
-      function inner2() {
-        return a;
-      }
-      return inner;
-    })();
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('bar', foo());
-})();
-
-(function TestContextReferencingArray() {
-  function createObjects() {
-    function outer() {
-      let o = [11525];
-      function inner() { return o; }
-      return inner;
-    }
-    globalThis.foo = {
-      func: outer()
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(11525, foo.func()[0]);
-})();
-
-(function TestContextReferencingObject() {
-  function createObjects() {
-    function outer() {
-      let o = { value: 11525 };
-      function inner() { return o; }
-      return inner;
-    }
-    globalThis.foo = {
-      func: outer()
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(11525, foo.func().value);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-function.js b/test/mjsunit/web-snapshot/web-snapshot-function.js
deleted file mode 100644
index 9cd5e7f55c..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-function.js
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestFunction() {
-  function createObjects() {
-    globalThis.foo = {
-      key: function () { return 'bar'; },
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('bar', foo.key());
-})();
-
-(function TestOptimizingFunctionFromSnapshot() {
-  function createObjects() {
-    globalThis.f = function(a, b) { return a + b; }
-  }
-  const { f } = takeAndUseWebSnapshot(createObjects, ['f']);
-  %PrepareFunctionForOptimization(f);
-  assertEquals(3, f(1, 2));
-  %OptimizeFunctionOnNextCall(f);
-  assertEquals(4, f(1, 3));
-})();
-
-(function TestOptimizingConstructorFromSnapshot() {
-  function createObjects() {
-    globalThis.C = class {
-      constructor(a, b) {
-        this.x = a + b;
-      }
-    }
-  }
-  const { C } = takeAndUseWebSnapshot(createObjects, ['C']);
-  %PrepareFunctionForOptimization(C);
-  assertEquals(3, new C(1, 2).x);
-  %OptimizeFunctionOnNextCall(C);
-  assertEquals(4, new C(1, 3).x);
-})();
-
-(function TestFunctionPrototype() {
-  function createObjects() {
-    globalThis.F = function(p1, p2) {
-      this.x = p1 + p2;
-    }
-    globalThis.F.prototype.m = function(p1, p2) {
-      return this.x + p1 + p2;
-    }
-  }
-  const { F } = takeAndUseWebSnapshot(createObjects, ['F']);
-  const o = new F(1, 2);
-  assertEquals(3, o.x);
-  assertEquals(10, o.m(3, 4));
-})();
-
-(function TestFunctionPrototypeBecomesProto() {
-  function createObjects() {
-    globalThis.F = function() {}
-    globalThis.F.prototype.x = 100;
-  }
-  const { F } = takeAndUseWebSnapshot(createObjects, ['F']);
-  const o = new F();
-  assertEquals(100, Object.getPrototypeOf(o).x);
-})();
-
-(function TestFunctionCtorCallsFunctionInPrototype() {
-  function createObjects() {
-    globalThis.F = function() {
-      this.fooCalled = false;
-      this.foo();
-    }
-    globalThis.F.prototype.foo = function() { this.fooCalled = true; };
-  }
-  const { F } = takeAndUseWebSnapshot(createObjects, ['F']);
-  const o = new F();
-  assertTrue(o.fooCalled);
-})();
-
-(function TestFunctionPrototypeConnectedToObjectPrototype() {
-  function createObjects() {
-    globalThis.F = function() {}
-  }
-  const realm = Realm.create();
-  const { F } = takeAndUseWebSnapshot(createObjects, ['F'], realm);
-  const o = new F();
-  assertSame(Realm.eval(realm, 'Object.prototype'),
-             Object.getPrototypeOf(Object.getPrototypeOf(o)));
-})();
-
-(function TestFunctionInheritance() {
-  function createObjects() {
-    globalThis.Super = function() {}
-    globalThis.Super.prototype.superfunc = function() { return 'superfunc'; };
-    globalThis.Sub = function() {}
-    globalThis.Sub.prototype = Object.create(Super.prototype);
-    globalThis.Sub.prototype.subfunc = function() { return 'subfunc'; };
-  }
-  const realm = Realm.create();
-  const { Sub, Super } =
-      takeAndUseWebSnapshot(createObjects, ['Sub', 'Super'], realm);
-  const o = new Sub();
-  assertEquals('superfunc', o.superfunc());
-  assertEquals('subfunc', o.subfunc());
-  assertSame(Super.prototype, Sub.prototype.__proto__);
-  const realmFunctionPrototype = Realm.eval(realm, 'Function.prototype');
-  assertSame(realmFunctionPrototype, Super.__proto__);
-  assertSame(realmFunctionPrototype, Sub.__proto__);
-})();
-
-(function TestFunctionKinds() {
-  function createObjects() {
-    globalThis.normalFunction = function() {}
-    globalThis.asyncFunction = async function() {}
-    globalThis.generatorFunction = function*() {}
-    globalThis.asyncGeneratorFunction = async function*() {}
-  }
-  const realm = Realm.create();
-  const {normalFunction, asyncFunction, generatorFunction,
-         asyncGeneratorFunction} =
-      takeAndUseWebSnapshot(createObjects, ['normalFunction', 'asyncFunction',
-          'generatorFunction', 'asyncGeneratorFunction'], realm);
-  const newNormalFunction = Realm.eval(realm, 'f1 = function() {}');
-  const newAsyncFunction = Realm.eval(realm, 'f2 = async function() {}');
-  const newGeneratorFunction = Realm.eval(realm, 'f3 = function*() {}');
-  const newAsyncGeneratorFunction =
-      Realm.eval(realm, 'f4 = async function*() {}');
-
-  assertSame(newNormalFunction.__proto__, normalFunction.__proto__);
-  assertSame(newNormalFunction.prototype.__proto__,
-             normalFunction.prototype.__proto__);
-
-  assertSame(newAsyncFunction.__proto__, asyncFunction.__proto__);
-  assertEquals(undefined, asyncFunction.prototype);
-  assertEquals(undefined, newAsyncFunction.prototype);
-
-  assertSame(newGeneratorFunction.__proto__, generatorFunction.__proto__);
-  assertSame(newGeneratorFunction.prototype.__proto__,
-             generatorFunction.prototype.__proto__);
-
-  assertSame(newAsyncGeneratorFunction.__proto__,
-             asyncGeneratorFunction.__proto__);
-  assertSame(newAsyncGeneratorFunction.prototype.__proto__,
-             asyncGeneratorFunction.prototype.__proto__);
-})();
-
-(function TestFunctionWithProperties() {
-  function createObjects() {
-    function bar() { return 'bar'; };
-    bar.key1 = 'value1';
-    bar.key2 = 1;
-    bar.key3 = 2.2;
-    bar.key4 = function key4() {
-      return 'key4';
-    }
-    bar.key5 = [1, 2];
-    bar.key6 = {'key':'value'}
-    globalThis.foo = {
-      bar: bar,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('bar', foo.bar());
-  assertEquals('value1', foo.bar.key1);
-  assertEquals(1, foo.bar.key2);
-  assertEquals(2.2, foo.bar.key3);
-  assertEquals('key4', foo.bar.key4());
-  assertEquals([1, 2], foo.bar.key5);
-  assertEquals({ 'key': 'value' }, foo.bar.key6 );
-})();
-
-(function TestAsyncFunctionWithProperties() {
-  function createObjects() {
-    async function bar() { return 'bar'; };
-    bar.key1 = 'value1';
-    bar.key2 = 1;
-    bar.key3 = 2.2;
-    bar.key4 = function key4() {
-      return 'key4';
-    }
-    bar.key5 = [1, 2];
-    bar.key6 = {'key':'value'}
-    globalThis.foo = {
-      bar: bar,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('value1', foo.bar.key1);
-  assertEquals(1, foo.bar.key2);
-  assertEquals(2.2, foo.bar.key3);
-  assertEquals('key4', foo.bar.key4());
-  assertEquals([1, 2], foo.bar.key5);
-  assertEquals({'key': 'value'}, foo.bar.key6 );
-})();
-
-(function TestGeneratorFunctionWithProperties() {
-  function createObjects() {
-    function *bar() { return 'bar'; };
-    bar.key1 = 'value1';
-    bar.key2 = 1;
-    bar.key3 = 2.2;
-    bar.key4 = function key4() {
-      return 'key4';
-    };
-    bar.key5 = [1, 2];
-    bar.key6 = {'key':'value'};
-    globalThis.foo = {
-      bar: bar,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('value1', foo.bar.key1);
-  assertEquals(1, foo.bar.key2);
-  assertEquals(2.2, foo.bar.key3);
-  assertEquals('key4', foo.bar.key4());
-  assertEquals([1, 2], foo.bar.key5);
-  assertEquals({'key': 'value'}, foo.bar.key6 );
-})();
-
-(function TestAsyncGeneratorFunctionWithProperties() {
-  function createObjects() {
-    async function *bar() { return 'bar'; };
-    bar.key1 = 'value1';
-    bar.key2 = 1;
-    bar.key3 = 2.2;
-    bar.key4 = function key4() {
-      return 'key4';
-    }
-    bar.key5 = [1, 2];
-    bar.key6 = {'key':'value'}
-    globalThis.foo = {
-      bar: bar,
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('value1', foo.bar.key1);
-  assertEquals(1, foo.bar.key2);
-  assertEquals(2.2, foo.bar.key3);
-  assertEquals('key4', foo.bar.key4());
-  assertEquals([1, 2], foo.bar.key5);
-  assertEquals({'key': 'value'}, foo.bar.key6);
-})();
-
-(function TestFunctionsWithSameMap() {
-  function createObjects() {
-    function bar1() { return 'bar1'; };
-    bar1.key = 'value';
-
-    function bar2() {
-      return 'bar2';
-    }
-    bar2.key = 'value';
-
-    globalThis.foo = {
-      bar1: bar1,
-      bar2: bar2
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals('bar1', foo.bar1());
-  assertEquals('value', foo.bar1.key);
-  assertEquals('bar2', foo.bar2());
-  assertEquals('value', foo.bar2.key);
-  assertTrue(%HaveSameMap(foo.bar1, foo.bar2))
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-helpers.js b/test/mjsunit/web-snapshot/web-snapshot-helpers.js
deleted file mode 100644
index 1987861192..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-helpers.js
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2022 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.
-
-function use(exports) {
-  const result = Object.create(null);
-  exports.forEach(x => result[x] = globalThis[x]);
-  return result;
-}
-
-function takeAndUseWebSnapshot(createObjects, exports, realmForDeserializing) {
-  // Take a snapshot in Realm r1.
-  const r1 = Realm.create();
-  Realm.eval(r1, createObjects, { type: 'function' });
-  const snapshot = Realm.takeWebSnapshot(r1, exports);
-  // Use the snapshot in Realm r2.
-  const r2 = realmForDeserializing != undefined ?
-      realmForDeserializing : Realm.create();
-  const success = Realm.useWebSnapshot(r2, snapshot);
-  assertTrue(success);
-  const result =
-      Realm.eval(r2, use, { type: 'function', arguments: [exports] });
-  %HeapObjectVerify(result);
-  return result;
-}
diff --git a/test/mjsunit/web-snapshot/web-snapshot-holey-array.js b/test/mjsunit/web-snapshot/web-snapshot-holey-array.js
deleted file mode 100644
index c096d964b7..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-holey-array.js
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestHoleySmiElementsArray() {
-  function createObjects() {
-    globalThis.foo = [1,,2];
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1,,2], foo);
-})();
-
-(function TestHoleyElementsArray() {
-  function createObjects() {
-    globalThis.foo = [1,,'123'];
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1,,'123'], foo);
-})();
-
-(function TestHoleyArrayContainingDoubleAndSmi() {
-  function createObjects() {
-    globalThis.foo = [1.2, , 1];
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1.2, , 1], foo);
-})();
-
-(function TestHoleyArrayContainingDoubleAndObject() {
-  function createObjects() {
-    globalThis.foo = [1.2, , {'key': 'value'}];
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1.2, , {'key': 'value'}], foo);
-})();
-
-(function TestHoleyDoubleElementsArray() {
-  function createObjects() {
-    globalThis.foo = [1.2, , 2.3];
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals([1.2, , 2.3], foo);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-object.js b/test/mjsunit/web-snapshot/web-snapshot-object.js
deleted file mode 100644
index 394bb3de55..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-object.js
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestObjectReferencingObject() {
-  function createObjects() {
-    globalThis.foo = {
-      bar: { baz: 11525 }
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(11525, foo.bar.baz);
-})();
-
-(function TestInPlaceStringsInObject() {
-  function createObjects() {
-    globalThis.foo = {a: 'foo', b: 'bar', c: 'baz'};
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  // We cannot test that the strings are really in-place; that's covered by
-  // cctests.
-  assertEquals('foobarbaz', foo.a + foo.b + foo.c);
-})();
-
-(function TestRepeatedInPlaceStringsInObject() {
-  function createObjects() {
-    globalThis.foo = {a: 'foo', b: 'bar', c: 'foo'};
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  // We cannot test that the strings are really in-place; that's covered by
-  // cctests.
-  assertEquals('foobarfoo', foo.a + foo.b + foo.c);
-})();
-
-(function TestObjectWithPackedElements() {
-  function createObjects() {
-    globalThis.foo = {
-      '0': 'zero', '1': 'one', '2': 'two', '3': 'three'
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  // Objects always get HOLEY_ELEMENTS; no PACKED or SMI_ELEMENTS.
-  const elementsKindTest = {0: 0, 1: 1, 2: 2};
-  assertFalse(%HasPackedElements(elementsKindTest));
-  assertFalse(%HasSmiElements(elementsKindTest));
-
-  assertFalse(%HasPackedElements(foo));
-  assertFalse(%HasSmiElements(foo));
-  assertEquals('zeroonetwothree', foo[0] + foo[1] + foo[2] + foo[3]);
-})();
-
-(function TestObjectWithPackedSmiElements() {
-  function createObjects() {
-    globalThis.foo = {
-      '0': 0, '1': 1, '2': 2, '3': 3
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertFalse(%HasPackedElements(foo));
-  assertFalse(%HasSmiElements(foo));
-  assertEquals('0123', '' + foo[0] + foo[1] + foo[2] + foo[3]);
-})();
-
-(function TestObjectWithHoleyElements() {
-  function createObjects() {
-    globalThis.foo = {
-      '1': 'a', '11': 'b', '111': 'c'
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertFalse(%HasPackedElements(foo));
-  assertFalse(%HasSmiElements(foo));
-  assertEquals('abc', foo[1] + foo[11] + foo[111]);
-})();
-
-(function TestObjectWithHoleySmiElements() {
-  function createObjects() {
-    globalThis.foo = {
-      '1': 0, '11': 1, '111': 2
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertFalse(%HasPackedElements(foo));
-  assertFalse(%HasSmiElements(foo));
-  assertEquals('012', '' + foo[1] + foo[11] + foo[111]);
-})();
-
-(function TestObjectWithPropertiesAndElements() {
-  function createObjects() {
-    globalThis.foo = {
-      'prop1': 'value1', '1': 'a', 'prop2': 'value2', '11': 'b', '111': 'c'
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertFalse(%HasPackedElements(foo));
-  assertFalse(%HasSmiElements(foo));
-  assertEquals('abc', foo[1] + foo[11] + foo[111]);
-  assertEquals('value1value2', foo.prop1 + foo.prop2);
-})();
-
-(function TestObjectsWithSamePropertiesButDifferentElementsKind() {
-  function createObjects() {
-    globalThis.foo = {
-      'prop1': 'value1', 'prop2': 'value2', '1': 'a', '11': 'b', '111': 'c'
-    };
-    globalThis.bar = {
-      'prop1': 'value1', 'prop2': 'value2', '0': 0, '1': 0
-    }
-  }
-  const { foo, bar } = takeAndUseWebSnapshot(createObjects, ['foo', 'bar']);
-  assertFalse(%HasPackedElements(foo));
-  assertFalse(%HasSmiElements(foo));
-  assertEquals('abc', foo[1] + foo[11] + foo[111]);
-  assertEquals('value1value2', foo.prop1 + foo.prop2);
-  assertFalse(%HasPackedElements(bar));
-  assertFalse(%HasSmiElements(bar));
-  assertEquals('00', '' + bar[0] + bar[1]);
-  assertEquals('value1value2', bar.prop1 + bar.prop2);
-})();
-
-(function TestObjectWithEmptyMap() {
-  function createObjects() {
-    globalThis.foo = [{a:1}, {}, {b: 2}];
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(1, foo[0].a);
-  assertEquals(2, foo[2].b);
-})();
-
-(function TestObjectWithDictionaryMap() {
-  function createObjects() {
-    const obj = {};
-    // Create an object with dictionary map.
-    for (let i = 0; i < 2000; i++){
-      obj[`key${i}`] = `value${i}`;
-    }
-    globalThis.foo = obj;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(2000, Object.keys(foo).length);
-  assertEquals(2000, Object.values(foo).length);
-  for (let i = 0; i < 2000; i++){
-    assertEquals(`value${i}`, foo[`key${i}`]);
-  }
-})();
-
-(function TwoExportedObjects() {
-  function createObjects() {
-    globalThis.one = {x: 1};
-    globalThis.two = {x: 2};
-  }
-  const { one, two } = takeAndUseWebSnapshot(createObjects, ['one', 'two']);
-  assertEquals(1, one.x);
-  assertEquals(2, two.x);
-})();
-
-(function TestObjectWithDictionaryElements() {
-  function createObjects() {
-    globalThis.obj = {
-      10: 1,
-      100: 2,
-      1000: 3,
-      10000: 4
-    };
-  }
-  const { obj } = takeAndUseWebSnapshot(createObjects, ['obj']);
-  assertEquals(['10', '100', '1000', '10000'], Object.getOwnPropertyNames(obj));
-  assertEquals[1, obj[10]];
-  assertEquals[2, obj[100]];
-  assertEquals[3, obj[1000]];
-  assertEquals[4, obj[10000]];
-})();
-
-(function TestObjectWithDictionaryElementsWithLargeIndex() {
-  function createObjects() {
-    globalThis.obj = {};
-    globalThis.obj[4394967296] = 'lol';
-  }
-  const { obj } = takeAndUseWebSnapshot(createObjects, ['obj']);
-  assertEquals(['4394967296'], Object.getOwnPropertyNames(obj));
-  assertEquals['lol', obj[4394967296]];
-})();
-
-(function TestObjectWithSlackElements() {
-  function createObjects() {
-    globalThis.foo = {};
-    globalThis.bar = {};
-    for (let i = 0; i < 100; ++i) {
-      globalThis.foo[i] = i;
-      globalThis.bar[i] = {};
-    }
-  }
-  const { foo, bar } = takeAndUseWebSnapshot(createObjects, ['foo', 'bar']);
-  for (let i = 0; i < 100; ++i) {
-    assertEquals(i, foo[i]);
-    assertEquals({}, bar[i]);
-  }
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-prototype.js b/test/mjsunit/web-snapshot/web-snapshot-prototype.js
deleted file mode 100644
index eefe0cc4a7..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-prototype.js
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestObjectPrototype() {
-  function createObjects() {
-    globalThis.obj = {a: 1, __proto__: {x: 1}};
-  }
-  const realm = Realm.create();
-  const {obj} = takeAndUseWebSnapshot(createObjects, ['obj'], realm);
-  assertEquals(1, obj.x);
-  assertEquals(1, obj.__proto__.x);
-  assertSame(Realm.eval(realm, 'Object.prototype'), obj.__proto__.__proto__);
-})();
-
-(function TestEmptyObjectPrototype() {
-  function createObjects() {
-    globalThis.obj = {__proto__: {x: 1}};
-  }
-  const realm = Realm.create();
-  const {obj} = takeAndUseWebSnapshot(createObjects, ['obj'], realm);
-  assertEquals(1, obj.x);
-  assertEquals(1, obj.__proto__.x);
-  assertSame(Realm.eval(realm, 'Object.prototype'), obj.__proto__.__proto__);
-})();
-
-(function TestDictionaryObjectPrototype() {
-  function createObjects() {
-    const obj = {};
-    // Create an object with dictionary map.
-    for (let i = 0; i < 2000; i++){
-      obj[`key${i}`] = `value${i}`;
-    }
-    obj.__proto__ = {x: 1};
-    globalThis.foo = obj;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(2000, Object.keys(foo).length);
-  assertEquals(2000, Object.values(foo).length);
-  for (let i = 0; i < 2000; i++){
-    assertEquals(`value${i}`, foo[`key${i}`]);
-  }
-  assertEquals(1, foo.x);
-  assertEquals(1, foo.__proto__.x);
-})();
-
-(function TestNullPrototype() {
-  function createObjects() {
-    globalThis.foo = Object.create(null);
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(null, Object.getPrototypeOf(foo));
-})();
-
-(function TestDefaultObjectProto() {
-  function createObjects() {
-    globalThis.foo = {
-      str: 'hello',
-      n: 42,
-    };
-  }
-  const realm = Realm.create();
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo'], realm);
-  assertSame(Realm.eval(realm, 'Object.prototype'), Object.getPrototypeOf(foo));
-})();
-
-(function TestEmptyObjectProto() {
-  function createObjects() {
-    globalThis.foo = {};
-  }
-  const realm = Realm.create();
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo'], realm);
-  assertSame(Realm.eval(realm, 'Object.prototype'), Object.getPrototypeOf(foo));
-})();
-
-(function TestObjectProto() {
-  function createObjects() {
-    globalThis.foo = {
-      __proto__ : {x : 10},
-      y: 11
-    };
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertEquals(10, Object.getPrototypeOf(foo).x);
-})();
-
-(function TestObjectProtoInSnapshot() {
-  function createObjects() {
-    globalThis.o1 = { x: 10};
-    globalThis.o2 = {
-      __proto__ : o1,
-      y: 11
-    };
-  }
-  const realm = Realm.create();
-  const { o1, o2 } = takeAndUseWebSnapshot(createObjects, ['o1', 'o2'], realm);
-  assertSame(o1, Object.getPrototypeOf(o2));
-  assertSame(Realm.eval(realm, 'Object.prototype'), Object.getPrototypeOf(o1));
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-sparse-array.js b/test/mjsunit/web-snapshot/web-snapshot-sparse-array.js
deleted file mode 100644
index 7a2bf9bcb0..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-sparse-array.js
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestDictionaryElementsArray() {
-  function createObjects() {
-    const array = [];
-    // Add a large index to force dictionary elements.
-    array[2 ** 30] = 10;
-    for (let i = 0; i < 10; i++) {
-      array[i * 101] = i;
-    }
-    globalThis.foo = array;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertTrue(%HasDictionaryElements(foo));
-  assertEquals(2 ** 30 + 1, foo.length);
-  for (let i = 0; i < 10; i++) {
-    assertEquals(i, foo[i * 101]);
-  }
-})();
-
-(function TestDictionaryElementsArrayContainingArray() {
-  function createObjects() {
-    const array = [];
-    // Add a large index to force dictionary elements.
-    array[2 ** 30] = 10;
-    for (let i = 0; i < 10; i++) {
-      array[i * 101] = [i];
-    }
-    globalThis.foo = array;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertTrue(%HasDictionaryElements(foo));
-  assertEquals(2 ** 30 + 1, foo.length);
-  for (let i = 0; i < 10; i++) {
-    assertEquals([i], foo[i * 101]);
-  }
-})();
-
-(function TestDictionaryElementsArrayContainingObject() {
-  function createObjects() {
-    const array = [];
-    // Add a large index to force dictionary elements.
-    array[2 ** 30] = 10;
-    for (let i = 0; i < 10; i++) {
-      array[i * 101] = {i: i};
-    }
-    globalThis.foo = array;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertTrue(%HasDictionaryElements(foo));
-  assertEquals(2 ** 30 + 1, foo.length);
-  for (let i = 0; i < 10; i++) {
-    assertEquals({i: i}, foo[i * 101]);
-  }
-})();
-
-(function TestDictionaryElementsArrayContainingFunction() {
-  function createObjects() {
-    const array = [];
-    // Add a large index to force dictionary elements.
-    array[2 ** 30] = 10;
-    for (let i = 0; i < 10; i++) {
-      array[i * 101] = function() { return i; };
-    }
-    globalThis.foo = array;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertTrue(%HasDictionaryElements(foo));
-  assertEquals(2 ** 30 + 1, foo.length);
-  for (let i = 0; i < 10; i++) {
-    assertEquals(i, foo[i * 101]());
-  }
-})();
-
-(function TestDictionaryElementsArrayContainingString() {
-  function createObjects() {
-    const array = [];
-    // Add a large index to force dictionary elements.
-    array[2 ** 30] = 10;
-    for (let i = 0; i < 10; i++) {
-      array[i * 101] = `${i}`;
-    }
-    globalThis.foo = array;
-  }
-  const { foo } = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertTrue(%HasDictionaryElements(foo));
-  assertEquals(2 ** 30 + 1, foo.length);
-  for (let i = 0; i < 10; i++) {
-    assertEquals(`${i}`, foo[i * 101]);
-  }
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-symbol.js b/test/mjsunit/web-snapshot/web-snapshot-symbol.js
deleted file mode 100644
index 807dd1bd20..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-symbol.js
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestNonGlobalSymbol() {
-  function createObjects() {
-    const s = Symbol('description');
-    globalThis.foo = {mySymbol: s, innerObject: { symbolHereToo: s}};
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertSame(foo.mySymbol, foo.innerObject.symbolHereToo);
-  assertEquals('description', foo.mySymbol.description);
-  assertNotEquals(foo.mySymbol, Symbol('description'));
-  assertNotEquals(foo.mySymbol, Symbol.for('description'));
-})();
-
-(function TestGlobalSymbol() {
-  function createObjects() {
-    const s = Symbol.for('this is global');
-    globalThis.foo = {mySymbol: s, innerObject: { symbolHereToo: s}};
-  }
-  const {foo} = takeAndUseWebSnapshot(createObjects, ['foo']);
-  assertSame(foo.mySymbol, foo.innerObject.symbolHereToo);
-  assertEquals('this is global', foo.mySymbol.description);
-  assertEquals(Symbol.for('this is global'), foo.mySymbol);
-})();
-
-(function TestSymbolAsMapKey() {
-  function createObjects() {
-    globalThis.obj1 = {};
-    const global_symbol = Symbol.for('this is global');
-    obj1[global_symbol] = 'global symbol value';
-    globalThis.obj2 = {};
-    const nonglobal_symbol = Symbol('this is not global');
-    obj2[nonglobal_symbol] = 'nonglobal symbol value';
-  }
-  const {obj1, obj2} = takeAndUseWebSnapshot(createObjects, ['obj1', 'obj2']);
-  assertEquals('global symbol value', obj1[Symbol.for('this is global')]);
-  const nonglobal_symbol = Object.getOwnPropertySymbols(obj2)[0];
-  assertEquals('nonglobal symbol value', obj2[nonglobal_symbol]);
-})();
diff --git a/test/mjsunit/web-snapshot/web-snapshot-typed-array.js b/test/mjsunit/web-snapshot/web-snapshot-typed-array.js
deleted file mode 100644
index 0f16b5eace..0000000000
--- a/test/mjsunit/web-snapshot/web-snapshot-typed-array.js
+++ /dev/null
@@ -1,439 +0,0 @@
-// Copyright 2022 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: --experimental-d8-web-snapshot-api --allow-natives-syntax --harmony-rab-gsab --verify-heap
-
-'use strict';
-
-d8.file.execute('test/mjsunit/web-snapshot/web-snapshot-helpers.js');
-
-(function TestTypedArray() {
-  function createObjects() {
-    const int8Array = new Int8Array(3);
-    for (let i = 0; i < 3; i++) {
-      int8Array[i] = i;
-    }
-    const uint8Array = new Uint8Array(3);
-    for (let i = 0; i < 3; i++) {
-      uint8Array[i] = i;
-    }
-    const uint8ClampedArray = new Uint8ClampedArray(3);
-    for (let i = 0; i < 3; i++) {
-      uint8ClampedArray[i] = i;
-    }
-    const int16Array = new Int16Array(3);
-    for (let i = 0; i < 3; i++) {
-      int16Array[i] = i;
-    }
-    const uint16Array = new Uint16Array(3);
-    for (let i = 0; i < 3; i++) {
-      uint16Array[i] = i;
-    }
-    const int32Array = new Int32Array(3);
-    for (let i = 0; i < 3; i++) {
-      int32Array[i] = i;
-    }
-    const uint32Array = new Uint32Array(3);
-    for (let i = 0; i < 3; i++) {
-      uint32Array[i] = i;
-    }
-    const float32Array = new Float32Array(3);
-    for (let i = 0; i < 3; i++) {
-      float32Array[i] = i + 0.2;
-    }
-    const float64Array = new Float64Array(3);
-    for (let i = 0; i < 3; i++) {
-      float64Array[i] = i + 0.2;
-    }
-    const bigInt64Array = new BigInt64Array(3);
-    for (let i = 0; i < 3; i++) {
-      bigInt64Array[i] = BigInt(i);
-    }
-    const bigUint64Array = new BigUint64Array(3);
-    for (let i = 0; i < 3; i++) {
-      bigUint64Array[i] = BigInt(i);
-    }
-    globalThis.int8Array = int8Array;
-    globalThis.uint8Array = uint8Array;
-    globalThis.uint8ClampedArray = uint8ClampedArray;
-    globalThis.int16Array = int16Array;
-    globalThis.uint16Array = uint16Array;
-    globalThis.int32Array = int32Array;
-    globalThis.uint32Array = uint32Array;
-    globalThis.float32Array = float32Array;
-    globalThis.float64Array = float64Array;
-    globalThis.bigInt64Array = bigInt64Array;
-    globalThis.bigUint64Array = bigUint64Array;
-  }
-  const {
-    int8Array,
-    uint8Array,
-    uint8ClampedArray,
-    int16Array,
-    uint16Array,
-    int32Array,
-    uint32Array,
-    float32Array,
-    float64Array,
-    bigInt64Array,
-    bigUint64Array,
-  } =
-      takeAndUseWebSnapshot(createObjects, [
-        'int8Array',
-        'uint8Array',
-        'uint8ClampedArray',
-        'int16Array',
-        'uint16Array',
-        'int32Array',
-        'uint32Array',
-        'float32Array',
-        'float64Array',
-        'bigInt64Array',
-        'bigUint64Array',
-      ]);
-  assertNotSame(globalThis.int8Array, int8Array);
-  assertEquals(int8Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(int8Array[i], i);
-  }
-  assertNotSame(globalThis.uint8Array, uint8Array);
-  assertEquals(uint8Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(uint8Array[i], i);
-  }
-  assertNotSame(globalThis.uint8ClampedArray, uint8ClampedArray);
-  assertEquals(uint8ClampedArray.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(uint8ClampedArray[i], i);
-  }
-  assertNotSame(globalThis.int16Array, int16Array);
-  assertEquals(int16Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(int16Array[i], i);
-  }
-  assertNotSame(globalThis.uint16Array, uint16Array);
-  assertEquals(uint16Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(uint16Array[i], i);
-  }
-  assertNotSame(globalThis.int32Array, int32Array);
-  assertEquals(int32Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(int32Array[i], i);
-  }
-  assertNotSame(globalThis.uint32Array, uint32Array);
-  assertEquals(uint32Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(uint32Array[i], i);
-  }
-  assertNotSame(globalThis.float32Array, float32Array);
-  assertEquals(float32Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEqualsDelta(float32Array[i], i + 0.2);
-  }
-  assertNotSame(globalThis.float64Array, float64Array);
-  assertEquals(float64Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEqualsDelta(float64Array[i], i + 0.2);
-  }
-  assertNotSame(globalThis.bigInt64Array, bigInt64Array);
-  assertEquals(bigInt64Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(bigInt64Array[i], BigInt(i));
-  }
-  assertNotSame(globalThis.bigUint64Array, bigUint64Array);
-  assertEquals(bigUint64Array.length, 3);
-  for (let i = 0; i < 3; i++) {
-    assertEquals(bigUint64Array[i], BigInt(i));
-  }
-})();
-
-(function TestInt8Array() {
-  function createObjects() {
-    const array = new Int8Array([-129, -128, 1, 127, 128]);
-    globalThis.array = array;
-    const array2 = new Int8Array(array.buffer, 1, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], 127);
-  assertEquals(array[1], -128);
-  assertEquals(array[2], 1);
-  assertEquals(array[3], 127);
-  assertEquals(array[4], -128);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestUint8Array() {
-  function createObjects() {
-    const array = new Uint8Array([-1, 0, 2, 255, 256]);
-    globalThis.array = array;
-    const array2 = new Uint8Array(array.buffer, 1, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], 255);
-  assertEquals(array[1], 0);
-  assertEquals(array[2], 2);
-  assertEquals(array[3], 255);
-  assertEquals(array[4], 0);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestUint8ClampedArray() {
-  function createObjects() {
-    const array = new Uint8ClampedArray([-1, 0, 2, 255, 256]);
-    globalThis.array = array;
-    const array2 = new Uint8ClampedArray(array.buffer, 1, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], 0);
-  assertEquals(array[1], 0);
-  assertEquals(array[2], 2);
-  assertEquals(array[3], 255);
-  assertEquals(array[4], 255);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestInt16Array() {
-  function createObjects() {
-    const array = new Int16Array([-32769, -32768, 1, 32767, 32768]);
-    globalThis.array = array;
-    const array2 = new Int16Array(array.buffer, 2, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], 32767);
-  assertEquals(array[1], -32768);
-  assertEquals(array[2], 1);
-  assertEquals(array[3], 32767);
-  assertEquals(array[4], -32768);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestUint16Array() {
-  function createObjects() {
-    const array = new Uint16Array([-1, 0, 2, 65535, 65536]);
-    globalThis.array = array;
-    const array2 = new Uint16Array(array.buffer, 2, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], 65535);
-  assertEquals(array[1], 0);
-  assertEquals(array[2], 2);
-  assertEquals(array[3], 65535);
-  assertEquals(array[4], 0);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestInt32Array() {
-  function createObjects() {
-    const array = new Int32Array([
-      -2147483649,
-      -2147483648,
-      1,
-      2147483647,
-      2147483648,
-    ]);
-    globalThis.array = array;
-    const array2 = new Int32Array(array.buffer, 4, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], 2147483647);
-  assertEquals(array[1], -2147483648);
-  assertEquals(array[2], 1);
-  assertEquals(array[3], 2147483647);
-  assertEquals(array[4], -2147483648);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestUint32Array() {
-  function createObjects() {
-    const array = new Uint32Array([-1, 0, 2, 4294967295, 4294967296]);
-    globalThis.array = array;
-    const array2 = new Uint32Array(array.buffer, 4, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], 4294967295);
-  assertEquals(array[1], 0);
-  assertEquals(array[2], 2);
-  assertEquals(array[3], 4294967295);
-  assertEquals(array[4], 0);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestBigInt64Array() {
-  function createObjects() {
-    const array = new BigInt64Array([
-      BigInt(-(2 ** 63)) - 1n,
-      BigInt(-(2 ** 63)),
-      1n,
-      BigInt(2 ** 63) - 1n,
-      BigInt(2 ** 63),
-    ]);
-    globalThis.array = array;
-    const array2 = new BigInt64Array(array.buffer, 8, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], BigInt(2 ** 63) - 1n);
-  assertEquals(array[1], BigInt(-(2 ** 63)));
-  assertEquals(array[2], 1n);
-  assertEquals(array[3], BigInt(2 ** 63) - 1n);
-  assertEquals(array[4], BigInt(-(2 ** 63)));
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestBigUint32Array() {
-  function createObjects() {
-    const array = new BigUint64Array([
-      -1n,
-      0n,
-      2n,
-      BigInt(2 ** 64) - 1n,
-      BigInt(2 ** 64),
-    ]);
-    globalThis.array = array;
-    const array2 = new BigUint64Array(array.buffer, 8, 2);
-    globalThis.array2 = array2;
-  }
-  const {array, array2} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-  ]);
-  assertEquals(array.length, 5);
-  assertEquals(array[0], BigInt(2 ** 64) - 1n);
-  assertEquals(array[1], 0n);
-  assertEquals(array[2], 2n);
-  assertEquals(array[3], BigInt(2 ** 64) - 1n);
-  assertEquals(array[4], 0n);
-  assertSame(array.buffer, array2.buffer);
-  assertEquals(array2.length, 2);
-  assertEquals(array2[0], array[1]);
-  assertEquals(array2[1], array[2]);
-})();
-
-(function TestResizableTypedArray() {
-  function createObjects() {
-    let resizableArrayBuffer = new ArrayBuffer(1024, {
-      maxByteLength: 1024 * 2,
-    });
-    // 0 offset, auto length
-    let array = new Uint32Array(resizableArrayBuffer);
-    globalThis.array = array;
-
-    // Non-0 offset, auto length
-    let array2 = new Uint32Array(resizableArrayBuffer, 256);
-    globalThis.array2 = array2;
-
-    // Non-0 offset, fixed length
-    let array3 = new Uint32Array(resizableArrayBuffer, 128, 4);
-    globalThis.array3 = array3;
-  }
-  const {array, array2, array3} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-    'array3',
-  ]);
-  assertTrue(array.buffer.resizable);
-  assertEquals(array.length, 256);   // (1024 - 0) / 4
-  assertEquals(array2.length, 192);  // (1024 - 256) / 4
-  assertEquals(array3.length, 4);
-  array.buffer.resize(1024 * 2);
-  assertEquals(array.length, 512);   // (2048 - 0) / 4
-  assertEquals(array2.length, 448);  // (2048 - 256) / 4
-  assertEquals(array3.length, 4);
-})();
-
-(function TestGrowableTypedArray() {
-  function createObjects() {
-    let resizableArrayBuffer = new SharedArrayBuffer(1024, {
-      maxByteLength: 1024 * 2,
-    });
-    // 0 offset, auto length
-    let array = new Uint32Array(resizableArrayBuffer);
-    globalThis.array = array;
-
-    // Non-0 offset, auto length
-    let array2 = new Uint32Array(resizableArrayBuffer, 256);
-    globalThis.array2 = array2;
-
-    // Non-0 offset, fixed length
-    let array3 = new Uint32Array(resizableArrayBuffer, 128, 4);
-    globalThis.array3 = array3;
-  }
-  const {array, array2, array3} = takeAndUseWebSnapshot(createObjects, [
-    'array',
-    'array2',
-    'array3',
-  ]);
-  assertTrue(array.buffer.growable);
-  assertEquals(array.length, 256);   // (1024 - 0) / 4
-  assertEquals(array2.length, 192);  // (1024 - 256) / 4
-  assertEquals(array3.length, 4);
-  array.buffer.grow(1024 * 2);
-  assertEquals(array.length, 512);   // (2048 - 0) / 4
-  assertEquals(array2.length, 448);  // (2048 - 256) / 4
-  assertEquals(array3.length, 4);
-})();
diff --git a/test/unittests/BUILD.gn b/test/unittests/BUILD.gn
index dca8fb1ae2..cb428e3985 100644
--- a/test/unittests/BUILD.gn
+++ b/test/unittests/BUILD.gn
@@ -465,7 +465,6 @@ v8_source_set("unittests_sources") {
     "utils/sparse-bit-vector-unittest.cc",
     "utils/utils-unittest.cc",
     "utils/version-unittest.cc",
-    "web-snapshot/web-snapshot-unittest.cc",
     "zone/zone-allocator-unittest.cc",
     "zone/zone-chunk-list-unittest.cc",
     "zone/zone-unittest.cc",
diff --git a/test/unittests/unittests.status b/test/unittests/unittests.status
index df6a02338c..ca426e12c9 100644
--- a/test/unittests/unittests.status
+++ b/test/unittests/unittests.status
@@ -246,7 +246,6 @@
   'WeakMapsTest.WeakMapsWithChainedEntries': [SKIP],
   'WeakMapsTest.Weakness': [SKIP],
   'WeakSetsTest.WeakSet_Weakness': [SKIP],
-  'WebSnapshotTest.SFIDeduplicationAfterBytecodeFlushing': [SKIP],
 
   # CodeRange tests
   'CodePagesTest.LargeCodeObjectWithSignalHandler': [SKIP],
@@ -264,13 +263,6 @@
   'FactoryCodeBuilderOOMTest.Factory_CodeBuilder_TryBuildOOM': [SKIP],
 }], # third_party_heap
 
-################################################################################
-['variant == always_sparkplug', {
-  # SFI deduplication tests check compilation state, which always_sparkplug
-  # can break.
-  'WebSnapshotTest.SFIDeduplication*': [SKIP],
-}],
-
 ##############################################################################
 ['byteorder == big', {
   # Peephole optimization not supported on big-endian machines.
diff --git a/test/unittests/web-snapshot/web-snapshot-unittest.cc b/test/unittests/web-snapshot/web-snapshot-unittest.cc
deleted file mode 100644
index 7ecf244535..0000000000
--- a/test/unittests/web-snapshot/web-snapshot-unittest.cc
+++ /dev/null
@@ -1,1139 +0,0 @@
-// Copyright 2018 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/web-snapshot/web-snapshot.h"
-
-#include "include/v8-function.h"
-#include "src/api/api-inl.h"
-#include "test/unittests/test-utils.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace v8 {
-namespace internal {
-
-namespace {
-
-class WebSnapshotTest : public TestWithContext {
- protected:
-  void TestWebSnapshotExtensive(
-      const char* snapshot_source, const char* test_source,
-      std::function<void(v8::Isolate*, v8::Local<v8::Context>)> tester,
-      uint32_t string_count, uint32_t symbol_count,
-      uint32_t builtin_object_count, uint32_t map_count, uint32_t context_count,
-      uint32_t function_count, uint32_t object_count, uint32_t array_count) {
-    v8::Isolate* isolate = v8_isolate();
-
-    WebSnapshotData snapshot_data;
-    {
-      v8::HandleScope scope(isolate);
-      v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-      v8::Context::Scope context_scope(new_context);
-
-      TryRunJS(snapshot_source);
-      v8::Local<v8::PrimitiveArray> exports =
-          v8::PrimitiveArray::New(isolate, 1);
-      v8::Local<v8::String> str =
-          v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-      exports->Set(isolate, 0, str);
-      WebSnapshotSerializer serializer(isolate);
-      CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-      CHECK(!serializer.has_error());
-      CHECK_NOT_NULL(snapshot_data.buffer);
-      CHECK_EQ(string_count, serializer.string_count());
-      CHECK_EQ(symbol_count, serializer.symbol_count());
-      CHECK_EQ(map_count, serializer.map_count());
-      CHECK_EQ(builtin_object_count, serializer.builtin_object_count());
-      CHECK_EQ(context_count, serializer.context_count());
-      CHECK_EQ(function_count, serializer.function_count());
-      CHECK_EQ(object_count, serializer.object_count());
-      CHECK_EQ(array_count, serializer.array_count());
-    }
-
-    {
-      v8::HandleScope scope(isolate);
-      v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-      v8::Context::Scope context_scope(new_context);
-      WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                           snapshot_data.buffer_size);
-      CHECK(deserializer.Deserialize());
-      CHECK(!deserializer.has_error());
-      tester(isolate, new_context);
-      CHECK_EQ(string_count, deserializer.string_count());
-      CHECK_EQ(symbol_count, deserializer.symbol_count());
-      CHECK_EQ(map_count, deserializer.map_count());
-      CHECK_EQ(builtin_object_count, deserializer.builtin_object_count());
-      CHECK_EQ(context_count, deserializer.context_count());
-      CHECK_EQ(function_count, deserializer.function_count());
-      CHECK_EQ(object_count, deserializer.object_count());
-      CHECK_EQ(array_count, deserializer.array_count());
-    }
-  }
-
-  void TestWebSnapshot(const char* snapshot_source, const char* test_source,
-                       const char* expected_result, uint32_t string_count,
-                       uint32_t symbol_count, uint32_t map_count,
-                       uint32_t builtin_object_count, uint32_t context_count,
-                       uint32_t function_count, uint32_t object_count,
-                       uint32_t array_count) {
-    TestWebSnapshotExtensive(
-        snapshot_source, test_source,
-        [this, test_source, expected_result](
-            v8::Isolate* isolate, v8::Local<v8::Context> new_context) {
-          v8::Local<v8::String> result = RunJS(test_source).As<v8::String>();
-          CHECK(result->Equals(new_context, NewString(expected_result))
-                    .FromJust());
-        },
-        string_count, symbol_count, map_count, builtin_object_count,
-        context_count, function_count, object_count, array_count);
-  }
-
-  void VerifyFunctionKind(const v8::Local<v8::Object>& result,
-                          const v8::Local<v8::Context>& context,
-                          const char* property_name,
-                          FunctionKind expected_kind) {
-    v8::Local<v8::Function> v8_function =
-        result->Get(context, NewString(property_name))
-            .ToLocalChecked()
-            .As<v8::Function>();
-    Handle<JSFunction> function =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_function));
-    CHECK_EQ(function->shared().kind(), expected_kind);
-  }
-};
-
-}  // namespace
-
-TEST_F(WebSnapshotTest, Minimal) {
-  const char* snapshot_source = "var foo = {'key': 'lol'};";
-  const char* test_source = "foo.key";
-  const char* expected_result = "lol";
-  uint32_t kStringCount = 2;  // 'foo', 'Object.prototype'; 'key' is in-place.
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, EmptyObject) {
-  const char* snapshot_source = "var foo = {}";
-  const char* test_source = "foo";
-  uint32_t kStringCount = 2;  // 'foo', 'Object.prototype'
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  std::function<void(v8::Isolate*, v8::Local<v8::Context>)> tester =
-      [this, test_source](v8::Isolate* isolate,
-                          v8::Local<v8::Context> new_context) {
-        v8::Local<v8::Object> result = RunJS(test_source).As<v8::Object>();
-        Handle<JSReceiver> foo(v8::Utils::OpenHandle(*result));
-        Isolate* i_isolate = reinterpret_cast<Isolate*>(isolate);
-        CHECK_EQ(foo->map(),
-                 i_isolate->native_context()->object_function().initial_map());
-      };
-  TestWebSnapshotExtensive(snapshot_source, test_source, tester, kStringCount,
-                           kSymbolCount, kBuiltinObjectCount, kMapCount,
-                           kContextCount, kFunctionCount, kObjectCount,
-                           kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, Numbers) {
-  const char* snapshot_source =
-      "var foo = {'a': 6,\n"
-      "           'b': -11,\n"
-      "           'c': 11.6,\n"
-      "           'd': NaN,\n"
-      "           'e': Number.POSITIVE_INFINITY,\n"
-      "           'f': Number.NEGATIVE_INFINITY,\n"
-      "}";
-  const char* test_source = "foo";
-  uint32_t kStringCount =
-      2;  // 'foo', 'Object.prototype'; 'a'...'f' are in-place.
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-
-  std::function<void(v8::Isolate*, v8::Local<v8::Context>)> tester =
-      [this, test_source](v8::Isolate* isolate,
-                          v8::Local<v8::Context> new_context) {
-        v8::Local<v8::Object> result = RunJS(test_source).As<v8::Object>();
-        int32_t a = result->Get(new_context, NewString("a"))
-                        .ToLocalChecked()
-                        .As<v8::Number>()
-                        ->Value();
-        CHECK_EQ(a, 6);
-        int32_t b = result->Get(new_context, NewString("b"))
-                        .ToLocalChecked()
-                        .As<v8::Number>()
-                        ->Value();
-        CHECK_EQ(b, -11);
-        double c = result->Get(new_context, NewString("c"))
-                       .ToLocalChecked()
-                       .As<v8::Number>()
-                       ->Value();
-        CHECK_EQ(c, 11.6);
-        double d = result->Get(new_context, NewString("d"))
-                       .ToLocalChecked()
-                       .As<v8::Number>()
-                       ->Value();
-        CHECK(std::isnan(d));
-        double e = result->Get(new_context, NewString("e"))
-                       .ToLocalChecked()
-                       .As<v8::Number>()
-                       ->Value();
-        CHECK_EQ(e, std::numeric_limits<double>::infinity());
-        double f = result->Get(new_context, NewString("f"))
-                       .ToLocalChecked()
-                       .As<v8::Number>()
-                       ->Value();
-        CHECK_EQ(f, -std::numeric_limits<double>::infinity());
-      };
-  TestWebSnapshotExtensive(snapshot_source, test_source, tester, kStringCount,
-                           kSymbolCount, kBuiltinObjectCount, kMapCount,
-                           kContextCount, kFunctionCount, kObjectCount,
-                           kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, Oddballs) {
-  const char* snapshot_source =
-      "var foo = {'a': false,\n"
-      "           'b': true,\n"
-      "           'c': null,\n"
-      "           'd': undefined,\n"
-      "}";
-  const char* test_source = "foo";
-  // 'foo', 'Object.prototype'; 'a'...'d' are in-place.
-  uint32_t kStringCount = 2;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  std::function<void(v8::Isolate*, v8::Local<v8::Context>)> tester =
-      [this, test_source](v8::Isolate* isolate,
-                          v8::Local<v8::Context> new_context) {
-        v8::Local<v8::Object> result = RunJS(test_source).As<v8::Object>();
-        Local<Value> a =
-            result->Get(new_context, NewString("a")).ToLocalChecked();
-        CHECK(a->IsFalse());
-        Local<Value> b =
-            result->Get(new_context, NewString("b")).ToLocalChecked();
-        CHECK(b->IsTrue());
-        Local<Value> c =
-            result->Get(new_context, NewString("c")).ToLocalChecked();
-        CHECK(c->IsNull());
-        Local<Value> d =
-            result->Get(new_context, NewString("d")).ToLocalChecked();
-        CHECK(d->IsUndefined());
-      };
-  TestWebSnapshotExtensive(snapshot_source, test_source, tester, kStringCount,
-                           kSymbolCount, kBuiltinObjectCount, kMapCount,
-                           kContextCount, kFunctionCount, kObjectCount,
-                           kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, Function) {
-  const char* snapshot_source =
-      "var foo = {'key': function() { return '11525'; }};";
-  const char* test_source = "foo.key()";
-  const char* expected_result = "11525";
-  // 'foo', 'Object.prototype', 'Function.prototype', function source code.
-  // 'key' is in-place.
-  uint32_t kStringCount = 4;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 2;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 1;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, InnerFunctionWithContext) {
-  const char* snapshot_source =
-      "var foo = {'key': (function() {\n"
-      "                     let result = '11525';\n"
-      "                     function inner() { return result; }\n"
-      "                     return inner;\n"
-      "                   })()};";
-  const char* test_source = "foo.key()";
-  const char* expected_result = "11525";
-  // Strings: 'foo', 'result', 'Object.prototype', 'Function.prototype'.
-  // function source code (inner). 'key' is in-place.
-  uint32_t kStringCount = 5;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 2;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 1;
-  uint32_t kFunctionCount = 1;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, InnerFunctionWithContextAndParentContext) {
-  const char* snapshot_source =
-      "var foo = {'key': (function() {\n"
-      "                     let part1 = '11';\n"
-      "                     function inner() {\n"
-      "                       let part2 = '525';\n"
-      "                       function innerinner() {\n"
-      "                         return part1 + part2;\n"
-      "                       }\n"
-      "                       return innerinner;\n"
-      "                     }\n"
-      "                     return inner();\n"
-      "                   })()};";
-  const char* test_source = "foo.key()";
-  const char* expected_result = "11525";
-  // Strings: 'foo', 'Object.prototype', 'Function.prototype', function source
-  // code (innerinner), 'part1', 'part2'.
-  uint32_t kStringCount = 6;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 2;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 2;
-  uint32_t kFunctionCount = 1;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, RegExp) {
-  const char* snapshot_source = "var foo = {'re': /ab+c/gi}";
-  const char* test_source = "foo";
-  // 'foo', 'Object.prototype', RegExp pattern, RegExp flags
-  uint32_t kStringCount = 4;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  std::function<void(v8::Isolate*, v8::Local<v8::Context>)> tester =
-      [this, test_source](v8::Isolate* isolate,
-                          v8::Local<v8::Context> new_context) {
-        v8::Local<v8::Object> result = RunJS(test_source).As<v8::Object>();
-        Local<v8::RegExp> re = result->Get(new_context, NewString("re"))
-                                   .ToLocalChecked()
-                                   .As<v8::RegExp>();
-        CHECK(re->IsRegExp());
-        CHECK(
-            re->GetSource()->Equals(new_context, NewString("ab+c")).FromJust());
-        CHECK_EQ(v8::RegExp::kGlobal | v8::RegExp::kIgnoreCase, re->GetFlags());
-        v8::Local<v8::Object> match =
-            re->Exec(new_context, NewString("aBc")).ToLocalChecked();
-        CHECK(match->IsArray());
-        v8::Local<v8::Object> no_match =
-            re->Exec(new_context, NewString("ac")).ToLocalChecked();
-        CHECK(no_match->IsNull());
-      };
-  TestWebSnapshotExtensive(snapshot_source, test_source, tester, kStringCount,
-                           kSymbolCount, kBuiltinObjectCount, kMapCount,
-                           kContextCount, kFunctionCount, kObjectCount,
-                           kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, RegExpNoFlags) {
-  const char* snapshot_source = "var foo = {'re': /ab+c/}";
-  const char* test_source = "foo";
-  // 'foo', , 'Object.prototype RegExp pattern, RegExp flags
-  uint32_t kStringCount = 4;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  std::function<void(v8::Isolate*, v8::Local<v8::Context>)> tester =
-      [this, test_source](v8::Isolate* isolate,
-                          v8::Local<v8::Context> new_context) {
-        v8::Local<v8::Object> result = RunJS(test_source).As<v8::Object>();
-        Local<v8::RegExp> re = result->Get(new_context, NewString("re"))
-                                   .ToLocalChecked()
-                                   .As<v8::RegExp>();
-        CHECK(re->IsRegExp());
-        CHECK(
-            re->GetSource()->Equals(new_context, NewString("ab+c")).FromJust());
-        CHECK_EQ(v8::RegExp::kNone, re->GetFlags());
-        v8::Local<v8::Object> match =
-            re->Exec(new_context, NewString("abc")).ToLocalChecked();
-        CHECK(match->IsArray());
-        v8::Local<v8::Object> no_match =
-            re->Exec(new_context, NewString("ac")).ToLocalChecked();
-        CHECK(no_match->IsNull());
-      };
-  TestWebSnapshotExtensive(snapshot_source, test_source, tester, kStringCount,
-                           kSymbolCount, kBuiltinObjectCount, kMapCount,
-                           kContextCount, kFunctionCount, kObjectCount,
-                           kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, SFIDeduplication) {
-  v8::Isolate* isolate = v8_isolate();
-  v8::HandleScope scope(isolate);
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    const char* snapshot_source =
-        "let foo = {};\n"
-        "foo.outer = function(a) {\n"
-        "  return function() {\n"
-        "   return a;\n"
-        "  }\n"
-        "}\n"
-        "foo.inner = foo.outer('hi');";
-
-    TryRunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    const char* get_inner = "foo.inner";
-    const char* create_new_inner = "foo.outer()";
-
-    // Verify that foo.inner and the JSFunction which is the result of calling
-    // foo.outer() after deserialization share the SFI.
-    v8::Local<v8::Function> v8_inner1 = RunJS(get_inner).As<v8::Function>();
-    v8::Local<v8::Function> v8_inner2 =
-        RunJS(create_new_inner).As<v8::Function>();
-
-    Handle<JSFunction> inner1 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_inner1));
-    Handle<JSFunction> inner2 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_inner2));
-
-    CHECK_EQ(inner1->shared(), inner2->shared());
-  }
-}
-
-TEST_F(WebSnapshotTest, SFIDeduplicationClasses) {
-  v8::Isolate* isolate = v8_isolate();
-  v8::HandleScope scope(isolate);
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    const char* snapshot_source =
-        "let foo = {};\n"
-        "foo.create = function(a) {\n"
-        "  return class {\n"
-        "   constructor(x) {this.x = x;};\n"
-        "  }\n"
-        "}\n"
-        "foo.class = foo.create('hi');";
-
-    TryRunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    const char* get_class = "foo.class";
-    const char* create_new_class = "foo.create()";
-
-    // Verify that foo.inner and the JSFunction which is the result of calling
-    // foo.outer() after deserialization share the SFI.
-    v8::Local<v8::Function> v8_class1 = RunJS(get_class).As<v8::Function>();
-    v8::Local<v8::Function> v8_class2 =
-        RunJS(create_new_class).As<v8::Function>();
-
-    Handle<JSFunction> class1 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_class1));
-    Handle<JSFunction> class2 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_class2));
-
-    CHECK_EQ(class1->shared(), class2->shared());
-  }
-}
-
-TEST_F(WebSnapshotTest, SFIDeduplicationAfterBytecodeFlushing) {
-  v8_flags.stress_flush_code = true;
-  v8_flags.flush_bytecode = true;
-  v8::Isolate* isolate = v8_isolate();
-  DisableConservativeStackScanningScopeForTesting no_stack_scanning(
-      i_isolate()->heap());
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-
-    const char* snapshot_source =
-        "let foo = {};\n"
-        "foo.outer = function() {\n"
-        "  let a = 'hello';\n"
-        "  return function() {\n"
-        "   return a;\n"
-        "  }\n"
-        "}\n"
-        "foo.inner = foo.outer();";
-
-    TryRunJS(snapshot_source);
-
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  CollectAllGarbage();
-  CollectAllGarbage();
-
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    const char* get_outer = "foo.outer";
-    const char* get_inner = "foo.inner";
-    const char* create_new_inner = "foo.outer()";
-
-    v8::Local<v8::Function> v8_outer = RunJS(get_outer).As<v8::Function>();
-    Handle<JSFunction> outer =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_outer));
-    CHECK(!outer->shared().is_compiled());
-
-    v8::Local<v8::Function> v8_inner1 = RunJS(get_inner).As<v8::Function>();
-    v8::Local<v8::Function> v8_inner2 =
-        RunJS(create_new_inner).As<v8::Function>();
-
-    Handle<JSFunction> inner1 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_inner1));
-    Handle<JSFunction> inner2 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_inner2));
-
-    CHECK(outer->shared().is_compiled());
-    CHECK_EQ(inner1->shared(), inner2->shared());
-
-    // Force bytecode flushing of "foo.outer".
-    CollectAllGarbage();
-    CollectAllGarbage();
-
-    CHECK(!outer->shared().is_compiled());
-
-    // Create another inner function.
-    v8::Local<v8::Function> v8_inner3 =
-        RunJS(create_new_inner).As<v8::Function>();
-    Handle<JSFunction> inner3 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_inner3));
-
-    // Check that it shares the SFI with the original inner function which is in
-    // the snapshot.
-    CHECK_EQ(inner1->shared(), inner3->shared());
-  }
-}
-
-TEST_F(WebSnapshotTest, SFIDeduplicationAfterBytecodeFlushingClasses) {
-  v8_flags.stress_flush_code = true;
-  v8_flags.flush_bytecode = true;
-  v8::Isolate* isolate = v8_isolate();
-  DisableConservativeStackScanningScopeForTesting no_stack_scanning(
-      i_isolate()->heap());
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-
-    const char* snapshot_source =
-        "let foo = {};\n"
-        "foo.create = function(a) {\n"
-        "  return class {\n"
-        "   constructor(x) {this.x = x;};\n"
-        "  }\n"
-        "}\n"
-        "foo.class = foo.create('hi');";
-
-    TryRunJS(snapshot_source);
-
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  CollectAllGarbage();
-  CollectAllGarbage();
-
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    const char* get_create = "foo.create";
-    const char* get_class = "foo.class";
-    const char* create_new_class = "foo.create()";
-
-    v8::Local<v8::Function> v8_create = RunJS(get_create).As<v8::Function>();
-    Handle<JSFunction> create =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_create));
-    CHECK(!create->shared().is_compiled());
-
-    v8::Local<v8::Function> v8_class1 = RunJS(get_class).As<v8::Function>();
-    v8::Local<v8::Function> v8_class2 =
-        RunJS(create_new_class).As<v8::Function>();
-
-    Handle<JSFunction> class1 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_class1));
-    Handle<JSFunction> class2 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_class2));
-
-    CHECK(create->shared().is_compiled());
-    CHECK_EQ(class1->shared(), class2->shared());
-
-    // Force bytecode flushing of "foo.outer".
-    CollectAllGarbage();
-    CollectAllGarbage();
-
-    CHECK(!create->shared().is_compiled());
-
-    // Create another inner function.
-    v8::Local<v8::Function> v8_class3 =
-        RunJS(create_new_class).As<v8::Function>();
-    Handle<JSFunction> class3 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_class3));
-
-    // Check that it shares the SFI with the original inner function which is in
-    // the snapshot.
-    CHECK_EQ(class1->shared(), class3->shared());
-  }
-}
-
-TEST_F(WebSnapshotTest, SFIDeduplicationOfFunctionsNotInSnapshot) {
-  v8::Isolate* isolate = v8_isolate();
-  v8::HandleScope scope(isolate);
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    const char* snapshot_source =
-        "let foo = {};\n"
-        "foo.outer = function(a) {\n"
-        "  return function() {\n"
-        "   return a;\n"
-        "  }\n"
-        "}\n";
-
-    TryRunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    const char* create_new_inner = "foo.outer()";
-
-    // Verify that repeated invocations of foo.outer() return functions which
-    // share the SFI.
-    v8::Local<v8::Function> v8_inner1 =
-        RunJS(create_new_inner).As<v8::Function>();
-    v8::Local<v8::Function> v8_inner2 =
-        RunJS(create_new_inner).As<v8::Function>();
-
-    Handle<JSFunction> inner1 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_inner1));
-    Handle<JSFunction> inner2 =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_inner2));
-
-    CHECK_EQ(inner1->shared(), inner2->shared());
-  }
-}
-
-TEST_F(WebSnapshotTest, FunctionKinds) {
-  const char* snapshot_source =
-      "var foo = {a: function() {},\n"
-      "           b: () => {},\n"
-      "           c: async function() {},\n"
-      "           d: async () => {},\n"
-      "           e: function*() {},\n"
-      "           f: async function*() {}\n"
-      "}";
-  const char* test_source = "foo";
-  // 'foo', 'Object.prototype', 'Function.prototype', 'AsyncFunction.prototype',
-  // 'AsyncGeneratorFunction.prototype", "GeneratorFunction.prototype", source
-  // code. 'a'...'f' in-place.
-  uint32_t kStringCount = 7;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 5;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 6;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  std::function<void(v8::Isolate*, v8::Local<v8::Context>)> tester =
-      [this, test_source](v8::Isolate* isolate,
-                          v8::Local<v8::Context> new_context) {
-        v8::Local<v8::Object> result = RunJS(test_source).As<v8::Object>();
-        // Verify all FunctionKinds.
-        VerifyFunctionKind(result, new_context, "a",
-                           FunctionKind::kNormalFunction);
-        VerifyFunctionKind(result, new_context, "b",
-                           FunctionKind::kArrowFunction);
-        VerifyFunctionKind(result, new_context, "c",
-                           FunctionKind::kAsyncFunction);
-        VerifyFunctionKind(result, new_context, "d",
-                           FunctionKind::kAsyncArrowFunction);
-        VerifyFunctionKind(result, new_context, "e",
-                           FunctionKind::kGeneratorFunction);
-        VerifyFunctionKind(result, new_context, "f",
-                           FunctionKind::kAsyncGeneratorFunction);
-      };
-  TestWebSnapshotExtensive(snapshot_source, test_source, tester, kStringCount,
-                           kSymbolCount, kBuiltinObjectCount, kMapCount,
-                           kContextCount, kFunctionCount, kObjectCount,
-                           kArrayCount);
-}
-
-// Test that concatenating JS code to the snapshot works.
-TEST_F(WebSnapshotTest, Concatenation) {
-  v8::Isolate* isolate = v8_isolate();
-
-  const char* snapshot_source = "var foo = {a: 1};\n";
-  const char* source_to_append = "var bar = {a: 10};";
-  const char* test_source = "foo.a + bar.a";
-  uint32_t kObjectCount = 1;
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-
-    TryRunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-    CHECK_EQ(kObjectCount, serializer.object_count());
-  }
-
-  auto buffer_size = snapshot_data.buffer_size + strlen(source_to_append);
-  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
-  memcpy(buffer.get(), snapshot_data.buffer, snapshot_data.buffer_size);
-  memcpy(buffer.get() + snapshot_data.buffer_size, source_to_append,
-         strlen(source_to_append));
-
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, buffer.get(), buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-    CHECK_EQ(kObjectCount, deserializer.object_count());
-
-    v8::Local<v8::Number> result = RunJS(test_source).As<v8::Number>();
-    CHECK_EQ(11, result->Value());
-  }
-}
-
-// Test that errors from invalid concatenated code are handled correctly.
-TEST_F(WebSnapshotTest, ConcatenationErrors) {
-  v8::Isolate* isolate = v8_isolate();
-
-  const char* snapshot_source = "var foo = {a: 1};\n";
-  const char* source_to_append = "wontparse+[)";
-  uint32_t kObjectCount = 1;
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-
-    TryRunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-    CHECK_EQ(kObjectCount, serializer.object_count());
-  }
-
-  auto buffer_size = snapshot_data.buffer_size + strlen(source_to_append);
-  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
-  memcpy(buffer.get(), snapshot_data.buffer, snapshot_data.buffer_size);
-  memcpy(buffer.get() + snapshot_data.buffer_size, source_to_append,
-         strlen(source_to_append));
-
-  {
-    v8::HandleScope scope(isolate);
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, buffer.get(), buffer_size);
-    CHECK(!deserializer.Deserialize());
-  }
-}
-
-TEST_F(WebSnapshotTest, CompactedSourceCode) {
-  v8::Isolate* isolate = v8_isolate();
-  v8::HandleScope scope(isolate);
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    const char* snapshot_source =
-        "function foo() { 'foo' }\n"
-        "function bar() { 'bar' }\n"
-        "function baz() { 'baz' }\n"
-        "let e = [foo, bar, baz]";
-    TryRunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 1);
-    v8::Local<v8::String> str =
-        v8::String::NewFromUtf8(isolate, "e").ToLocalChecked();
-    exports->Set(isolate, 0, str);
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    const char* get_function = "e[0]";
-
-    // Verify that the source code got compacted.
-    v8::Local<v8::Function> v8_function =
-        RunJS(get_function).As<v8::Function>();
-    Handle<JSFunction> function =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_function));
-    Handle<String> function_script_source =
-        handle(String::cast(Script::cast(function->shared().script()).source()),
-               i_isolate());
-    const char* raw_expected_source = "() { 'foo' }() { 'bar' }() { 'baz' }";
-
-    Handle<String> expected_source = Utils::OpenHandle(
-        *v8::String::NewFromUtf8(isolate, raw_expected_source).ToLocalChecked(),
-        i_isolate());
-    CHECK(function_script_source->Equals(*expected_source));
-  }
-}
-
-TEST_F(WebSnapshotTest, InPlaceStringsInArrays) {
-  const char* snapshot_source = "var foo = ['one', 'two', 'three'];";
-  const char* test_source = "foo.join('');";
-  const char* expected_result = "onetwothree";
-  uint32_t kStringCount = 1;  // 'foo'; Other strings are in-place.
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 0;
-  uint32_t kMapCount = 0;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 0;
-  uint32_t kArrayCount = 1;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, RepeatedInPlaceStringsInArrays) {
-  const char* snapshot_source = "var foo = ['one', 'two', 'one'];";
-  const char* test_source = "foo.join('');";
-  const char* expected_result = "onetwoone";
-  uint32_t kStringCount = 2;  // 'foo', 'one'; Other strings are in-place.
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 0;
-  uint32_t kMapCount = 0;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 0;
-  uint32_t kArrayCount = 1;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, InPlaceStringsInObjects) {
-  const char* snapshot_source = "var foo =  {a: 'one', b: 'two', c: 'three'};";
-  const char* test_source = "foo.a + foo.b + foo.c;";
-  const char* expected_result = "onetwothree";
-  // 'foo', 'Object.prototype'. Other strings are in-place.
-  uint32_t kStringCount = 2;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, RepeatedInPlaceStringsInObjects) {
-  const char* snapshot_source = "var foo =  {a: 'one', b: 'two', c: 'one'};";
-  const char* test_source = "foo.a + foo.b + foo.c;";
-  const char* expected_result = "onetwoone";
-  // 'foo', 'one', 'Object.prototype'. Other strings are in-place.
-  uint32_t kStringCount = 3;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 1;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, BuiltinObjects) {
-  const char* snapshot_source = "var foo = {a: Error.prototype};";
-  const char* test_source = "foo.a == Error.prototype ? \"pass\" : \"fail\"";
-  const char* expected_result = "pass";
-  // 'foo', 'Error.prototype', 'Object.prototype'. Other strings are in-place.
-  uint32_t kStringCount = 3;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 2;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, BuiltinObjectsDeduplicated) {
-  const char* snapshot_source =
-      "var foo = {a: Error.prototype, b: Error.prototype}";
-  const char* test_source = "foo.a === Error.prototype ? \"pass\" : \"fail\"";
-  const char* expected_result = "pass";
-  // 'foo', 'Error.prototype', 'Object.prototype'. Other strings are in-place.
-  uint32_t kStringCount = 3;
-  uint32_t kSymbolCount = 0;
-  uint32_t kBuiltinObjectCount = 2;
-  uint32_t kMapCount = 1;
-  uint32_t kContextCount = 0;
-  uint32_t kFunctionCount = 0;
-  uint32_t kObjectCount = 1;
-  uint32_t kArrayCount = 0;
-  TestWebSnapshot(snapshot_source, test_source, expected_result, kStringCount,
-                  kSymbolCount, kBuiltinObjectCount, kMapCount, kContextCount,
-                  kFunctionCount, kObjectCount, kArrayCount);
-}
-
-TEST_F(WebSnapshotTest, ConstructorFunctionKinds) {
-  v8::Isolate* isolate = v8_isolate();
-  v8::HandleScope scope(isolate);
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    const char* snapshot_source =
-        "class Base { constructor() {} };\n"
-        "class Derived extends Base { constructor() {} };\n"
-        "class BaseDefault {};\n"
-        "class DerivedDefault extends BaseDefault {};\n";
-
-    TryRunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 4);
-    exports->Set(isolate, 0,
-                 v8::String::NewFromUtf8(isolate, "Base").ToLocalChecked());
-    exports->Set(isolate, 1,
-                 v8::String::NewFromUtf8(isolate, "Derived").ToLocalChecked());
-    exports->Set(
-        isolate, 2,
-        v8::String::NewFromUtf8(isolate, "BaseDefault").ToLocalChecked());
-    exports->Set(
-        isolate, 3,
-        v8::String::NewFromUtf8(isolate, "DerivedDefault").ToLocalChecked());
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    v8::Local<v8::Function> v8_base = RunJS("Base").As<v8::Function>();
-    Handle<JSFunction> base =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_base));
-    CHECK_EQ(FunctionKind::kBaseConstructor, base->shared().kind());
-
-    v8::Local<v8::Function> v8_derived = RunJS("Derived").As<v8::Function>();
-    Handle<JSFunction> derived =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_derived));
-    CHECK_EQ(FunctionKind::kDerivedConstructor, derived->shared().kind());
-
-    v8::Local<v8::Function> v8_base_default =
-        RunJS("BaseDefault").As<v8::Function>();
-    Handle<JSFunction> base_default =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_base_default));
-    CHECK_EQ(FunctionKind::kDefaultBaseConstructor,
-             base_default->shared().kind());
-
-    v8::Local<v8::Function> v8_derived_default =
-        RunJS("DerivedDefault").As<v8::Function>();
-    Handle<JSFunction> derived_default =
-        Handle<JSFunction>::cast(Utils::OpenHandle(*v8_derived_default));
-    CHECK_EQ(FunctionKind::kDefaultDerivedConstructor,
-             derived_default->shared().kind());
-  }
-}
-
-TEST_F(WebSnapshotTest, SlackElementsInObjects) {
-  v8::Isolate* isolate = v8_isolate();
-  v8::HandleScope scope(isolate);
-
-  WebSnapshotData snapshot_data;
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    const char* snapshot_source =
-        "var foo = {};"
-        "for (let i = 0; i < 100; ++i) {"
-        "  foo[i] = i;"
-        "}"
-        "var bar = {};"
-        "for (let i = 0; i < 100; ++i) {"
-        "  bar[i] = {};"
-        "}";
-
-    RunJS(snapshot_source);
-    v8::Local<v8::PrimitiveArray> exports = v8::PrimitiveArray::New(isolate, 2);
-    exports->Set(isolate, 0,
-                 v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked());
-    exports->Set(isolate, 1,
-                 v8::String::NewFromUtf8(isolate, "bar").ToLocalChecked());
-    WebSnapshotSerializer serializer(isolate);
-    CHECK(serializer.TakeSnapshot(new_context, exports, snapshot_data));
-    CHECK(!serializer.has_error());
-    CHECK_NOT_NULL(snapshot_data.buffer);
-  }
-
-  {
-    v8::Local<v8::Context> new_context = v8::Context::New(isolate);
-    v8::Context::Scope context_scope(new_context);
-    WebSnapshotDeserializer deserializer(isolate, snapshot_data.buffer,
-                                         snapshot_data.buffer_size);
-    CHECK(deserializer.Deserialize());
-    CHECK(!deserializer.has_error());
-
-    Handle<JSObject> foo =
-        Handle<JSObject>::cast(Utils::OpenHandle<v8::Object, JSReceiver>(
-            RunJS("foo").As<v8::Object>()));
-    CHECK_EQ(100, foo->elements().length());
-    CHECK_EQ(HOLEY_ELEMENTS, foo->GetElementsKind());
-
-    Handle<JSObject> bar =
-        Handle<JSObject>::cast(Utils::OpenHandle<v8::Object, JSReceiver>(
-            RunJS("bar").As<v8::Object>()));
-    CHECK_EQ(100, bar->elements().length());
-    CHECK_EQ(HOLEY_ELEMENTS, bar->GetElementsKind());
-  }
-}
-
-}  // namespace internal
-}  // namespace v8
diff --git a/tools/callstats.html b/tools/callstats.html
index d67c287959..0664d5a6ff 100644
--- a/tools/callstats.html
+++ b/tools/callstats.html
@@ -1945,7 +1945,6 @@ code is governed by a BSD-style license that can be found in the LICENSE file.
           Group.groups.get('gc-background').entry(),
           Group.groups.get('gc').entry(),
           Group.groups.get('javascript').entry(),
-          Group.groups.get('websnapshot').entry(),
           Group.groups.get('runtime').entry(),
           this.unclassified
         ];
@@ -2282,7 +2281,6 @@ code is governed by a BSD-style license that can be found in the LICENSE file.
       new Group('GC', /GC_.*|AllocateInTargetSpace|GC/, "#00799c"));
     Group.add('javascript',
       new Group('JavaScript', /JS_Execution|JavaScript/, "#DD4477"));
-    Group.add('websnapshot', new Group('WebSnapshot', /.*Web.*/, "#E8E11C"));
     Group.add('runtime', new Group('V8 C++', /.*/, "#88BB00"));
     Group.add('blink',
       new Group('Blink RCS', /.*Blink_.*/, "#006600", false, false));
diff --git a/tools/callstats_groups.py b/tools/callstats_groups.py
index cd8712d499..62898c61c8 100644
--- a/tools/callstats_groups.py
+++ b/tools/callstats_groups.py
@@ -19,5 +19,4 @@ RUNTIME_CALL_STATS_GROUPS = [
     ('Group-GC-Background', re.compile(".*GC.*BACKGROUND.*")),
     ('Group-GC', re.compile("GC_.*|AllocateInTargetSpace")),
     ('Group-JavaScript', re.compile("JS_Execution")),
-    ('Group-WebSnapshot', re.compile("WebSnapshot.*")),
     ('Group-Runtime', re.compile(".*"))]