diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7819d8e0..6af4f3cb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,32 @@
+# [8.6.0-alpha.1](https://github.com/NativeScript/ios/compare/v8.5.2...v8.6.0-alpha.1) (2023-06-20)
+
+
+### Bug Fixes
+
+* delay isolate disposal when isolate is in use ([5a6c2ee](https://github.com/NativeScript/ios/commit/5a6c2ee5efa0c557c94ae56da0d3b3a31911d1b8))
+
+
+### Reverts
+
+* Revert "Misc changes that might not be needed" ([ad9670b](https://github.com/NativeScript/ios/commit/ad9670b9c7fb347b5d59698adbadbf40c31fe86c))
+* Revert "Garbage changes to revert" ([3b0e697](https://github.com/NativeScript/ios/commit/3b0e697b2ec9f4d5fc14f2c218fe25b16159f32f))
+* Revert "Add Clear() method to ConcurrentMap" ([bfbd301](https://github.com/NativeScript/ios/commit/bfbd30198510d7526c7eef1e6949408a0aad992e))
+
+
+
+# [8.6.0-alpha.0](https://github.com/NativeScript/ios/compare/v8.5.2...v8.6.0-alpha.0) (2023-06-20)
+
+
+### Bug Fixes
+
+* delay isolate disposal when isolate is in use ([5a6c2ee](https://github.com/NativeScript/ios/commit/5a6c2ee5efa0c557c94ae56da0d3b3a31911d1b8))
+
+
+### Features
+
+* Support v8 11.1.277.17 ([20be18a](https://github.com/NativeScript/ios/pull/218/commits/20be18ac6fe44a4cc517ccdb776f249f98a31b27))
+
+
 ## [8.5.2](https://github.com/NativeScript/ios/compare/v8.5.1...v8.5.2) (2023-05-24)
 
 
diff --git a/NativeScript/include/cppgc/README.md b/NativeScript/include/cppgc/README.md
index a7d08f86..d825ea5b 100644
--- a/NativeScript/include/cppgc/README.md
+++ b/NativeScript/include/cppgc/README.md
@@ -26,6 +26,8 @@ This allows Oilpan to run garbage collection in parallel with mutators running i
 References to objects belonging to another thread's heap are modeled using cross-thread roots.
 This is even true for on-heap to on-heap references.
 
+Oilpan heaps may generally not be accessed from different threads unless otherwise noted.
+
 ## Heap partitioning
 
 Oilpan's heaps are partitioned into spaces.
diff --git a/NativeScript/include/cppgc/common.h b/NativeScript/include/cppgc/common.h
index b6dbff3d..96103836 100644
--- a/NativeScript/include/cppgc/common.h
+++ b/NativeScript/include/cppgc/common.h
@@ -5,7 +5,6 @@
 #ifndef INCLUDE_CPPGC_COMMON_H_
 #define INCLUDE_CPPGC_COMMON_H_
 
-// TODO(chromium:1056170): Remove dependency on v8.
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
diff --git a/NativeScript/include/cppgc/cross-thread-persistent.h b/NativeScript/include/cppgc/cross-thread-persistent.h
index c8751e1d..1fa28afa 100644
--- a/NativeScript/include/cppgc/cross-thread-persistent.h
+++ b/NativeScript/include/cppgc/cross-thread-persistent.h
@@ -120,7 +120,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     if (!IsValid(raw)) return;
     PersistentRegionLock guard;
     CrossThreadPersistentRegion& region = this->GetPersistentRegion(raw);
-    SetNode(region.AllocateNode(this, &Trace));
+    SetNode(region.AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(raw);
   }
 
@@ -138,7 +138,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
       : CrossThreadPersistentBase(raw), LocationPolicy(loc) {
     if (!IsValid(raw)) return;
     CrossThreadPersistentRegion& region = this->GetPersistentRegion(raw);
-    SetNode(region.AllocateNode(this, &Trace));
+    SetNode(region.AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(raw);
   }
 
@@ -349,9 +349,8 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     return ptr && ptr != kSentinelPointer;
   }
 
-  static void Trace(Visitor* v, const void* ptr) {
-    const auto* handle = static_cast<const BasicCrossThreadPersistent*>(ptr);
-    v->TraceRoot(*handle, handle->Location());
+  static void TraceAsRoot(RootVisitor& root_visitor, const void* ptr) {
+    root_visitor.Trace(*static_cast<const BasicCrossThreadPersistent*>(ptr));
   }
 
   void AssignUnsafe(T* ptr) {
@@ -378,7 +377,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     SetValue(ptr);
     if (!IsValid(ptr)) return;
     PersistentRegionLock guard;
-    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &Trace));
+    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(ptr);
   }
 
@@ -398,7 +397,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     }
     SetValue(ptr);
     if (!IsValid(ptr)) return;
-    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &Trace));
+    SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(ptr);
   }
 
@@ -416,7 +415,7 @@ class BasicCrossThreadPersistent final : public CrossThreadPersistentBase,
     return static_cast<T*>(const_cast<void*>(GetValueFromGC()));
   }
 
-  friend class cppgc::Visitor;
+  friend class internal::RootVisitor;
 };
 
 template <typename T, typename LocationPolicy, typename CheckingPolicy>
diff --git a/NativeScript/include/cppgc/heap-consistency.h b/NativeScript/include/cppgc/heap-consistency.h
index 54a4dbc2..35c59ed1 100644
--- a/NativeScript/include/cppgc/heap-consistency.h
+++ b/NativeScript/include/cppgc/heap-consistency.h
@@ -9,6 +9,7 @@
 
 #include "cppgc/internal/write-barrier.h"
 #include "cppgc/macros.h"
+#include "cppgc/member.h"
 #include "cppgc/trace-trait.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
@@ -47,6 +48,29 @@ class HeapConsistency final {
     return internal::WriteBarrier::GetWriteBarrierType(slot, value, params);
   }
 
+  /**
+   * Gets the required write barrier type for a specific write. This override is
+   * only used for all the BasicMember types.
+   *
+   * \param slot Slot containing the pointer to the object. The slot itself
+   *   must reside in an object that has been allocated using
+   *   `MakeGarbageCollected()`.
+   * \param value The pointer to the object held via `BasicMember`.
+   * \param params Parameters that may be used for actual write barrier calls.
+   *   Only filled if return value indicates that a write barrier is needed. The
+   *   contents of the `params` are an implementation detail.
+   * \returns whether a write barrier is needed and which barrier to invoke.
+   */
+  template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+            typename CheckingPolicy>
+  static V8_INLINE WriteBarrierType GetWriteBarrierType(
+      const internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                  CheckingPolicy>& value,
+      WriteBarrierParams& params) {
+    return internal::WriteBarrier::GetWriteBarrierType(
+        value.GetRawSlot(), value.GetRawStorage(), params);
+  }
+
   /**
    * Gets the required write barrier type for a specific write.
    *
@@ -146,7 +170,25 @@ class HeapConsistency final {
    */
   static V8_INLINE void GenerationalBarrier(const WriteBarrierParams& params,
                                             const void* slot) {
-    internal::WriteBarrier::GenerationalBarrier(params, slot);
+    internal::WriteBarrier::GenerationalBarrier<
+        internal::WriteBarrier::GenerationalBarrierType::kPreciseSlot>(params,
+                                                                       slot);
+  }
+
+  /**
+   * Generational barrier for maintaining consistency when running with multiple
+   * generations. This version is used when slot contains uncompressed pointer.
+   *
+   * \param params The parameters retrieved from `GetWriteBarrierType()`.
+   * \param slot Uncompressed slot containing the direct pointer to the object.
+   * The slot itself must reside in an object that has been allocated using
+   *   `MakeGarbageCollected()`.
+   */
+  static V8_INLINE void GenerationalBarrierForUncompressedSlot(
+      const WriteBarrierParams& params, const void* uncompressed_slot) {
+    internal::WriteBarrier::GenerationalBarrier<
+        internal::WriteBarrier::GenerationalBarrierType::
+            kPreciseUncompressedSlot>(params, uncompressed_slot);
   }
 
   /**
@@ -158,8 +200,9 @@ class HeapConsistency final {
    */
   static V8_INLINE void GenerationalBarrierForSourceObject(
       const WriteBarrierParams& params, const void* inner_pointer) {
-    internal::WriteBarrier::GenerationalBarrierForSourceObject(params,
-                                                               inner_pointer);
+    internal::WriteBarrier::GenerationalBarrier<
+        internal::WriteBarrier::GenerationalBarrierType::kImpreciseSlot>(
+        params, inner_pointer);
   }
 
  private:
diff --git a/NativeScript/include/cppgc/heap-handle.h b/NativeScript/include/cppgc/heap-handle.h
new file mode 100644
index 00000000..0d1d21e6
--- /dev/null
+++ b/NativeScript/include/cppgc/heap-handle.h
@@ -0,0 +1,48 @@
+// 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.
+
+#ifndef INCLUDE_CPPGC_HEAP_HANDLE_H_
+#define INCLUDE_CPPGC_HEAP_HANDLE_H_
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+namespace internal {
+class HeapBase;
+class WriteBarrierTypeForCagedHeapPolicy;
+class WriteBarrierTypeForNonCagedHeapPolicy;
+}  // namespace internal
+
+/**
+ * Opaque handle used for additional heap APIs.
+ */
+class HeapHandle {
+ public:
+  // Deleted copy ctor to avoid treating the type by value.
+  HeapHandle(const HeapHandle&) = delete;
+  HeapHandle& operator=(const HeapHandle&) = delete;
+
+ private:
+  HeapHandle() = default;
+
+  V8_INLINE bool is_incremental_marking_in_progress() const {
+    return is_incremental_marking_in_progress_;
+  }
+
+  V8_INLINE bool is_young_generation_enabled() const {
+    return is_young_generation_enabled_;
+  }
+
+  bool is_incremental_marking_in_progress_ = false;
+  bool is_young_generation_enabled_ = false;
+
+  friend class internal::HeapBase;
+  friend class internal::WriteBarrierTypeForCagedHeapPolicy;
+  friend class internal::WriteBarrierTypeForNonCagedHeapPolicy;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_HEAP_HANDLE_H_
diff --git a/NativeScript/include/cppgc/heap-statistics.h b/NativeScript/include/cppgc/heap-statistics.h
index 8e626596..5e389874 100644
--- a/NativeScript/include/cppgc/heap-statistics.h
+++ b/NativeScript/include/cppgc/heap-statistics.h
@@ -56,7 +56,7 @@ struct HeapStatistics final {
     /** Amount of memory actually used on the page. */
     size_t used_size_bytes = 0;
     /** Statistics for object allocated on the page. Filled only when
-     * NameProvider::HideInternalNames() is false. */
+     * NameProvider::SupportsCppClassNamesAsObjectNames() is true. */
     std::vector<ObjectStatsEntry> object_statistics;
   };
 
@@ -98,7 +98,7 @@ struct HeapStatistics final {
 
   /** Overall committed amount of memory for the heap. */
   size_t committed_size_bytes = 0;
-  /** Resident amount of memory help by the heap. */
+  /** Resident amount of memory held by the heap. */
   size_t resident_size_bytes = 0;
   /** Amount of memory actually used on the heap. */
   size_t used_size_bytes = 0;
diff --git a/NativeScript/include/cppgc/heap.h b/NativeScript/include/cppgc/heap.h
index aa3c6f46..02ee12ea 100644
--- a/NativeScript/include/cppgc/heap.h
+++ b/NativeScript/include/cppgc/heap.h
@@ -21,6 +21,7 @@
 namespace cppgc {
 
 class AllocationHandle;
+class HeapHandle;
 
 /**
  * Implementation details of cppgc. Those details are considered internal and
@@ -31,11 +32,6 @@ namespace internal {
 class Heap;
 }  // namespace internal
 
-/**
- * Used for additional heap APIs.
- */
-class HeapHandle;
-
 class V8_EXPORT Heap {
  public:
   /**
@@ -59,7 +55,7 @@ class V8_EXPORT Heap {
   };
 
   /**
-   * Specifies supported marking types
+   * Specifies supported marking types.
    */
   enum class MarkingType : uint8_t {
     /**
@@ -79,7 +75,7 @@ class V8_EXPORT Heap {
   };
 
   /**
-   * Specifies supported sweeping types
+   * Specifies supported sweeping types.
    */
   enum class SweepingType : uint8_t {
     /**
diff --git a/NativeScript/include/cppgc/internal/api-constants.h b/NativeScript/include/cppgc/internal/api-constants.h
index a50d4d04..023426e9 100644
--- a/NativeScript/include/cppgc/internal/api-constants.h
+++ b/NativeScript/include/cppgc/internal/api-constants.h
@@ -32,12 +32,22 @@ static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
 
 static constexpr size_t kPageSize = size_t{1} << 17;
 
+#if defined(V8_TARGET_ARCH_ARM64) && defined(V8_OS_MACOS)
+constexpr size_t kGuardPageSize = 0;
+#else
+constexpr size_t kGuardPageSize = 4096;
+#endif
+
 static constexpr size_t kLargeObjectSizeThreshold = kPageSize / 2;
 
 #if defined(CPPGC_CAGED_HEAP)
+#if defined(CPPGC_2GB_CAGE)
+constexpr size_t kCagedHeapReservationSize = static_cast<size_t>(2) * kGB;
+#else   // !defined(CPPGC_2GB_CAGE)
 constexpr size_t kCagedHeapReservationSize = static_cast<size_t>(4) * kGB;
+#endif  // !defined(CPPGC_2GB_CAGE)
 constexpr size_t kCagedHeapReservationAlignment = kCagedHeapReservationSize;
-#endif
+#endif  // defined(CPPGC_CAGED_HEAP)
 
 static constexpr size_t kDefaultAlignment = sizeof(void*);
 
diff --git a/NativeScript/include/cppgc/internal/base-page-handle.h b/NativeScript/include/cppgc/internal/base-page-handle.h
new file mode 100644
index 00000000..9c690755
--- /dev/null
+++ b/NativeScript/include/cppgc/internal/base-page-handle.h
@@ -0,0 +1,45 @@
+// 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.
+
+#ifndef INCLUDE_CPPGC_INTERNAL_BASE_PAGE_HANDLE_H_
+#define INCLUDE_CPPGC_INTERNAL_BASE_PAGE_HANDLE_H_
+
+#include "cppgc/heap-handle.h"
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/logging.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+// The class is needed in the header to allow for fast access to HeapHandle in
+// the write barrier.
+class BasePageHandle {
+ public:
+  static V8_INLINE BasePageHandle* FromPayload(void* payload) {
+    return reinterpret_cast<BasePageHandle*>(
+        (reinterpret_cast<uintptr_t>(payload) &
+         ~(api_constants::kPageSize - 1)) +
+        api_constants::kGuardPageSize);
+  }
+  static V8_INLINE const BasePageHandle* FromPayload(const void* payload) {
+    return FromPayload(const_cast<void*>(payload));
+  }
+
+  HeapHandle& heap_handle() { return heap_handle_; }
+  const HeapHandle& heap_handle() const { return heap_handle_; }
+
+ protected:
+  explicit BasePageHandle(HeapHandle& heap_handle) : heap_handle_(heap_handle) {
+    CPPGC_DCHECK(reinterpret_cast<uintptr_t>(this) % api_constants::kPageSize ==
+                 api_constants::kGuardPageSize);
+  }
+
+  HeapHandle& heap_handle_;
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_BASE_PAGE_HANDLE_H_
diff --git a/NativeScript/include/cppgc/internal/caged-heap-local-data.h b/NativeScript/include/cppgc/internal/caged-heap-local-data.h
index a27649c1..7d689f87 100644
--- a/NativeScript/include/cppgc/internal/caged-heap-local-data.h
+++ b/NativeScript/include/cppgc/internal/caged-heap-local-data.h
@@ -10,46 +10,76 @@
 #include <cstdint>
 
 #include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/caged-heap.h"
 #include "cppgc/internal/logging.h"
 #include "cppgc/platform.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
+#if __cpp_lib_bitopts
+#include <bit>
+#endif  // __cpp_lib_bitopts
+
+#if defined(CPPGC_CAGED_HEAP)
+
 namespace cppgc {
 namespace internal {
 
 class HeapBase;
+class HeapBaseHandle;
 
 #if defined(CPPGC_YOUNG_GENERATION)
 
 // AgeTable is the bytemap needed for the fast generation check in the write
-// barrier. AgeTable contains entries that correspond to 512 bytes memory
+// barrier. AgeTable contains entries that correspond to 4096 bytes memory
 // regions (cards). Each entry in the table represents generation of the objects
 // that reside on the corresponding card (young, old or mixed).
-class AgeTable final {
+class V8_EXPORT AgeTable final {
   static constexpr size_t kRequiredSize = 1 * api_constants::kMB;
   static constexpr size_t kAllocationGranularity =
       api_constants::kAllocationGranularity;
 
  public:
+  // Represents age of the objects living on a single card.
   enum class Age : uint8_t { kOld, kYoung, kMixed };
+  // When setting age for a range, consider or ignore ages of the adjacent
+  // cards.
+  enum class AdjacentCardsPolicy : uint8_t { kConsider, kIgnore };
 
   static constexpr size_t kCardSizeInBytes =
-      (api_constants::kCagedHeapReservationSize / kAllocationGranularity) /
-      kRequiredSize;
+      api_constants::kCagedHeapReservationSize / kRequiredSize;
 
   void SetAge(uintptr_t cage_offset, Age age) {
     table_[card(cage_offset)] = age;
   }
+
   V8_INLINE Age GetAge(uintptr_t cage_offset) const {
     return table_[card(cage_offset)];
   }
 
-  void Reset(PageAllocator* allocator);
+  void SetAgeForRange(uintptr_t cage_offset_begin, uintptr_t cage_offset_end,
+                      Age age, AdjacentCardsPolicy adjacent_cards_policy);
+
+  Age GetAgeForRange(uintptr_t cage_offset_begin,
+                     uintptr_t cage_offset_end) const;
+
+  void ResetForTesting();
 
  private:
   V8_INLINE size_t card(uintptr_t offset) const {
     constexpr size_t kGranularityBits =
+#if __cpp_lib_bitopts
+        std::countr_zero(static_cast<uint32_t>(kCardSizeInBytes));
+#elif V8_HAS_BUILTIN_CTZ
         __builtin_ctz(static_cast<uint32_t>(kCardSizeInBytes));
+#else   //! V8_HAS_BUILTIN_CTZ
+        // Hardcode and check with assert.
+#if defined(CPPGC_2GB_CAGE)
+        11;
+#else   // !defined(CPPGC_2GB_CAGE)
+        12;
+#endif  // !defined(CPPGC_2GB_CAGE)
+#endif  // !V8_HAS_BUILTIN_CTZ
+    static_assert((1 << kGranularityBits) == kCardSizeInBytes);
     const size_t entry = offset >> kGranularityBits;
     CPPGC_DCHECK(table_.size() > entry);
     return entry;
@@ -64,10 +94,10 @@ static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,
 #endif  // CPPGC_YOUNG_GENERATION
 
 struct CagedHeapLocalData final {
-  CagedHeapLocalData(HeapBase&, PageAllocator&);
+  V8_INLINE static CagedHeapLocalData& Get() {
+    return *reinterpret_cast<CagedHeapLocalData*>(CagedHeapBase::GetBase());
+  }
 
-  bool is_incremental_marking_in_progress = false;
-  HeapBase& heap_base;
 #if defined(CPPGC_YOUNG_GENERATION)
   AgeTable age_table;
 #endif
@@ -76,4 +106,6 @@ struct CagedHeapLocalData final {
 }  // namespace internal
 }  // namespace cppgc
 
+#endif  // defined(CPPGC_CAGED_HEAP)
+
 #endif  // INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_
diff --git a/NativeScript/include/cppgc/internal/caged-heap.h b/NativeScript/include/cppgc/internal/caged-heap.h
new file mode 100644
index 00000000..4db42aee
--- /dev/null
+++ b/NativeScript/include/cppgc/internal/caged-heap.h
@@ -0,0 +1,61 @@
+// 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.
+
+#ifndef INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_H_
+#define INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_H_
+
+#include <climits>
+#include <cstddef>
+
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/base-page-handle.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+#if defined(CPPGC_CAGED_HEAP)
+
+namespace cppgc {
+namespace internal {
+
+class V8_EXPORT CagedHeapBase {
+ public:
+  V8_INLINE static uintptr_t OffsetFromAddress(const void* address) {
+    return reinterpret_cast<uintptr_t>(address) &
+           (api_constants::kCagedHeapReservationAlignment - 1);
+  }
+
+  V8_INLINE static bool IsWithinCage(const void* address) {
+    CPPGC_DCHECK(g_heap_base_);
+    return (reinterpret_cast<uintptr_t>(address) &
+            ~(api_constants::kCagedHeapReservationAlignment - 1)) ==
+           g_heap_base_;
+  }
+
+  V8_INLINE static bool AreWithinCage(const void* addr1, const void* addr2) {
+#if defined(CPPGC_2GB_CAGE)
+    static constexpr size_t kHalfWordShift = sizeof(uint32_t) * CHAR_BIT - 1;
+#else   //! defined(CPPGC_2GB_CAGE)
+    static constexpr size_t kHalfWordShift = sizeof(uint32_t) * CHAR_BIT;
+#endif  //! defined(CPPGC_2GB_CAGE)
+    static_assert((static_cast<size_t>(1) << kHalfWordShift) ==
+                  api_constants::kCagedHeapReservationSize);
+    CPPGC_DCHECK(g_heap_base_);
+    return !(((reinterpret_cast<uintptr_t>(addr1) ^ g_heap_base_) |
+              (reinterpret_cast<uintptr_t>(addr2) ^ g_heap_base_)) >>
+             kHalfWordShift);
+  }
+
+  V8_INLINE static uintptr_t GetBase() { return g_heap_base_; }
+
+ private:
+  friend class CagedHeap;
+
+  static uintptr_t g_heap_base_;
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // defined(CPPGC_CAGED_HEAP)
+
+#endif  // INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_H_
diff --git a/NativeScript/include/cppgc/internal/gc-info.h b/NativeScript/include/cppgc/internal/gc-info.h
index 82a0d053..08ffd411 100644
--- a/NativeScript/include/cppgc/internal/gc-info.h
+++ b/NativeScript/include/cppgc/internal/gc-info.h
@@ -10,6 +10,7 @@
 #include <type_traits>
 
 #include "cppgc/internal/finalizer-trait.h"
+#include "cppgc/internal/logging.h"
 #include "cppgc/internal/name-trait.h"
 #include "cppgc/trace-trait.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
@@ -20,12 +21,12 @@ namespace internal {
 using GCInfoIndex = uint16_t;
 
 struct V8_EXPORT EnsureGCInfoIndexTrait final {
-  // Acquires a new GC info object and returns the index. In addition, also
-  // updates `registered_index` atomically.
+  // Acquires a new GC info object and updates `registered_index` with the index
+  // that identifies that new info accordingly.
   template <typename T>
-  V8_INLINE static GCInfoIndex EnsureIndex(
+  V8_INLINE static void EnsureIndex(
       std::atomic<GCInfoIndex>& registered_index) {
-    return EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
+    EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
   }
 
  private:
@@ -34,39 +35,32 @@ struct V8_EXPORT EnsureGCInfoIndexTrait final {
             bool = NameTrait<T>::HasNonHiddenName()>
   struct EnsureGCInfoIndexTraitDispatch;
 
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback,
-                                                  FinalizationCallback,
-                                                  NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback,
-                                                  FinalizationCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback, NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     FinalizationCallback,
-
-                                                     NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     FinalizationCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback);
+  static void V8_PRESERVE_MOST
+  EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback,
+                               FinalizationCallback, NameCallback);
+  static void V8_PRESERVE_MOST EnsureGCInfoIndexPolymorphic(
+      std::atomic<GCInfoIndex>&, TraceCallback, FinalizationCallback);
+  static void V8_PRESERVE_MOST EnsureGCInfoIndexPolymorphic(
+      std::atomic<GCInfoIndex>&, TraceCallback, NameCallback);
+  static void V8_PRESERVE_MOST
+  EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback);
+  static void V8_PRESERVE_MOST
+  EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback,
+                                  FinalizationCallback, NameCallback);
+  static void V8_PRESERVE_MOST EnsureGCInfoIndexNonPolymorphic(
+      std::atomic<GCInfoIndex>&, TraceCallback, FinalizationCallback);
+  static void V8_PRESERVE_MOST EnsureGCInfoIndexNonPolymorphic(
+      std::atomic<GCInfoIndex>&, TraceCallback, NameCallback);
+  static void V8_PRESERVE_MOST
+  EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&, TraceCallback);
 };
 
 #define DISPATCH(is_polymorphic, has_finalizer, has_non_hidden_name, function) \
   template <typename T>                                                        \
   struct EnsureGCInfoIndexTrait::EnsureGCInfoIndexTraitDispatch<               \
       T, is_polymorphic, has_finalizer, has_non_hidden_name> {                 \
-    V8_INLINE GCInfoIndex                                                      \
-    operator()(std::atomic<GCInfoIndex>& registered_index) {                   \
-      return function;                                                         \
+    V8_INLINE void operator()(std::atomic<GCInfoIndex>& registered_index) {    \
+      function;                                                                \
     }                                                                          \
   };
 
@@ -144,9 +138,16 @@ struct GCInfoTrait final {
     static_assert(sizeof(T), "T must be fully defined");
     static std::atomic<GCInfoIndex>
         registered_index;  // Uses zero initialization.
-    const GCInfoIndex index = registered_index.load(std::memory_order_acquire);
-    return index ? index
-                 : EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
+    GCInfoIndex index = registered_index.load(std::memory_order_acquire);
+    if (V8_UNLIKELY(!index)) {
+      EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
+      // Slow path call uses V8_PRESERVE_MOST which does not support return
+      // values (also preserves RAX). Avoid out parameter by just reloading the
+      // value here which at this point is guaranteed to be set.
+      index = registered_index.load(std::memory_order_acquire);
+      CPPGC_DCHECK(index != 0);
+    }
+    return index;
   }
 };
 
diff --git a/NativeScript/include/cppgc/internal/member-storage.h b/NativeScript/include/cppgc/internal/member-storage.h
new file mode 100644
index 00000000..0eb63820
--- /dev/null
+++ b/NativeScript/include/cppgc/internal/member-storage.h
@@ -0,0 +1,236 @@
+// 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.
+
+#ifndef INCLUDE_CPPGC_INTERNAL_MEMBER_STORAGE_H_
+#define INCLUDE_CPPGC_INTERNAL_MEMBER_STORAGE_H_
+
+#include <atomic>
+#include <cstddef>
+#include <type_traits>
+
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/logging.h"
+#include "cppgc/sentinel-pointer.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+
+#if defined(__clang__)
+// Attribute const allows the compiler to assume that CageBaseGlobal::g_base_
+// doesn't change (e.g. across calls) and thereby avoid redundant loads.
+#define CPPGC_CONST __attribute__((const))
+#define CPPGC_REQUIRE_CONSTANT_INIT \
+  __attribute__((require_constant_initialization))
+#else  // defined(__clang__)
+#define CPPGC_CONST
+#define CPPGC_REQUIRE_CONSTANT_INIT
+#endif  // defined(__clang__)
+
+class CageBaseGlobal final {
+ public:
+  V8_INLINE CPPGC_CONST static uintptr_t Get() {
+    CPPGC_DCHECK(IsBaseConsistent());
+    return g_base_;
+  }
+
+  V8_INLINE CPPGC_CONST static bool IsSet() {
+    CPPGC_DCHECK(IsBaseConsistent());
+    return (g_base_ & ~kLowerHalfWordMask) != 0;
+  }
+
+ private:
+  // We keep the lower halfword as ones to speed up decompression.
+  static constexpr uintptr_t kLowerHalfWordMask =
+      (api_constants::kCagedHeapReservationAlignment - 1);
+
+  static V8_EXPORT uintptr_t g_base_ CPPGC_REQUIRE_CONSTANT_INIT;
+
+  CageBaseGlobal() = delete;
+
+  V8_INLINE static bool IsBaseConsistent() {
+    return kLowerHalfWordMask == (g_base_ & kLowerHalfWordMask);
+  }
+
+  friend class CageBaseGlobalUpdater;
+};
+
+#undef CPPGC_REQUIRE_CONSTANT_INIT
+#undef CPPGC_CONST
+
+class V8_TRIVIAL_ABI CompressedPointer final {
+ public:
+  using IntegralType = uint32_t;
+
+  V8_INLINE CompressedPointer() : value_(0u) {}
+  V8_INLINE explicit CompressedPointer(const void* ptr)
+      : value_(Compress(ptr)) {}
+  V8_INLINE explicit CompressedPointer(std::nullptr_t) : value_(0u) {}
+  V8_INLINE explicit CompressedPointer(SentinelPointer)
+      : value_(kCompressedSentinel) {}
+
+  V8_INLINE const void* Load() const { return Decompress(value_); }
+  V8_INLINE const void* LoadAtomic() const {
+    return Decompress(
+        reinterpret_cast<const std::atomic<IntegralType>&>(value_).load(
+            std::memory_order_relaxed));
+  }
+
+  V8_INLINE void Store(const void* ptr) { value_ = Compress(ptr); }
+  V8_INLINE void StoreAtomic(const void* value) {
+    reinterpret_cast<std::atomic<IntegralType>&>(value_).store(
+        Compress(value), std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Clear() { value_ = 0u; }
+  V8_INLINE bool IsCleared() const { return !value_; }
+
+  V8_INLINE bool IsSentinel() const { return value_ == kCompressedSentinel; }
+
+  V8_INLINE uint32_t GetAsInteger() const { return value_; }
+
+  V8_INLINE friend bool operator==(CompressedPointer a, CompressedPointer b) {
+    return a.value_ == b.value_;
+  }
+  V8_INLINE friend bool operator!=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ != b.value_;
+  }
+  V8_INLINE friend bool operator<(CompressedPointer a, CompressedPointer b) {
+    return a.value_ < b.value_;
+  }
+  V8_INLINE friend bool operator<=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ <= b.value_;
+  }
+  V8_INLINE friend bool operator>(CompressedPointer a, CompressedPointer b) {
+    return a.value_ > b.value_;
+  }
+  V8_INLINE friend bool operator>=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ >= b.value_;
+  }
+
+  static V8_INLINE IntegralType Compress(const void* ptr) {
+    static_assert(
+        SentinelPointer::kSentinelValue == 0b10,
+        "The compression scheme relies on the sentinel encoded as 0b10");
+    static constexpr size_t kGigaCageMask =
+        ~(api_constants::kCagedHeapReservationAlignment - 1);
+
+    CPPGC_DCHECK(CageBaseGlobal::IsSet());
+    const uintptr_t base = CageBaseGlobal::Get();
+    CPPGC_DCHECK(!ptr || ptr == kSentinelPointer ||
+                 (base & kGigaCageMask) ==
+                     (reinterpret_cast<uintptr_t>(ptr) & kGigaCageMask));
+
+#if defined(CPPGC_2GB_CAGE)
+    // Truncate the pointer.
+    auto compressed =
+        static_cast<IntegralType>(reinterpret_cast<uintptr_t>(ptr));
+#else   // !defined(CPPGC_2GB_CAGE)
+    const auto uptr = reinterpret_cast<uintptr_t>(ptr);
+    // Shift the pointer by one and truncate.
+    auto compressed = static_cast<IntegralType>(uptr >> 1);
+#endif  // !defined(CPPGC_2GB_CAGE)
+    // Normal compressed pointers must have the MSB set.
+    CPPGC_DCHECK((!compressed || compressed == kCompressedSentinel) ||
+                 (compressed & (1 << 31)));
+    return compressed;
+  }
+
+  static V8_INLINE void* Decompress(IntegralType ptr) {
+    CPPGC_DCHECK(CageBaseGlobal::IsSet());
+    const uintptr_t base = CageBaseGlobal::Get();
+    // Treat compressed pointer as signed and cast it to uint64_t, which will
+    // sign-extend it.
+#if defined(CPPGC_2GB_CAGE)
+    const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr));
+#else   // !defined(CPPGC_2GB_CAGE)
+    // Then, shift the result by one. It's important to shift the unsigned
+    // value, as otherwise it would result in undefined behavior.
+    const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr)) << 1;
+#endif  // !defined(CPPGC_2GB_CAGE)
+    return reinterpret_cast<void*>(mask & base);
+  }
+
+ private:
+#if defined(CPPGC_2GB_CAGE)
+  static constexpr IntegralType kCompressedSentinel =
+      SentinelPointer::kSentinelValue;
+#else   // !defined(CPPGC_2GB_CAGE)
+  static constexpr IntegralType kCompressedSentinel =
+      SentinelPointer::kSentinelValue >> 1;
+#endif  // !defined(CPPGC_2GB_CAGE)
+  // All constructors initialize `value_`. Do not add a default value here as it
+  // results in a non-atomic write on some builds, even when the atomic version
+  // of the constructor is used.
+  IntegralType value_;
+};
+
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
+class V8_TRIVIAL_ABI RawPointer final {
+ public:
+  using IntegralType = uintptr_t;
+
+  V8_INLINE RawPointer() : ptr_(nullptr) {}
+  V8_INLINE explicit RawPointer(const void* ptr) : ptr_(ptr) {}
+
+  V8_INLINE const void* Load() const { return ptr_; }
+  V8_INLINE const void* LoadAtomic() const {
+    return reinterpret_cast<const std::atomic<const void*>&>(ptr_).load(
+        std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Store(const void* ptr) { ptr_ = ptr; }
+  V8_INLINE void StoreAtomic(const void* ptr) {
+    reinterpret_cast<std::atomic<const void*>&>(ptr_).store(
+        ptr, std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Clear() { ptr_ = nullptr; }
+  V8_INLINE bool IsCleared() const { return !ptr_; }
+
+  V8_INLINE bool IsSentinel() const { return ptr_ == kSentinelPointer; }
+
+  V8_INLINE uintptr_t GetAsInteger() const {
+    return reinterpret_cast<uintptr_t>(ptr_);
+  }
+
+  V8_INLINE friend bool operator==(RawPointer a, RawPointer b) {
+    return a.ptr_ == b.ptr_;
+  }
+  V8_INLINE friend bool operator!=(RawPointer a, RawPointer b) {
+    return a.ptr_ != b.ptr_;
+  }
+  V8_INLINE friend bool operator<(RawPointer a, RawPointer b) {
+    return a.ptr_ < b.ptr_;
+  }
+  V8_INLINE friend bool operator<=(RawPointer a, RawPointer b) {
+    return a.ptr_ <= b.ptr_;
+  }
+  V8_INLINE friend bool operator>(RawPointer a, RawPointer b) {
+    return a.ptr_ > b.ptr_;
+  }
+  V8_INLINE friend bool operator>=(RawPointer a, RawPointer b) {
+    return a.ptr_ >= b.ptr_;
+  }
+
+ private:
+  // All constructors initialize `ptr_`. Do not add a default value here as it
+  // results in a non-atomic write on some builds, even when the atomic version
+  // of the constructor is used.
+  const void* ptr_;
+};
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+using MemberStorage = CompressedPointer;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+using MemberStorage = RawPointer;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_MEMBER_STORAGE_H_
diff --git a/NativeScript/include/cppgc/internal/name-trait.h b/NativeScript/include/cppgc/internal/name-trait.h
index 32a33478..1d927a9d 100644
--- a/NativeScript/include/cppgc/internal/name-trait.h
+++ b/NativeScript/include/cppgc/internal/name-trait.h
@@ -6,6 +6,7 @@
 #define INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
 
 #include <cstddef>
+#include <cstdint>
 #include <type_traits>
 
 #include "cppgc/name-provider.h"
@@ -58,6 +59,11 @@ struct HeapObjectName {
   bool name_was_hidden;
 };
 
+enum class HeapObjectNameForUnnamedObject : uint8_t {
+  kUseClassNameIfSupported,
+  kUseHiddenName,
+};
+
 class V8_EXPORT NameTraitBase {
  protected:
   static HeapObjectName GetNameFromTypeSignature(const char*);
@@ -78,16 +84,24 @@ class NameTrait final : public NameTraitBase {
 #endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
   }
 
-  static HeapObjectName GetName(const void* obj) {
-    return GetNameFor(static_cast<const T*>(obj));
+  static HeapObjectName GetName(
+      const void* obj, HeapObjectNameForUnnamedObject name_retrieval_mode) {
+    return GetNameFor(static_cast<const T*>(obj), name_retrieval_mode);
   }
 
  private:
-  static HeapObjectName GetNameFor(const NameProvider* name_provider) {
+  static HeapObjectName GetNameFor(const NameProvider* name_provider,
+                                   HeapObjectNameForUnnamedObject) {
+    // Objects inheriting from `NameProvider` are not considered unnamed as
+    // users already provided a name for them.
     return {name_provider->GetHumanReadableName(), false};
   }
 
-  static HeapObjectName GetNameFor(...) {
+  static HeapObjectName GetNameFor(
+      const void*, HeapObjectNameForUnnamedObject name_retrieval_mode) {
+    if (name_retrieval_mode == HeapObjectNameForUnnamedObject::kUseHiddenName)
+      return {NameProvider::kHiddenName, true};
+
 #if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
     return {GetTypename<T>(), false};
 #elif CPPGC_SUPPORTS_OBJECT_NAMES
@@ -102,7 +116,7 @@ class NameTrait final : public NameTraitBase {
 
     static const HeapObjectName leaky_name =
         GetNameFromTypeSignature(PRETTY_FUNCTION_VALUE);
-    return {leaky_name, false};
+    return leaky_name;
 
 #undef PRETTY_FUNCTION_VALUE
 
@@ -112,7 +126,8 @@ class NameTrait final : public NameTraitBase {
   }
 };
 
-using NameCallback = HeapObjectName (*)(const void*);
+using NameCallback = HeapObjectName (*)(const void*,
+                                        HeapObjectNameForUnnamedObject);
 
 }  // namespace internal
 }  // namespace cppgc
diff --git a/NativeScript/include/cppgc/internal/persistent-node.h b/NativeScript/include/cppgc/internal/persistent-node.h
index 22b4cf09..d22692a7 100644
--- a/NativeScript/include/cppgc/internal/persistent-node.h
+++ b/NativeScript/include/cppgc/internal/persistent-node.h
@@ -14,13 +14,11 @@
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
-
-class Visitor;
-
 namespace internal {
 
 class CrossThreadPersistentRegion;
 class FatalOutOfMemoryHandler;
+class RootVisitor;
 
 // PersistentNode represents a variant of two states:
 // 1) traceable node with a back pointer to the Persistent object;
@@ -32,7 +30,7 @@ class PersistentNode final {
   PersistentNode(const PersistentNode&) = delete;
   PersistentNode& operator=(const PersistentNode&) = delete;
 
-  void InitializeAsUsedNode(void* owner, TraceCallback trace) {
+  void InitializeAsUsedNode(void* owner, TraceRootCallback trace) {
     CPPGC_DCHECK(trace);
     owner_ = owner;
     trace_ = trace;
@@ -53,9 +51,9 @@ class PersistentNode final {
     return next_;
   }
 
-  void Trace(Visitor* visitor) const {
+  void Trace(RootVisitor& root_visitor) const {
     CPPGC_DCHECK(IsUsed());
-    trace_(visitor, owner_);
+    trace_(root_visitor, owner_);
   }
 
   bool IsUsed() const { return trace_; }
@@ -73,7 +71,7 @@ class PersistentNode final {
     void* owner_ = nullptr;
     PersistentNode* next_;
   };
-  TraceCallback trace_ = nullptr;
+  TraceRootCallback trace_ = nullptr;
 };
 
 class V8_EXPORT PersistentRegionBase {
@@ -86,7 +84,7 @@ class V8_EXPORT PersistentRegionBase {
   PersistentRegionBase(const PersistentRegionBase&) = delete;
   PersistentRegionBase& operator=(const PersistentRegionBase&) = delete;
 
-  void Trace(Visitor*);
+  void Iterate(RootVisitor&);
 
   size_t NodesInUse() const;
 
@@ -96,7 +94,7 @@ class V8_EXPORT PersistentRegionBase {
   explicit PersistentRegionBase(const FatalOutOfMemoryHandler& oom_handler);
 
   PersistentNode* TryAllocateNodeFromFreeList(void* owner,
-                                              TraceCallback trace) {
+                                              TraceRootCallback trace) {
     PersistentNode* node = nullptr;
     if (V8_LIKELY(free_list_head_)) {
       node = free_list_head_;
@@ -118,7 +116,7 @@ class V8_EXPORT PersistentRegionBase {
   }
 
   PersistentNode* RefillFreeListAndAllocateNode(void* owner,
-                                                TraceCallback trace);
+                                                TraceRootCallback trace);
 
  private:
   template <typename PersistentBaseClass>
@@ -145,7 +143,7 @@ class V8_EXPORT PersistentRegion final : public PersistentRegionBase {
   PersistentRegion(const PersistentRegion&) = delete;
   PersistentRegion& operator=(const PersistentRegion&) = delete;
 
-  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
+  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceRootCallback trace) {
     CPPGC_DCHECK(IsCreationThread());
     auto* node = TryAllocateNodeFromFreeList(owner, trace);
     if (V8_LIKELY(node)) return node;
@@ -189,7 +187,7 @@ class V8_EXPORT CrossThreadPersistentRegion final
   CrossThreadPersistentRegion& operator=(const CrossThreadPersistentRegion&) =
       delete;
 
-  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
+  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceRootCallback trace) {
     PersistentRegionLock::AssertLocked();
     auto* node = TryAllocateNodeFromFreeList(owner, trace);
     if (V8_LIKELY(node)) return node;
@@ -202,7 +200,7 @@ class V8_EXPORT CrossThreadPersistentRegion final
     PersistentRegionBase::FreeNode(node);
   }
 
-  void Trace(Visitor*);
+  void Iterate(RootVisitor&);
 
   size_t NodesInUse() const;
 
diff --git a/NativeScript/include/cppgc/internal/pointer-policies.h b/NativeScript/include/cppgc/internal/pointer-policies.h
index 853d7031..e67da040 100644
--- a/NativeScript/include/cppgc/internal/pointer-policies.h
+++ b/NativeScript/include/cppgc/internal/pointer-policies.h
@@ -8,6 +8,7 @@
 #include <cstdint>
 #include <type_traits>
 
+#include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/write-barrier.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/source-location.h"
@@ -27,15 +28,44 @@ class WeakMemberTag;
 class UntracedMemberTag;
 
 struct DijkstraWriteBarrierPolicy {
-  static void InitializingBarrier(const void*, const void*) {
+  V8_INLINE static void InitializingBarrier(const void*, const void*) {
     // Since in initializing writes the source object is always white, having no
     // barrier doesn't break the tri-color invariant.
   }
-  static void AssigningBarrier(const void* slot, const void* value) {
+
+  V8_INLINE static void AssigningBarrier(const void* slot, const void* value) {
+#ifdef CPPGC_SLIM_WRITE_BARRIER
+    if (V8_UNLIKELY(WriteBarrier::IsEnabled()))
+      WriteBarrier::CombinedWriteBarrierSlow(slot);
+#else   // !CPPGC_SLIM_WRITE_BARRIER
+    WriteBarrier::Params params;
+    const WriteBarrier::Type type =
+        WriteBarrier::GetWriteBarrierType(slot, value, params);
+    WriteBarrier(type, params, slot, value);
+#endif  // !CPPGC_SLIM_WRITE_BARRIER
+  }
+
+  V8_INLINE static void AssigningBarrier(const void* slot,
+                                         MemberStorage storage) {
+#ifdef CPPGC_SLIM_WRITE_BARRIER
+    if (V8_UNLIKELY(WriteBarrier::IsEnabled()))
+      WriteBarrier::CombinedWriteBarrierSlow(slot);
+#else   // !CPPGC_SLIM_WRITE_BARRIER
     WriteBarrier::Params params;
-    switch (WriteBarrier::GetWriteBarrierType(slot, value, params)) {
+    const WriteBarrier::Type type =
+        WriteBarrier::GetWriteBarrierType(slot, storage, params);
+    WriteBarrier(type, params, slot, storage.Load());
+#endif  // !CPPGC_SLIM_WRITE_BARRIER
+  }
+
+ private:
+  V8_INLINE static void WriteBarrier(WriteBarrier::Type type,
+                                     const WriteBarrier::Params& params,
+                                     const void* slot, const void* value) {
+    switch (type) {
       case WriteBarrier::Type::kGenerational:
-        WriteBarrier::GenerationalBarrier(params, slot);
+        WriteBarrier::GenerationalBarrier<
+            WriteBarrier::GenerationalBarrierType::kPreciseSlot>(params, slot);
         break;
       case WriteBarrier::Type::kMarking:
         WriteBarrier::DijkstraMarkingBarrier(params, value);
@@ -47,8 +77,9 @@ struct DijkstraWriteBarrierPolicy {
 };
 
 struct NoWriteBarrierPolicy {
-  static void InitializingBarrier(const void*, const void*) {}
-  static void AssigningBarrier(const void*, const void*) {}
+  V8_INLINE static void InitializingBarrier(const void*, const void*) {}
+  V8_INLINE static void AssigningBarrier(const void*, const void*) {}
+  V8_INLINE static void AssigningBarrier(const void*, MemberStorage) {}
 };
 
 class V8_EXPORT SameThreadEnabledCheckingPolicyBase {
@@ -89,7 +120,7 @@ class V8_EXPORT SameThreadEnabledCheckingPolicy
 
 class DisabledCheckingPolicy {
  protected:
-  void CheckPointer(const void*) {}
+  V8_INLINE void CheckPointer(const void*) {}
 };
 
 #ifdef DEBUG
diff --git a/NativeScript/include/cppgc/internal/write-barrier.h b/NativeScript/include/cppgc/internal/write-barrier.h
index bfabc31e..80c6ee33 100644
--- a/NativeScript/include/cppgc/internal/write-barrier.h
+++ b/NativeScript/include/cppgc/internal/write-barrier.h
@@ -8,9 +8,12 @@
 #include <cstddef>
 #include <cstdint>
 
+#include "cppgc/heap-handle.h"
 #include "cppgc/heap-state.h"
 #include "cppgc/internal/api-constants.h"
 #include "cppgc/internal/atomic-entry-flag.h"
+#include "cppgc/internal/base-page-handle.h"
+#include "cppgc/internal/member-storage.h"
 #include "cppgc/platform.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/trace-trait.h"
@@ -18,6 +21,7 @@
 
 #if defined(CPPGC_CAGED_HEAP)
 #include "cppgc/internal/caged-heap-local-data.h"
+#include "cppgc/internal/caged-heap.h"
 #endif
 
 namespace cppgc {
@@ -40,16 +44,18 @@ class V8_EXPORT WriteBarrier final {
     kGenerational,
   };
 
+  enum class GenerationalBarrierType : uint8_t {
+    kPreciseSlot,
+    kPreciseUncompressedSlot,
+    kImpreciseSlot,
+  };
+
   struct Params {
     HeapHandle* heap = nullptr;
 #if V8_ENABLE_CHECKS
     Type type = Type::kNone;
 #endif  // !V8_ENABLE_CHECKS
 #if defined(CPPGC_CAGED_HEAP)
-    uintptr_t start = 0;
-    CagedHeapLocalData& caged_heap() const {
-      return *reinterpret_cast<CagedHeapLocalData*>(start);
-    }
     uintptr_t slot_offset = 0;
     uintptr_t value_offset = 0;
 #endif  // CPPGC_CAGED_HEAP
@@ -63,6 +69,9 @@ class V8_EXPORT WriteBarrier final {
   // Returns the required write barrier for a given `slot` and `value`.
   static V8_INLINE Type GetWriteBarrierType(const void* slot, const void* value,
                                             Params& params);
+  // Returns the required write barrier for a given `slot` and `value`.
+  static V8_INLINE Type GetWriteBarrierType(const void* slot, MemberStorage,
+                                            Params& params);
   // Returns the required write barrier for a given `slot`.
   template <typename HeapHandleCallback>
   static V8_INLINE Type GetWriteBarrierType(const void* slot, Params& params,
@@ -70,6 +79,14 @@ class V8_EXPORT WriteBarrier final {
   // Returns the required write barrier for a given  `value`.
   static V8_INLINE Type GetWriteBarrierType(const void* value, Params& params);
 
+#ifdef CPPGC_SLIM_WRITE_BARRIER
+  // A write barrier that combines `GenerationalBarrier()` and
+  // `DijkstraMarkingBarrier()`. We only pass a single parameter here to clobber
+  // as few registers as possible.
+  static V8_NOINLINE void V8_PRESERVE_MOST
+  CombinedWriteBarrierSlow(const void* slot);
+#endif  // CPPGC_SLIM_WRITE_BARRIER
+
   static V8_INLINE void DijkstraMarkingBarrier(const Params& params,
                                                const void* object);
   static V8_INLINE void DijkstraMarkingBarrierRange(
@@ -78,15 +95,13 @@ class V8_EXPORT WriteBarrier final {
   static V8_INLINE void SteeleMarkingBarrier(const Params& params,
                                              const void* object);
 #if defined(CPPGC_YOUNG_GENERATION)
+  template <GenerationalBarrierType>
   static V8_INLINE void GenerationalBarrier(const Params& params,
                                             const void* slot);
-  static V8_INLINE void GenerationalBarrierForSourceObject(
-      const Params& params, const void* inner_pointer);
 #else  // !CPPGC_YOUNG_GENERATION
+  template <GenerationalBarrierType>
   static V8_INLINE void GenerationalBarrier(const Params& params,
-                                            const void* slot) {}
-  static V8_INLINE void GenerationalBarrierForSourceObject(
-      const Params& params, const void* inner_pointer) {}
+                                            const void* slot){}
 #endif  // CPPGC_YOUNG_GENERATION
 
 #if V8_ENABLE_CHECKS
@@ -95,12 +110,10 @@ class V8_EXPORT WriteBarrier final {
   static void CheckParams(Type expected_type, const Params& params) {}
 #endif  // !V8_ENABLE_CHECKS
 
-  // The IncrementalOrConcurrentUpdater class allows cppgc internal to update
-  // |incremental_or_concurrent_marking_flag_|.
-  class IncrementalOrConcurrentMarkingFlagUpdater;
-  static bool IsAnyIncrementalOrConcurrentMarking() {
-    return incremental_or_concurrent_marking_flag_.MightBeEntered();
-  }
+  // The FlagUpdater class allows cppgc internal to update
+  // |write_barrier_enabled_|.
+  class FlagUpdater;
+  static bool IsEnabled() { return write_barrier_enabled_.MightBeEntered(); }
 
  private:
   WriteBarrier() = delete;
@@ -125,17 +138,23 @@ class V8_EXPORT WriteBarrier final {
   static CagedHeapLocalData& GetLocalData(HeapHandle&);
   static void GenerationalBarrierSlow(const CagedHeapLocalData& local_data,
                                       const AgeTable& age_table,
-                                      const void* slot, uintptr_t value_offset);
+                                      const void* slot, uintptr_t value_offset,
+                                      HeapHandle* heap_handle);
+  static void GenerationalBarrierForUncompressedSlotSlow(
+      const CagedHeapLocalData& local_data, const AgeTable& age_table,
+      const void* slot, uintptr_t value_offset, HeapHandle* heap_handle);
   static void GenerationalBarrierForSourceObjectSlow(
-      const CagedHeapLocalData& local_data, const void* object);
+      const CagedHeapLocalData& local_data, const void* object,
+      HeapHandle* heap_handle);
 #endif  // CPPGC_YOUNG_GENERATION
 
-  static AtomicEntryFlag incremental_or_concurrent_marking_flag_;
+  static AtomicEntryFlag write_barrier_enabled_;
 };
 
 template <WriteBarrier::Type type>
 V8_INLINE WriteBarrier::Type SetAndReturnType(WriteBarrier::Params& params) {
-  if (type == WriteBarrier::Type::kNone) return WriteBarrier::Type::kNone;
+  if constexpr (type == WriteBarrier::Type::kNone)
+    return WriteBarrier::Type::kNone;
 #if V8_ENABLE_CHECKS
   params.type = type;
 #endif  // !V8_ENABLE_CHECKS
@@ -152,6 +171,13 @@ class V8_EXPORT WriteBarrierTypeForCagedHeapPolicy final {
     return ValueModeDispatch<value_mode>::Get(slot, value, params, callback);
   }
 
+  template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void* slot, MemberStorage value,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback callback) {
+    return ValueModeDispatch<value_mode>::Get(slot, value, params, callback);
+  }
+
   template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
   static V8_INLINE WriteBarrier::Type Get(const void* value,
                                           WriteBarrier::Params& params,
@@ -166,69 +192,77 @@ class V8_EXPORT WriteBarrierTypeForCagedHeapPolicy final {
   static V8_INLINE WriteBarrier::Type GetNoSlot(const void* value,
                                                 WriteBarrier::Params& params,
                                                 HeapHandleCallback) {
-    if (!TryGetCagedHeap(value, value, params)) {
-      return WriteBarrier::Type::kNone;
-    }
-    if (V8_UNLIKELY(params.caged_heap().is_incremental_marking_in_progress)) {
+    const bool within_cage = CagedHeapBase::IsWithinCage(value);
+    if (!within_cage) return WriteBarrier::Type::kNone;
+
+    // We know that |value| points either within the normal page or to the
+    // beginning of large-page, so extract the page header by bitmasking.
+    BasePageHandle* page =
+        BasePageHandle::FromPayload(const_cast<void*>(value));
+
+    HeapHandle& heap_handle = page->heap_handle();
+    if (V8_UNLIKELY(heap_handle.is_incremental_marking_in_progress())) {
       return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
     }
+
     return SetAndReturnType<WriteBarrier::Type::kNone>(params);
   }
 
   template <WriteBarrier::ValueMode value_mode>
   struct ValueModeDispatch;
-
-  static V8_INLINE bool TryGetCagedHeap(const void* slot, const void* value,
-                                        WriteBarrier::Params& params) {
-    // TODO(chromium:1056170): Check if the null check can be folded in with
-    // the rest of the write barrier.
-    if (!value) return false;
-    params.start = reinterpret_cast<uintptr_t>(value) &
-                   ~(api_constants::kCagedHeapReservationAlignment - 1);
-    const uintptr_t slot_offset =
-        reinterpret_cast<uintptr_t>(slot) - params.start;
-    if (slot_offset > api_constants::kCagedHeapReservationSize) {
-      // Check if slot is on stack or value is sentinel or nullptr. This relies
-      // on the fact that kSentinelPointer is encoded as 0x1.
-      return false;
-    }
-    return true;
-  }
-
-  // Returns whether marking is in progress. If marking is not in progress
-  // sets the start of the cage accordingly.
-  //
-  // TODO(chromium:1056170): Create fast path on API.
-  static bool IsMarking(const HeapHandle&, WriteBarrier::Params&);
 };
 
 template <>
 struct WriteBarrierTypeForCagedHeapPolicy::ValueModeDispatch<
     WriteBarrier::ValueMode::kValuePresent> {
+  template <typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void* slot,
+                                          MemberStorage storage,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback) {
+    if (V8_LIKELY(!WriteBarrier::IsEnabled()))
+      return SetAndReturnType<WriteBarrier::Type::kNone>(params);
+
+    return BarrierEnabledGet(slot, storage.Load(), params);
+  }
+
   template <typename HeapHandleCallback>
   static V8_INLINE WriteBarrier::Type Get(const void* slot, const void* value,
                                           WriteBarrier::Params& params,
                                           HeapHandleCallback) {
-#if !defined(CPPGC_YOUNG_GENERATION)
-    if (V8_LIKELY(!WriteBarrier::IsAnyIncrementalOrConcurrentMarking())) {
+    if (V8_LIKELY(!WriteBarrier::IsEnabled()))
       return SetAndReturnType<WriteBarrier::Type::kNone>(params);
-    }
-#endif  // !CPPGC_YOUNG_GENERATION
-    bool within_cage = TryGetCagedHeap(slot, value, params);
-    if (!within_cage) {
-      return WriteBarrier::Type::kNone;
-    }
-    if (V8_LIKELY(!params.caged_heap().is_incremental_marking_in_progress)) {
+
+    return BarrierEnabledGet(slot, value, params);
+  }
+
+ private:
+  static V8_INLINE WriteBarrier::Type BarrierEnabledGet(
+      const void* slot, const void* value, WriteBarrier::Params& params) {
+    const bool within_cage = CagedHeapBase::AreWithinCage(slot, value);
+    if (!within_cage) return WriteBarrier::Type::kNone;
+
+    // We know that |value| points either within the normal page or to the
+    // beginning of large-page, so extract the page header by bitmasking.
+    BasePageHandle* page =
+        BasePageHandle::FromPayload(const_cast<void*>(value));
+
+    HeapHandle& heap_handle = page->heap_handle();
+    if (V8_LIKELY(!heap_handle.is_incremental_marking_in_progress())) {
 #if defined(CPPGC_YOUNG_GENERATION)
-      params.heap = reinterpret_cast<HeapHandle*>(params.start);
-      params.slot_offset = reinterpret_cast<uintptr_t>(slot) - params.start;
-      params.value_offset = reinterpret_cast<uintptr_t>(value) - params.start;
+      if (!heap_handle.is_young_generation_enabled())
+        return WriteBarrier::Type::kNone;
+      params.heap = &heap_handle;
+      params.slot_offset = CagedHeapBase::OffsetFromAddress(slot);
+      params.value_offset = CagedHeapBase::OffsetFromAddress(value);
       return SetAndReturnType<WriteBarrier::Type::kGenerational>(params);
 #else   // !CPPGC_YOUNG_GENERATION
       return SetAndReturnType<WriteBarrier::Type::kNone>(params);
 #endif  // !CPPGC_YOUNG_GENERATION
     }
-    params.heap = reinterpret_cast<HeapHandle*>(params.start);
+
+    // Use marking barrier.
+    params.heap = &heap_handle;
     return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
   }
 };
@@ -240,28 +274,28 @@ struct WriteBarrierTypeForCagedHeapPolicy::ValueModeDispatch<
   static V8_INLINE WriteBarrier::Type Get(const void* slot, const void*,
                                           WriteBarrier::Params& params,
                                           HeapHandleCallback callback) {
-#if defined(CPPGC_YOUNG_GENERATION)
+    if (V8_LIKELY(!WriteBarrier::IsEnabled()))
+      return SetAndReturnType<WriteBarrier::Type::kNone>(params);
+
     HeapHandle& handle = callback();
-    if (V8_LIKELY(!IsMarking(handle, params))) {
-      // params.start is populated by IsMarking().
+#if defined(CPPGC_YOUNG_GENERATION)
+    if (V8_LIKELY(!handle.is_incremental_marking_in_progress())) {
+      if (!handle.is_young_generation_enabled()) {
+        return WriteBarrier::Type::kNone;
+      }
       params.heap = &handle;
-      params.slot_offset = reinterpret_cast<uintptr_t>(slot) - params.start;
-      // params.value_offset stays 0.
-      if (params.slot_offset > api_constants::kCagedHeapReservationSize) {
-        // Check if slot is on stack.
+      // Check if slot is on stack.
+      if (V8_UNLIKELY(!CagedHeapBase::IsWithinCage(slot))) {
         return SetAndReturnType<WriteBarrier::Type::kNone>(params);
       }
+      params.slot_offset = CagedHeapBase::OffsetFromAddress(slot);
       return SetAndReturnType<WriteBarrier::Type::kGenerational>(params);
     }
-#else   // !CPPGC_YOUNG_GENERATION
-    if (V8_LIKELY(!WriteBarrier::IsAnyIncrementalOrConcurrentMarking())) {
-      return SetAndReturnType<WriteBarrier::Type::kNone>(params);
-    }
-    HeapHandle& handle = callback();
-    if (V8_UNLIKELY(!subtle::HeapState::IsMarking(handle))) {
+#else   // !defined(CPPGC_YOUNG_GENERATION)
+    if (V8_UNLIKELY(!handle.is_incremental_marking_in_progress())) {
       return SetAndReturnType<WriteBarrier::Type::kNone>(params);
     }
-#endif  // !CPPGC_YOUNG_GENERATION
+#endif  // !defined(CPPGC_YOUNG_GENERATION)
     params.heap = &handle;
     return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
   }
@@ -278,6 +312,16 @@ class V8_EXPORT WriteBarrierTypeForNonCagedHeapPolicy final {
     return ValueModeDispatch<value_mode>::Get(slot, value, params, callback);
   }
 
+  template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
+  static V8_INLINE WriteBarrier::Type Get(const void* slot, MemberStorage value,
+                                          WriteBarrier::Params& params,
+                                          HeapHandleCallback callback) {
+    // `MemberStorage` will always be `RawPointer` for non-caged heap builds.
+    // Just convert to `void*` in this case.
+    return ValueModeDispatch<value_mode>::Get(slot, value.Load(), params,
+                                              callback);
+  }
+
   template <WriteBarrier::ValueMode value_mode, typename HeapHandleCallback>
   static V8_INLINE WriteBarrier::Type Get(const void* value,
                                           WriteBarrier::Params& params,
@@ -291,11 +335,6 @@ class V8_EXPORT WriteBarrierTypeForNonCagedHeapPolicy final {
   template <WriteBarrier::ValueMode value_mode>
   struct ValueModeDispatch;
 
-  // TODO(chromium:1056170): Create fast path on API.
-  static bool IsMarking(const void*, HeapHandle**);
-  // TODO(chromium:1056170): Create fast path on API.
-  static bool IsMarking(HeapHandle&);
-
   WriteBarrierTypeForNonCagedHeapPolicy() = delete;
 };
 
@@ -310,10 +349,16 @@ struct WriteBarrierTypeForNonCagedHeapPolicy::ValueModeDispatch<
     if (object <= static_cast<void*>(kSentinelPointer)) {
       return SetAndReturnType<WriteBarrier::Type::kNone>(params);
     }
-    if (V8_LIKELY(!WriteBarrier::IsAnyIncrementalOrConcurrentMarking())) {
+    if (V8_LIKELY(!WriteBarrier::IsEnabled())) {
       return SetAndReturnType<WriteBarrier::Type::kNone>(params);
     }
-    if (IsMarking(object, &params.heap)) {
+    // We know that |object| is within the normal page or in the beginning of a
+    // large page, so extract the page header by bitmasking.
+    BasePageHandle* page =
+        BasePageHandle::FromPayload(const_cast<void*>(object));
+
+    HeapHandle& heap_handle = page->heap_handle();
+    if (V8_LIKELY(heap_handle.is_incremental_marking_in_progress())) {
       return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
     }
     return SetAndReturnType<WriteBarrier::Type::kNone>(params);
@@ -327,9 +372,9 @@ struct WriteBarrierTypeForNonCagedHeapPolicy::ValueModeDispatch<
   static V8_INLINE WriteBarrier::Type Get(const void*, const void*,
                                           WriteBarrier::Params& params,
                                           HeapHandleCallback callback) {
-    if (V8_UNLIKELY(WriteBarrier::IsAnyIncrementalOrConcurrentMarking())) {
+    if (V8_UNLIKELY(WriteBarrier::IsEnabled())) {
       HeapHandle& handle = callback();
-      if (IsMarking(handle)) {
+      if (V8_LIKELY(handle.is_incremental_marking_in_progress())) {
         params.heap = &handle;
         return SetAndReturnType<WriteBarrier::Type::kMarking>(params);
       }
@@ -345,6 +390,13 @@ WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
                                                                params, []() {});
 }
 
+// static
+WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
+    const void* slot, MemberStorage value, WriteBarrier::Params& params) {
+  return WriteBarrierTypePolicy::Get<ValueMode::kValuePresent>(slot, value,
+                                                               params, []() {});
+}
+
 // static
 template <typename HeapHandleCallback>
 WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
@@ -397,34 +449,32 @@ void WriteBarrier::SteeleMarkingBarrier(const Params& params,
 }
 
 #if defined(CPPGC_YOUNG_GENERATION)
-// static
-void WriteBarrier::GenerationalBarrier(const Params& params, const void* slot) {
-  CheckParams(Type::kGenerational, params);
-
-  const CagedHeapLocalData& local_data = params.caged_heap();
-  const AgeTable& age_table = local_data.age_table;
-
-  // Bail out if the slot is in young generation.
-  if (V8_LIKELY(age_table.GetAge(params.slot_offset) == AgeTable::Age::kYoung))
-    return;
-
-  GenerationalBarrierSlow(local_data, age_table, slot, params.value_offset);
-}
 
 // static
-void WriteBarrier::GenerationalBarrierForSourceObject(
-    const Params& params, const void* inner_pointer) {
+template <WriteBarrier::GenerationalBarrierType type>
+void WriteBarrier::GenerationalBarrier(const Params& params, const void* slot) {
   CheckParams(Type::kGenerational, params);
 
-  const CagedHeapLocalData& local_data = params.caged_heap();
+  const CagedHeapLocalData& local_data = CagedHeapLocalData::Get();
   const AgeTable& age_table = local_data.age_table;
 
-  // Assume that if the first element is in young generation, the whole range is
-  // in young generation.
+  // Bail out if the slot (precise or imprecise) is in young generation.
   if (V8_LIKELY(age_table.GetAge(params.slot_offset) == AgeTable::Age::kYoung))
     return;
 
-  GenerationalBarrierForSourceObjectSlow(local_data, inner_pointer);
+  // Dispatch between different types of barriers.
+  // TODO(chromium:1029379): Consider reload local_data in the slow path to
+  // reduce register pressure.
+  if constexpr (type == GenerationalBarrierType::kPreciseSlot) {
+    GenerationalBarrierSlow(local_data, age_table, slot, params.value_offset,
+                            params.heap);
+  } else if constexpr (type ==
+                       GenerationalBarrierType::kPreciseUncompressedSlot) {
+    GenerationalBarrierForUncompressedSlotSlow(
+        local_data, age_table, slot, params.value_offset, params.heap);
+  } else {
+    GenerationalBarrierForSourceObjectSlow(local_data, slot, params.heap);
+  }
 }
 
 #endif  // !CPPGC_YOUNG_GENERATION
diff --git a/NativeScript/include/cppgc/liveness-broker.h b/NativeScript/include/cppgc/liveness-broker.h
index c94eef0d..2c94f1c0 100644
--- a/NativeScript/include/cppgc/liveness-broker.h
+++ b/NativeScript/include/cppgc/liveness-broker.h
@@ -7,6 +7,7 @@
 
 #include "cppgc/heap.h"
 #include "cppgc/member.h"
+#include "cppgc/sentinel-pointer.h"
 #include "cppgc/trace-trait.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
@@ -44,24 +45,24 @@ class V8_EXPORT LivenessBroker final {
  public:
   template <typename T>
   bool IsHeapObjectAlive(const T* object) const {
-    // nullptr objects are considered alive to allow weakness to be used from
+    // - nullptr objects are considered alive to allow weakness to be used from
     // stack while running into a conservative GC. Treating nullptr as dead
-    // would mean that e.g. custom collectins could not be strongified on stack.
-    return !object ||
+    // would mean that e.g. custom collections could not be strongified on
+    // stack.
+    // - Sentinel pointers are also preserved in weakness and not cleared.
+    return !object || object == kSentinelPointer ||
            IsHeapObjectAliveImpl(
                TraceTrait<T>::GetTraceDescriptor(object).base_object_payload);
   }
 
   template <typename T>
   bool IsHeapObjectAlive(const WeakMember<T>& weak_member) const {
-    return (weak_member != kSentinelPointer) &&
-           IsHeapObjectAlive<T>(weak_member.Get());
+    return IsHeapObjectAlive<T>(weak_member.Get());
   }
 
   template <typename T>
   bool IsHeapObjectAlive(const UntracedMember<T>& untraced_member) const {
-    return (untraced_member != kSentinelPointer) &&
-           IsHeapObjectAlive<T>(untraced_member.Get());
+    return IsHeapObjectAlive<T>(untraced_member.Get());
   }
 
  private:
diff --git a/NativeScript/include/cppgc/member.h b/NativeScript/include/cppgc/member.h
index 66a8cfd8..9bc38363 100644
--- a/NativeScript/include/cppgc/member.h
+++ b/NativeScript/include/cppgc/member.h
@@ -9,6 +9,8 @@
 #include <cstddef>
 #include <type_traits>
 
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/pointer-policies.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/type-traits.h"
@@ -16,177 +18,247 @@
 
 namespace cppgc {
 
+namespace subtle {
+class HeapConsistency;
+}  // namespace subtle
+
 class Visitor;
 
 namespace internal {
 
 // MemberBase always refers to the object as const object and defers to
 // BasicMember on casting to the right type as needed.
-class MemberBase {
+class V8_TRIVIAL_ABI MemberBase {
+ public:
+#if defined(CPPGC_POINTER_COMPRESSION)
+  using RawStorage = CompressedPointer;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+  using RawStorage = RawPointer;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
  protected:
   struct AtomicInitializerTag {};
 
-  MemberBase() : raw_(nullptr) {}
-  explicit MemberBase(const void* value) : raw_(value) {}
-  MemberBase(const void* value, AtomicInitializerTag) { SetRawAtomic(value); }
+  V8_INLINE MemberBase() = default;
+  V8_INLINE explicit MemberBase(const void* value) : raw_(value) {}
+  V8_INLINE MemberBase(const void* value, AtomicInitializerTag) {
+    SetRawAtomic(value);
+  }
 
-  const void** GetRawSlot() const { return &raw_; }
-  const void* GetRaw() const { return raw_; }
-  void SetRaw(void* value) { raw_ = value; }
+  V8_INLINE explicit MemberBase(RawStorage raw) : raw_(raw) {}
+  V8_INLINE explicit MemberBase(std::nullptr_t) : raw_(nullptr) {}
+  V8_INLINE explicit MemberBase(SentinelPointer s) : raw_(s) {}
 
-  const void* GetRawAtomic() const {
-    return reinterpret_cast<const std::atomic<const void*>*>(&raw_)->load(
-        std::memory_order_relaxed);
+  V8_INLINE const void** GetRawSlot() const {
+    return reinterpret_cast<const void**>(const_cast<MemberBase*>(this));
   }
-  void SetRawAtomic(const void* value) {
-    reinterpret_cast<std::atomic<const void*>*>(&raw_)->store(
-        value, std::memory_order_relaxed);
+  V8_INLINE const void* GetRaw() const { return raw_.Load(); }
+  V8_INLINE void SetRaw(void* value) { raw_.Store(value); }
+
+  V8_INLINE const void* GetRawAtomic() const { return raw_.LoadAtomic(); }
+  V8_INLINE void SetRawAtomic(const void* value) { raw_.StoreAtomic(value); }
+
+  V8_INLINE RawStorage GetRawStorage() const { return raw_; }
+  V8_INLINE void SetRawStorageAtomic(RawStorage other) {
+    reinterpret_cast<std::atomic<RawStorage>&>(raw_).store(
+        other, std::memory_order_relaxed);
   }
 
-  void ClearFromGC() const { raw_ = nullptr; }
+  V8_INLINE bool IsCleared() const { return raw_.IsCleared(); }
+
+  V8_INLINE void ClearFromGC() const { raw_.Clear(); }
 
  private:
-  // All constructors initialize `raw_`. Do not add a default value here as it
-  // results in a non-atomic write on some builds, even when the atomic version
-  // of the constructor is used.
-  mutable const void* raw_;
+  friend class MemberDebugHelper;
+
+  mutable RawStorage raw_;
 };
 
 // The basic class from which all Member classes are 'generated'.
 template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
           typename CheckingPolicy>
-class BasicMember final : private MemberBase, private CheckingPolicy {
+class V8_TRIVIAL_ABI BasicMember final : private MemberBase,
+                                         private CheckingPolicy {
  public:
   using PointeeType = T;
 
-  constexpr BasicMember() = default;
-  constexpr BasicMember(std::nullptr_t) {}     // NOLINT
-  BasicMember(SentinelPointer s) : MemberBase(s) {}  // NOLINT
-  BasicMember(T* raw) : MemberBase(raw) {            // NOLINT
-    InitializingWriteBarrier();
+  V8_INLINE constexpr BasicMember() = default;
+  V8_INLINE constexpr BasicMember(std::nullptr_t) {}           // NOLINT
+  V8_INLINE BasicMember(SentinelPointer s) : MemberBase(s) {}  // NOLINT
+  V8_INLINE BasicMember(T* raw) : MemberBase(raw) {            // NOLINT
+    InitializingWriteBarrier(raw);
     this->CheckPointer(Get());
   }
-  BasicMember(T& raw) : BasicMember(&raw) {}  // NOLINT
+  V8_INLINE BasicMember(T& raw)  // NOLINT
+      : BasicMember(&raw) {}
+
   // Atomic ctor. Using the AtomicInitializerTag forces BasicMember to
   // initialize using atomic assignments. This is required for preventing
   // data races with concurrent marking.
   using AtomicInitializerTag = MemberBase::AtomicInitializerTag;
-  BasicMember(std::nullptr_t, AtomicInitializerTag atomic)
+  V8_INLINE BasicMember(std::nullptr_t, AtomicInitializerTag atomic)
       : MemberBase(nullptr, atomic) {}
-  BasicMember(SentinelPointer s, AtomicInitializerTag atomic)
+  V8_INLINE BasicMember(SentinelPointer s, AtomicInitializerTag atomic)
       : MemberBase(s, atomic) {}
-  BasicMember(T* raw, AtomicInitializerTag atomic) : MemberBase(raw, atomic) {
-    InitializingWriteBarrier();
+  V8_INLINE BasicMember(T* raw, AtomicInitializerTag atomic)
+      : MemberBase(raw, atomic) {
+    InitializingWriteBarrier(raw);
     this->CheckPointer(Get());
   }
-  BasicMember(T& raw, AtomicInitializerTag atomic)
+  V8_INLINE BasicMember(T& raw, AtomicInitializerTag atomic)
       : BasicMember(&raw, atomic) {}
+
   // Copy ctor.
-  BasicMember(const BasicMember& other) : BasicMember(other.Get()) {}
-  // Allow heterogeneous construction.
+  V8_INLINE BasicMember(const BasicMember& other)
+      : BasicMember(other.GetRawStorage()) {}
+
+  // Heterogeneous copy constructors. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(  // NOLINT
+            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(  // NOLINT
+      const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                        OtherCheckingPolicy>& other)
+      : BasicMember(other.GetRawStorage()) {}
+
+  template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
+            typename OtherCheckingPolicy,
+            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy>& other)
       : BasicMember(other.Get()) {}
+
   // Move ctor.
-  BasicMember(BasicMember&& other) noexcept : BasicMember(other.Get()) {
+  V8_INLINE BasicMember(BasicMember&& other) noexcept
+      : BasicMember(other.GetRawStorage()) {
     other.Clear();
   }
-  // Allow heterogeneous move construction.
+
+  // Heterogeneous move constructors. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                          OtherCheckingPolicy>&& other) noexcept
+            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                                    OtherCheckingPolicy>&& other) noexcept
+      : BasicMember(other.GetRawStorage()) {
+    other.Clear();
+  }
+
+  template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
+            typename OtherCheckingPolicy,
+            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+  V8_INLINE BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                                    OtherCheckingPolicy>&& other) noexcept
       : BasicMember(other.Get()) {
     other.Clear();
   }
+
   // Construction from Persistent.
   template <typename U, typename PersistentWeaknessPolicy,
             typename PersistentLocationPolicy,
             typename PersistentCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(const BasicPersistent<U, PersistentWeaknessPolicy,
-                                    PersistentLocationPolicy,
-                                    PersistentCheckingPolicy>& p)
+  V8_INLINE BasicMember(const BasicPersistent<U, PersistentWeaknessPolicy,
+                                              PersistentLocationPolicy,
+                                              PersistentCheckingPolicy>& p)
       : BasicMember(p.Get()) {}
 
   // Copy assignment.
-  BasicMember& operator=(const BasicMember& other) {
-    return operator=(other.Get());
+  V8_INLINE BasicMember& operator=(const BasicMember& other) {
+    return operator=(other.GetRawStorage());
   }
-  // Allow heterogeneous copy assignment.
+
+  // Heterogeneous copy assignment. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(
+            typename OtherCheckingPolicy>
+  V8_INLINE BasicMember& operator=(
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy>& other) {
-    return operator=(other.Get());
+    if constexpr (internal::IsDecayedSameV<T, U>) {
+      return operator=(other.GetRawStorage());
+    } else {
+      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      return operator=(other.Get());
+    }
   }
+
   // Move assignment.
-  BasicMember& operator=(BasicMember&& other) noexcept {
-    operator=(other.Get());
+  V8_INLINE BasicMember& operator=(BasicMember&& other) noexcept {
+    operator=(other.GetRawStorage());
     other.Clear();
     return *this;
   }
-  // Heterogeneous move assignment.
+
+  // Heterogeneous move assignment. When the source pointer have a different
+  // type, perform a compress-decompress round, because the source pointer may
+  // need to be adjusted.
   template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                                     OtherCheckingPolicy>&& other) noexcept {
-    operator=(other.Get());
+            typename OtherCheckingPolicy>
+  V8_INLINE BasicMember& operator=(
+      BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                  OtherCheckingPolicy>&& other) noexcept {
+    if constexpr (internal::IsDecayedSameV<T, U>) {
+      operator=(other.GetRawStorage());
+    } else {
+      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      operator=(other.Get());
+    }
     other.Clear();
     return *this;
   }
+
   // Assignment from Persistent.
   template <typename U, typename PersistentWeaknessPolicy,
             typename PersistentLocationPolicy,
             typename PersistentCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(
+  V8_INLINE BasicMember& operator=(
       const BasicPersistent<U, PersistentWeaknessPolicy,
                             PersistentLocationPolicy, PersistentCheckingPolicy>&
           other) {
     return operator=(other.Get());
   }
-  BasicMember& operator=(T* other) {
+
+  V8_INLINE BasicMember& operator=(T* other) {
     SetRawAtomic(other);
-    AssigningWriteBarrier();
+    AssigningWriteBarrier(other);
     this->CheckPointer(Get());
     return *this;
   }
-  BasicMember& operator=(std::nullptr_t) {
+
+  V8_INLINE BasicMember& operator=(std::nullptr_t) {
     Clear();
     return *this;
   }
-  BasicMember& operator=(SentinelPointer s) {
+  V8_INLINE BasicMember& operator=(SentinelPointer s) {
     SetRawAtomic(s);
     return *this;
   }
 
   template <typename OtherWeaknessTag, typename OtherBarrierPolicy,
             typename OtherCheckingPolicy>
-  void Swap(BasicMember<T, OtherWeaknessTag, OtherBarrierPolicy,
-                        OtherCheckingPolicy>& other) {
-    T* tmp = Get();
+  V8_INLINE void Swap(BasicMember<T, OtherWeaknessTag, OtherBarrierPolicy,
+                                  OtherCheckingPolicy>& other) {
+    auto tmp = GetRawStorage();
     *this = other;
     other = tmp;
   }
 
-  explicit operator bool() const { return Get(); }
-  operator T*() const { return Get(); }
-  T* operator->() const { return Get(); }
-  T& operator*() const { return *Get(); }
+  V8_INLINE explicit operator bool() const { return !IsCleared(); }
+  V8_INLINE operator T*() const { return Get(); }
+  V8_INLINE T* operator->() const { return Get(); }
+  V8_INLINE T& operator*() const { return *Get(); }
 
   // CFI cast exemption to allow passing SentinelPointer through T* and support
   // heterogeneous assignments between different Member and Persistent handles
   // based on their actual types.
-  V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
+  V8_INLINE V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
     // Executed by the mutator, hence non atomic load.
     //
     // The const_cast below removes the constness from MemberBase storage. The
@@ -195,59 +267,262 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
     return static_cast<T*>(const_cast<void*>(MemberBase::GetRaw()));
   }
 
-  void Clear() { SetRawAtomic(nullptr); }
+  V8_INLINE void Clear() { SetRawStorageAtomic(RawStorage{}); }
 
-  T* Release() {
+  V8_INLINE T* Release() {
     T* result = Get();
     Clear();
     return result;
   }
 
-  const T** GetSlotForTesting() const {
+  V8_INLINE const T** GetSlotForTesting() const {
     return reinterpret_cast<const T**>(GetRawSlot());
   }
 
+  V8_INLINE RawStorage GetRawStorage() const {
+    return MemberBase::GetRawStorage();
+  }
+
  private:
-  const T* GetRawAtomic() const {
+  V8_INLINE explicit BasicMember(RawStorage raw) : MemberBase(raw) {
+    InitializingWriteBarrier(Get());
+    this->CheckPointer(Get());
+  }
+
+  V8_INLINE BasicMember& operator=(RawStorage other) {
+    SetRawStorageAtomic(other);
+    AssigningWriteBarrier();
+    this->CheckPointer(Get());
+    return *this;
+  }
+
+  V8_INLINE const T* GetRawAtomic() const {
     return static_cast<const T*>(MemberBase::GetRawAtomic());
   }
 
-  void InitializingWriteBarrier() const {
-    WriteBarrierPolicy::InitializingBarrier(GetRawSlot(), GetRaw());
+  V8_INLINE void InitializingWriteBarrier(T* value) const {
+    WriteBarrierPolicy::InitializingBarrier(GetRawSlot(), value);
   }
-  void AssigningWriteBarrier() const {
-    WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), GetRaw());
+  V8_INLINE void AssigningWriteBarrier(T* value) const {
+    WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), value);
+  }
+  V8_INLINE void AssigningWriteBarrier() const {
+    WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), GetRawStorage());
   }
 
-  void ClearFromGC() const { MemberBase::ClearFromGC(); }
+  V8_INLINE void ClearFromGC() const { MemberBase::ClearFromGC(); }
 
-  T* GetFromGC() const { return Get(); }
+  V8_INLINE T* GetFromGC() const { return Get(); }
 
+  friend class cppgc::subtle::HeapConsistency;
   friend class cppgc::Visitor;
   template <typename U>
   friend struct cppgc::TraceTrait;
+  template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+            typename CheckingPolicy1>
+  friend class BasicMember;
 };
 
+// Member equality operators.
 template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
           typename CheckingPolicy1, typename T2, typename WeaknessTag2,
           typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator==(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
-                                  CheckingPolicy1>& member1,
-                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
-                                  CheckingPolicy2>& member2) {
-  return member1.Get() == member2.Get();
+V8_INLINE bool operator==(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  if constexpr (internal::IsDecayedSameV<T1, T2>) {
+    // Check compressed pointers if types are the same.
+    return member1.GetRawStorage() == member2.GetRawStorage();
+  } else {
+    static_assert(internal::IsStrictlyBaseOfV<T1, T2> ||
+                  internal::IsStrictlyBaseOfV<T2, T1>);
+    // Otherwise, check decompressed pointers.
+    return member1.Get() == member2.Get();
+  }
 }
 
 template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
           typename CheckingPolicy1, typename T2, typename WeaknessTag2,
           typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator!=(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
-                                  CheckingPolicy1>& member1,
-                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
-                                  CheckingPolicy2>& member2) {
+V8_INLINE bool operator!=(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
   return !(member1 == member2);
 }
 
+// Equality with raw pointers.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename U>
+V8_INLINE bool operator==(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          U* raw) {
+  // Never allow comparison with erased pointers.
+  static_assert(!internal::IsDecayedSameV<void, U>);
+
+  if constexpr (internal::IsDecayedSameV<T, U>) {
+    // Check compressed pointers if types are the same.
+    return member.GetRawStorage() == MemberBase::RawStorage(raw);
+  } else if constexpr (internal::IsStrictlyBaseOfV<T, U>) {
+    // Cast the raw pointer to T, which may adjust the pointer.
+    return member.GetRawStorage() ==
+           MemberBase::RawStorage(static_cast<T*>(raw));
+  } else {
+    // Otherwise, decompressed the member.
+    return member.Get() == raw;
+  }
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename U>
+V8_INLINE bool operator!=(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          U* raw) {
+  return !(member == raw);
+}
+
+template <typename T, typename U, typename WeaknessTag,
+          typename WriteBarrierPolicy, typename CheckingPolicy>
+V8_INLINE bool operator==(T* raw,
+                          const BasicMember<U, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return member == raw;
+}
+
+template <typename T, typename U, typename WeaknessTag,
+          typename WriteBarrierPolicy, typename CheckingPolicy>
+V8_INLINE bool operator!=(T* raw,
+                          const BasicMember<U, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return !(raw == member);
+}
+
+// Equality with sentinel.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          SentinelPointer) {
+  return member.GetRawStorage().IsSentinel();
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          SentinelPointer s) {
+  return !(member == s);
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(SentinelPointer s,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return member == s;
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(SentinelPointer s,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return !(s == member);
+}
+
+// Equality with nullptr.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          std::nullptr_t) {
+  return !static_cast<bool>(member);
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member,
+                          std::nullptr_t n) {
+  return !(member == n);
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator==(std::nullptr_t n,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return member == n;
+}
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy>
+V8_INLINE bool operator!=(std::nullptr_t n,
+                          const BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                            CheckingPolicy>& member) {
+  return !(n == member);
+}
+
+// Relational operators.
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator<(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::IsDecayedSameV<T1, T2>,
+      "Comparison works only for same pointer type modulo cv-qualifiers");
+  return member1.GetRawStorage() < member2.GetRawStorage();
+}
+
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator<=(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::IsDecayedSameV<T1, T2>,
+      "Comparison works only for same pointer type modulo cv-qualifiers");
+  return member1.GetRawStorage() <= member2.GetRawStorage();
+}
+
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator>(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::IsDecayedSameV<T1, T2>,
+      "Comparison works only for same pointer type modulo cv-qualifiers");
+  return member1.GetRawStorage() > member2.GetRawStorage();
+}
+
+template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
+          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
+          typename WriteBarrierPolicy2, typename CheckingPolicy2>
+V8_INLINE bool operator>=(
+    const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1, CheckingPolicy1>&
+        member1,
+    const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2>&
+        member2) {
+  static_assert(
+      internal::IsDecayedSameV<T1, T2>,
+      "Comparison works only for same pointer type modulo cv-qualifiers");
+  return member1.GetRawStorage() >= member2.GetRawStorage();
+}
+
 template <typename T, typename WriteBarrierPolicy, typename CheckingPolicy>
 struct IsWeak<
     internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy>>
diff --git a/NativeScript/include/cppgc/name-provider.h b/NativeScript/include/cppgc/name-provider.h
index 224dd4b5..216f6098 100644
--- a/NativeScript/include/cppgc/name-provider.h
+++ b/NativeScript/include/cppgc/name-provider.h
@@ -37,15 +37,15 @@ class V8_EXPORT NameProvider {
   static constexpr const char kNoNameDeducible[] = "<No name>";
 
   /**
-   * Indicating whether internal names are hidden or not.
+   * Indicating whether the build supports extracting C++ names as object names.
    *
    * @returns true if C++ names should be hidden and represented by kHiddenName.
    */
-  static constexpr bool HideInternalNames() {
+  static constexpr bool SupportsCppClassNamesAsObjectNames() {
 #if CPPGC_SUPPORTS_OBJECT_NAMES
-    return false;
-#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
     return true;
+#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
+    return false;
 #endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
   }
 
diff --git a/NativeScript/include/cppgc/persistent.h b/NativeScript/include/cppgc/persistent.h
index 244f94c8..3a66ccc0 100644
--- a/NativeScript/include/cppgc/persistent.h
+++ b/NativeScript/include/cppgc/persistent.h
@@ -16,9 +16,6 @@
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
-
-class Visitor;
-
 namespace internal {
 
 // PersistentBase always refers to the object as const object and defers to
@@ -78,7 +75,7 @@ class BasicPersistent final : public PersistentBase,
       : PersistentBase(raw), LocationPolicy(loc) {
     if (!IsValid()) return;
     SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())
-                .AllocateNode(this, &BasicPersistent::Trace));
+                .AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(Get());
   }
 
@@ -221,9 +218,8 @@ class BasicPersistent final : public PersistentBase,
   }
 
  private:
-  static void Trace(Visitor* v, const void* ptr) {
-    const auto* persistent = static_cast<const BasicPersistent*>(ptr);
-    v->TraceRoot(*persistent, persistent->Location());
+  static void TraceAsRoot(RootVisitor& root_visitor, const void* ptr) {
+    root_visitor.Trace(*static_cast<const BasicPersistent*>(ptr));
   }
 
   bool IsValid() const {
@@ -247,7 +243,7 @@ class BasicPersistent final : public PersistentBase,
     SetValue(ptr);
     if (!IsValid()) return;
     SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())
-                .AllocateNode(this, &BasicPersistent::Trace));
+                .AllocateNode(this, &TraceAsRoot));
     this->CheckPointer(Get());
   }
 
@@ -264,7 +260,7 @@ class BasicPersistent final : public PersistentBase,
     return static_cast<T*>(const_cast<void*>(GetValue()));
   }
 
-  friend class cppgc::Visitor;
+  friend class internal::RootVisitor;
 };
 
 template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,
diff --git a/NativeScript/include/cppgc/platform.h b/NativeScript/include/cppgc/platform.h
index 5d5f8796..5a0a40ec 100644
--- a/NativeScript/include/cppgc/platform.h
+++ b/NativeScript/include/cppgc/platform.h
@@ -33,8 +33,9 @@ class V8_EXPORT Platform {
   virtual ~Platform() = default;
 
   /**
-   * Returns the allocator used by cppgc to allocate its heap and various
-   * support structures.
+   * \returns the allocator used by cppgc to allocate its heap and various
+   * support structures. Returning nullptr results in using the `PageAllocator`
+   * provided by `cppgc::InitializeProcess()` instead.
    */
   virtual PageAllocator* GetPageAllocator() = 0;
 
@@ -132,10 +133,11 @@ class V8_EXPORT Platform {
  *
  * Can be called multiple times when paired with `ShutdownProcess()`.
  *
- * \param page_allocator The allocator used for maintaining meta data. Must not
- *   change between multiple calls to InitializeProcess.
+ * \param page_allocator The allocator used for maintaining meta data. Must stay
+ *   always alive and not change between multiple calls to InitializeProcess. If
+ *   no allocator is provided, a default internal version will be used.
  */
-V8_EXPORT void InitializeProcess(PageAllocator* page_allocator);
+V8_EXPORT void InitializeProcess(PageAllocator* page_allocator = nullptr);
 
 /**
  * Must be called after destroying the last used heap. Some process-global
diff --git a/NativeScript/include/cppgc/sentinel-pointer.h b/NativeScript/include/cppgc/sentinel-pointer.h
index b049d1a2..8dbbab0e 100644
--- a/NativeScript/include/cppgc/sentinel-pointer.h
+++ b/NativeScript/include/cppgc/sentinel-pointer.h
@@ -13,9 +13,9 @@ namespace internal {
 // Special tag type used to denote some sentinel member. The semantics of the
 // sentinel is defined by the embedder.
 struct SentinelPointer {
+  static constexpr intptr_t kSentinelValue = 0b10;
   template <typename T>
   operator T*() const {
-    static constexpr intptr_t kSentinelValue = 1;
     return reinterpret_cast<T*>(kSentinelValue);
   }
   // Hidden friends.
diff --git a/NativeScript/include/cppgc/trace-trait.h b/NativeScript/include/cppgc/trace-trait.h
index 83619b1d..694fbfdc 100644
--- a/NativeScript/include/cppgc/trace-trait.h
+++ b/NativeScript/include/cppgc/trace-trait.h
@@ -16,6 +16,10 @@ class Visitor;
 
 namespace internal {
 
+class RootVisitor;
+
+using TraceRootCallback = void (*)(RootVisitor&, const void* object);
+
 // Implementation of the default TraceTrait handling GarbageCollected and
 // GarbageCollectedMixin.
 template <typename T,
diff --git a/NativeScript/include/cppgc/type-traits.h b/NativeScript/include/cppgc/type-traits.h
index 970ffd48..2f499e68 100644
--- a/NativeScript/include/cppgc/type-traits.h
+++ b/NativeScript/include/cppgc/type-traits.h
@@ -170,6 +170,15 @@ struct IsComplete {
       decltype(IsSizeOfKnown(std::declval<T*>()))::value;
 };
 
+template <typename T, typename U>
+constexpr bool IsDecayedSameV =
+    std::is_same_v<std::decay_t<T>, std::decay_t<U>>;
+
+template <typename B, typename D>
+constexpr bool IsStrictlyBaseOfV =
+    std::is_base_of_v<std::decay_t<B>, std::decay_t<D>> &&
+    !IsDecayedSameV<B, D>;
+
 }  // namespace internal
 
 /**
diff --git a/NativeScript/include/cppgc/visitor.h b/NativeScript/include/cppgc/visitor.h
index 57e2ce39..704aabcd 100644
--- a/NativeScript/include/cppgc/visitor.h
+++ b/NativeScript/include/cppgc/visitor.h
@@ -62,22 +62,6 @@ class V8_EXPORT Visitor {
 
   virtual ~Visitor() = default;
 
-  /**
-   * Trace method for raw pointers. Prefer the versions for managed pointers.
-   *
-   * \param member Reference retaining an object.
-   */
-  template <typename T>
-  void Trace(const T* t) {
-    static_assert(sizeof(T), "Pointee type must be fully defined.");
-    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
-                  "T must be GarbageCollected or GarbageCollectedMixin type");
-    if (!t) {
-      return;
-    }
-    Visit(t, TraceTrait<T>::GetTraceDescriptor(t));
-  }
-
   /**
    * Trace method for Member.
    *
@@ -87,7 +71,7 @@ class V8_EXPORT Visitor {
   void Trace(const Member<T>& member) {
     const T* value = member.GetRawAtomic();
     CPPGC_DCHECK(value != kSentinelPointer);
-    Trace(value);
+    TraceImpl(value);
   }
 
   /**
@@ -231,23 +215,34 @@ class V8_EXPORT Visitor {
   void TraceStrongly(const WeakMember<T>& weak_member) {
     const T* value = weak_member.GetRawAtomic();
     CPPGC_DCHECK(value != kSentinelPointer);
-    Trace(value);
+    TraceImpl(value);
+  }
+
+  /**
+   * Trace method for retaining containers strongly.
+   *
+   * \param object reference to the container.
+   */
+  template <typename T>
+  void TraceStrongContainer(const T* object) {
+    TraceImpl(object);
   }
 
   /**
-   * Trace method for weak containers.
+   * Trace method for retaining containers weakly. Note that weak containers
+   * should emit write barriers.
    *
-   * \param object reference of the weak container.
+   * \param object reference to the container.
    * \param callback to be invoked.
-   * \param data custom data that is passed to the callback.
+   * \param callback_data custom data that is passed to the callback.
    */
   template <typename T>
   void TraceWeakContainer(const T* object, WeakCallback callback,
-                          const void* data) {
+                          const void* callback_data) {
     if (!object) return;
     VisitWeakContainer(object, TraceTrait<T>::GetTraceDescriptor(object),
                        TraceTrait<T>::GetWeakTraceDescriptor(object), callback,
-                       data);
+                       callback_data);
   }
 
   /**
@@ -255,6 +250,7 @@ class V8_EXPORT Visitor {
    * compactable space. Such references maybe be arbitrarily moved by the GC.
    *
    * \param slot location of reference to object that might be moved by the GC.
+   * The slot must contain an uncompressed pointer.
    */
   template <typename T>
   void RegisterMovableReference(const T** slot) {
@@ -297,9 +293,6 @@ class V8_EXPORT Visitor {
   virtual void Visit(const void* self, TraceDescriptor) {}
   virtual void VisitWeak(const void* self, TraceDescriptor, WeakCallback,
                          const void* weak_member) {}
-  virtual void VisitRoot(const void*, TraceDescriptor, const SourceLocation&) {}
-  virtual void VisitWeakRoot(const void* self, TraceDescriptor, WeakCallback,
-                             const void* weak_root, const SourceLocation&) {}
   virtual void VisitEphemeron(const void* key, const void* value,
                               TraceDescriptor value_desc) {}
   virtual void VisitWeakContainer(const void* self, TraceDescriptor strong_desc,
@@ -320,44 +313,20 @@ class V8_EXPORT Visitor {
   static void HandleWeak(const LivenessBroker& info, const void* object) {
     const PointerType* weak = static_cast<const PointerType*>(object);
     auto* raw_ptr = weak->GetFromGC();
-    // Sentinel values are preserved for weak pointers.
-    if (raw_ptr == kSentinelPointer) return;
     if (!info.IsHeapObjectAlive(raw_ptr)) {
       weak->ClearFromGC();
     }
   }
 
-  template <typename Persistent,
-            std::enable_if_t<Persistent::IsStrongPersistent::value>* = nullptr>
-  void TraceRoot(const Persistent& p, const SourceLocation& loc) {
-    using PointeeType = typename Persistent::PointeeType;
-    static_assert(sizeof(PointeeType),
-                  "Persistent's pointee type must be fully defined");
-    static_assert(internal::IsGarbageCollectedOrMixinType<PointeeType>::value,
-                  "Persistent's pointee type must be GarbageCollected or "
-                  "GarbageCollectedMixin");
-    auto* ptr = p.GetFromGC();
-    if (!ptr) {
+  template <typename T>
+  void TraceImpl(const T* t) {
+    static_assert(sizeof(T), "Pointee type must be fully defined.");
+    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
+                  "T must be GarbageCollected or GarbageCollectedMixin type");
+    if (!t) {
       return;
     }
-    VisitRoot(ptr, TraceTrait<PointeeType>::GetTraceDescriptor(ptr), loc);
-  }
-
-  template <
-      typename WeakPersistent,
-      std::enable_if_t<!WeakPersistent::IsStrongPersistent::value>* = nullptr>
-  void TraceRoot(const WeakPersistent& p, const SourceLocation& loc) {
-    using PointeeType = typename WeakPersistent::PointeeType;
-    static_assert(sizeof(PointeeType),
-                  "Persistent's pointee type must be fully defined");
-    static_assert(internal::IsGarbageCollectedOrMixinType<PointeeType>::value,
-                  "Persistent's pointee type must be GarbageCollected or "
-                  "GarbageCollectedMixin");
-    static_assert(!internal::IsAllocatedOnCompactableSpace<PointeeType>::value,
-                  "Weak references to compactable objects are not allowed");
-    auto* ptr = p.GetFromGC();
-    VisitWeakRoot(ptr, TraceTrait<PointeeType>::GetTraceDescriptor(ptr),
-                  &HandleWeak<WeakPersistent>, &p, loc);
+    Visit(t, TraceTrait<T>::GetTraceDescriptor(t));
   }
 
 #if V8_ENABLE_CHECKS
@@ -374,6 +343,70 @@ class V8_EXPORT Visitor {
   friend class internal::VisitorBase;
 };
 
+namespace internal {
+
+class V8_EXPORT RootVisitor {
+ public:
+  explicit RootVisitor(Visitor::Key) {}
+
+  virtual ~RootVisitor() = default;
+
+  template <typename AnyStrongPersistentType,
+            std::enable_if_t<
+                AnyStrongPersistentType::IsStrongPersistent::value>* = nullptr>
+  void Trace(const AnyStrongPersistentType& p) {
+    using PointeeType = typename AnyStrongPersistentType::PointeeType;
+    const void* object = Extract(p);
+    if (!object) {
+      return;
+    }
+    VisitRoot(object, TraceTrait<PointeeType>::GetTraceDescriptor(object),
+              p.Location());
+  }
+
+  template <typename AnyWeakPersistentType,
+            std::enable_if_t<
+                !AnyWeakPersistentType::IsStrongPersistent::value>* = nullptr>
+  void Trace(const AnyWeakPersistentType& p) {
+    using PointeeType = typename AnyWeakPersistentType::PointeeType;
+    static_assert(!internal::IsAllocatedOnCompactableSpace<PointeeType>::value,
+                  "Weak references to compactable objects are not allowed");
+    const void* object = Extract(p);
+    if (!object) {
+      return;
+    }
+    VisitWeakRoot(object, TraceTrait<PointeeType>::GetTraceDescriptor(object),
+                  &HandleWeak<AnyWeakPersistentType>, &p, p.Location());
+  }
+
+ protected:
+  virtual void VisitRoot(const void*, TraceDescriptor, const SourceLocation&) {}
+  virtual void VisitWeakRoot(const void* self, TraceDescriptor, WeakCallback,
+                             const void* weak_root, const SourceLocation&) {}
+
+ private:
+  template <typename AnyPersistentType>
+  static const void* Extract(AnyPersistentType& p) {
+    using PointeeType = typename AnyPersistentType::PointeeType;
+    static_assert(sizeof(PointeeType),
+                  "Persistent's pointee type must be fully defined");
+    static_assert(internal::IsGarbageCollectedOrMixinType<PointeeType>::value,
+                  "Persistent's pointee type must be GarbageCollected or "
+                  "GarbageCollectedMixin");
+    return p.GetFromGC();
+  }
+
+  template <typename PointerType>
+  static void HandleWeak(const LivenessBroker& info, const void* object) {
+    const PointerType* weak = static_cast<const PointerType*>(object);
+    auto* raw_ptr = weak->GetFromGC();
+    if (!info.IsHeapObjectAlive(raw_ptr)) {
+      weak->ClearFromGC();
+    }
+  }
+};
+
+}  // namespace internal
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_VISITOR_H_
diff --git a/NativeScript/include/js_protocol-1.3.json b/NativeScript/include/js_protocol-1.3.json
index ea573d11..a998d461 100644
--- a/NativeScript/include/js_protocol-1.3.json
+++ b/NativeScript/include/js_protocol-1.3.json
@@ -946,34 +946,6 @@
                     { "name": "url", "type": "string", "description": "JavaScript script name or url." },
                     { "name": "functions", "type": "array", "items": { "$ref": "FunctionCoverage" }, "description": "Functions contained in the script that has coverage data." }
                 ]
-            },
-            {   "id": "TypeObject",
-                "type": "object",
-                "description": "Describes a type collected during runtime.",
-                "properties": [
-                    { "name": "name", "type": "string", "description": "Name of a type collected with type profiling." }
-                ],
-                "experimental": true
-            },
-            {   "id": "TypeProfileEntry",
-                "type": "object",
-                "description": "Source offset and types for a parameter or return value.",
-                "properties": [
-                    { "name": "offset", "type": "integer", "description": "Source offset of the parameter or end of function for return values." },
-                    { "name": "types", "type": "array", "items": {"$ref": "TypeObject"}, "description": "The types for this parameter or return value."}
-                ],
-                "experimental": true
-            },
-            {
-                "id": "ScriptTypeProfile",
-                "type": "object",
-                "description": "Type profile data collected during runtime for a JavaScript script.",
-                "properties": [
-                    { "name": "scriptId", "$ref": "Runtime.ScriptId", "description": "JavaScript script id." },
-                    { "name": "url", "type": "string", "description": "JavaScript script name or url." },
-                    { "name": "entries", "type": "array", "items": { "$ref": "TypeProfileEntry" }, "description": "Type profile entries for parameters and return values of the functions in the script." }
-                ],
-                "experimental": true
             }
         ],
         "commands": [
@@ -1024,24 +996,6 @@
                     { "name": "result", "type": "array", "items": { "$ref": "ScriptCoverage" }, "description": "Coverage data for the current isolate." }
                 ],
                 "description": "Collect coverage data for the current isolate. The coverage data may be incomplete due to garbage collection."
-            },
-            {
-                "name": "startTypeProfile",
-                "description": "Enable type profile.",
-                "experimental": true
-            },
-            {
-                "name": "stopTypeProfile",
-                "description": "Disable type profile. Disabling releases type profile data collected so far.",
-                "experimental": true
-            },
-            {
-                "name": "takeTypeProfile",
-                "returns": [
-                    { "name": "result", "type":  "array", "items": { "$ref": "ScriptTypeProfile" }, "description": "Type profile for all scripts since startTypeProfile() was turned on." }
-                ],
-                "description": "Collect type profile.",
-                "experimental": true
             }
         ],
         "events": [
diff --git a/NativeScript/include/js_protocol.pdl b/NativeScript/include/js_protocol.pdl
index bd277eb0..d4102f5c 100644
--- a/NativeScript/include/js_protocol.pdl
+++ b/NativeScript/include/js_protocol.pdl
@@ -244,6 +244,40 @@ domain Debugger
       # Wasm bytecode.
       optional binary bytecode
 
+  experimental type WasmDisassemblyChunk extends object
+    properties
+      # The next chunk of disassembled lines.
+      array of string lines
+      # The bytecode offsets describing the start of each line.
+      array of integer bytecodeOffsets
+
+  experimental command disassembleWasmModule
+    parameters
+      # Id of the script to disassemble
+      Runtime.ScriptId scriptId
+    returns
+      # For large modules, return a stream from which additional chunks of
+      # disassembly can be read successively.
+      optional string streamId
+      # The total number of lines in the disassembly text.
+      integer totalNumberOfLines
+      # The offsets of all function bodies, in the format [start1, end1,
+      # start2, end2, ...] where all ends are exclusive.
+      array of integer functionBodyOffsets
+      # The first chunk of disassembly.
+      WasmDisassemblyChunk chunk
+
+  # Disassemble the next chunk of lines for the module corresponding to the
+  # stream. If disassembly is complete, this API will invalidate the streamId
+  # and return an empty chunk. Any subsequent calls for the now invalid stream
+  # will return errors.
+  experimental command nextWasmDisassemblyChunk
+    parameters
+      string streamId
+    returns
+      # The next chunk of disassembly.
+      WasmDisassemblyChunk chunk
+
   # This command is deprecated. Use getScriptSource instead.
   deprecated command getWasmBytecode
     parameters
@@ -273,18 +307,35 @@ domain Debugger
     parameters
       BreakpointId breakpointId
 
-  # Restarts particular call frame from the beginning.
-  deprecated command restartFrame
+  # Restarts particular call frame from the beginning. The old, deprecated
+  # behavior of `restartFrame` is to stay paused and allow further CDP commands
+  # after a restart was scheduled. This can cause problems with restarting, so
+  # we now continue execution immediatly after it has been scheduled until we
+  # reach the beginning of the restarted frame.
+  #
+  # To stay back-wards compatible, `restartFrame` now expects a `mode`
+  # parameter to be present. If the `mode` parameter is missing, `restartFrame`
+  # errors out.
+  #
+  # The various return values are deprecated and `callFrames` is always empty.
+  # Use the call frames from the `Debugger#paused` events instead, that fires
+  # once V8 pauses at the beginning of the restarted function.
+  command restartFrame
     parameters
       # Call frame identifier to evaluate on.
       CallFrameId callFrameId
+      # The `mode` parameter must be present and set to 'StepInto', otherwise
+      # `restartFrame` will error out.
+      experimental optional enum mode
+        # Pause at the beginning of the restarted function
+        StepInto
     returns
       # New stack trace.
-      array of CallFrame callFrames
+      deprecated array of CallFrame callFrames
       # Async stack trace, if any.
-      optional Runtime.StackTrace asyncStackTrace
+      deprecated optional Runtime.StackTrace asyncStackTrace
       # Async stack trace, if any.
-      experimental optional Runtime.StackTraceId asyncStackTraceId
+      deprecated optional Runtime.StackTraceId asyncStackTraceId
 
   # Resumes JavaScript execution.
   command resume
@@ -407,13 +458,14 @@ domain Debugger
       # New value for breakpoints active state.
       boolean active
 
-  # Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions or
-  # no exceptions. Initial pause on exceptions state is `none`.
+  # Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions,
+  # or caught exceptions, no exceptions. Initial pause on exceptions state is `none`.
   command setPauseOnExceptions
     parameters
       # Pause on exceptions mode.
       enum state
         none
+        caught
         uncaught
         all
 
@@ -424,6 +476,12 @@ domain Debugger
       Runtime.CallArgument newValue
 
   # Edits JavaScript source live.
+  #
+  # In general, functions that are currently on the stack can not be edited with
+  # a single exception: If the edited function is the top-most stack frame and
+  # that is the only activation of that function on the stack. In this case
+  # the live edit will be successful and a `Debugger.restartFrame` for the
+  # top-most function is automatically triggered.
   command setScriptSource
     parameters
       # Id of the script to edit.
@@ -433,16 +491,27 @@ domain Debugger
       #  If true the change will not actually be applied. Dry run may be used to get result
       # description without actually modifying the code.
       optional boolean dryRun
+      # If true, then `scriptSource` is allowed to change the function on top of the stack
+      # as long as the top-most stack frame is the only activation of that function.
+      experimental optional boolean allowTopFrameEditing
     returns
       # New stack trace in case editing has happened while VM was stopped.
-      optional array of CallFrame callFrames
+      deprecated optional array of CallFrame callFrames
       # Whether current call stack  was modified after applying the changes.
-      optional boolean stackChanged
+      deprecated optional boolean stackChanged
       # Async stack trace, if any.
-      optional Runtime.StackTrace asyncStackTrace
+      deprecated optional Runtime.StackTrace asyncStackTrace
       # Async stack trace, if any.
-      experimental optional Runtime.StackTraceId asyncStackTraceId
-      # Exception details if any.
+      deprecated optional Runtime.StackTraceId asyncStackTraceId
+      # Whether the operation was successful or not. Only `Ok` denotes a
+      # successful live edit while the other enum variants denote why
+      # the live edit failed.
+      experimental enum status
+        Ok
+        CompileError
+        BlockedByActiveGenerator
+        BlockedByActiveFunction
+      # Exception details if any. Only present when `status` is `CompileError`.
       optional Runtime.ExceptionDetails exceptionDetails
 
   # Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).
@@ -559,7 +628,7 @@ domain Debugger
       integer endColumn
       # Specifies script creation context.
       Runtime.ExecutionContextId executionContextId
-      # Content hash of the script.
+      # Content hash of the script, SHA-256.
       string hash
       # Embedder-specific auxiliary data.
       optional object executionContextAuxData
@@ -598,7 +667,7 @@ domain Debugger
       integer endColumn
       # Specifies script creation context.
       Runtime.ExecutionContextId executionContextId
-      # Content hash of the script.
+      # Content hash of the script, SHA-256.
       string hash
       # Embedder-specific auxiliary data.
       optional object executionContextAuxData
@@ -698,6 +767,22 @@ experimental domain HeapProfiler
       # Average sample interval in bytes. Poisson distribution is used for the intervals. The
       # default value is 32768 bytes.
       optional number samplingInterval
+      # By default, the sampling heap profiler reports only objects which are
+      # still alive when the profile is returned via getSamplingProfile or
+      # stopSampling, which is useful for determining what functions contribute
+      # the most to steady-state memory usage. This flag instructs the sampling
+      # heap profiler to also include information about objects discarded by
+      # major GC, which will show which functions cause large temporary memory
+      # usage or long GC pauses.
+      optional boolean includeObjectsCollectedByMajorGC
+      # By default, the sampling heap profiler reports only objects which are
+      # still alive when the profile is returned via getSamplingProfile or
+      # stopSampling, which is useful for determining what functions contribute
+      # the most to steady-state memory usage. This flag instructs the sampling
+      # heap profiler to also include information about objects discarded by
+      # minor GC, which is useful when tuning a latency-sensitive application
+      # for minimal GC activity.
+      optional boolean includeObjectsCollectedByMinorGC
 
   command startTrackingHeapObjects
     parameters
@@ -713,18 +798,24 @@ experimental domain HeapProfiler
       # If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken
       # when the tracking is stopped.
       optional boolean reportProgress
-      optional boolean treatGlobalObjectsAsRoots
+      # Deprecated in favor of `exposeInternals`.
+      deprecated optional boolean treatGlobalObjectsAsRoots
       # If true, numerical values are included in the snapshot
       optional boolean captureNumericValue
+      # If true, exposes internals of the snapshot.
+      experimental optional boolean exposeInternals
 
   command takeHeapSnapshot
     parameters
       # If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.
       optional boolean reportProgress
-      # If true, a raw snapshot without artificial roots will be generated
-      optional boolean treatGlobalObjectsAsRoots
+      # If true, a raw snapshot without artificial roots will be generated.
+      # Deprecated in favor of `exposeInternals`.
+      deprecated optional boolean treatGlobalObjectsAsRoots
       # If true, numerical values are included in the snapshot
       optional boolean captureNumericValue
+      # If true, exposes internals of the snapshot.
+      experimental optional boolean exposeInternals
 
   event addHeapSnapshotChunk
     parameters
@@ -828,30 +919,6 @@ domain Profiler
       # Functions contained in the script that has coverage data.
       array of FunctionCoverage functions
 
-  # Describes a type collected during runtime.
-  experimental type TypeObject extends object
-    properties
-      # Name of a type collected with type profiling.
-      string name
-
-  # Source offset and types for a parameter or return value.
-  experimental type TypeProfileEntry extends object
-    properties
-      # Source offset of the parameter or end of function for return values.
-      integer offset
-      # The types for this parameter or return value.
-      array of TypeObject types
-
-  # Type profile data collected during runtime for a JavaScript script.
-  experimental type ScriptTypeProfile extends object
-    properties
-      # JavaScript script id.
-      Runtime.ScriptId scriptId
-      # JavaScript script name or url.
-      string url
-      # Type profile entries for parameters and return values of the functions in the script.
-      array of TypeProfileEntry entries
-
   command disable
 
   command enable
@@ -886,9 +953,6 @@ domain Profiler
       # Monotonically increasing time (in seconds) when the coverage update was taken in the backend.
       number timestamp
 
-  # Enable type profile.
-  experimental command startTypeProfile
-
   command stop
     returns
       # Recorded profile.
@@ -898,9 +962,6 @@ domain Profiler
   # executing optimized code.
   command stopPreciseCoverage
 
-  # Disable type profile. Disabling releases type profile data collected so far.
-  experimental command stopTypeProfile
-
   # Collect coverage data for the current isolate, and resets execution counters. Precise code
   # coverage needs to have started.
   command takePreciseCoverage
@@ -910,12 +971,6 @@ domain Profiler
       # Monotonically increasing time (in seconds) when the coverage update was taken in the backend.
       number timestamp
 
-  # Collect type profile.
-  experimental command takeTypeProfile
-    returns
-      # Type profile for all scripts since startTypeProfile() was turned on.
-      array of ScriptTypeProfile result
-
   event consoleProfileFinished
     parameters
       string id
@@ -1347,7 +1402,16 @@ domain Runtime
       optional string objectGroup
       # Whether to throw an exception if side effect cannot be ruled out during evaluation.
       experimental optional boolean throwOnSideEffect
-      # Whether the result should be serialized according to https://w3c.github.io/webdriver-bidi.
+      # An alternative way to specify the execution context to call function on.
+      # Compared to contextId that may be reused across processes, this is guaranteed to be
+      # system-unique, so it can be used to prevent accidental function call
+      # in context different than intended (e.g. as a result of navigation across process
+      # boundaries).
+      # This is mutually exclusive with `executionContextId`.
+      experimental optional string uniqueContextId
+      # Whether the result should contain `webDriverValue`, serialized according to
+      # https://w3c.github.io/webdriver-bidi. This is mutually exclusive with `returnByValue`, but
+      # resulting `objectId` is still provided.
       experimental optional boolean generateWebDriverValue
     returns
       # Call result.
@@ -1677,7 +1741,9 @@ domain Runtime
   event executionContextDestroyed
     parameters
       # Id of the destroyed context
-      ExecutionContextId executionContextId
+      deprecated ExecutionContextId executionContextId
+      # Unique Id of the destroyed context
+      experimental string executionContextUniqueId
 
   # Issued when all executionContexts were cleared in browser
   event executionContextsCleared
diff --git a/NativeScript/include/libplatform/v8-tracing.h b/NativeScript/include/libplatform/v8-tracing.h
index 12489327..6039a9c5 100644
--- a/NativeScript/include/libplatform/v8-tracing.h
+++ b/NativeScript/include/libplatform/v8-tracing.h
@@ -282,12 +282,12 @@ class V8_PLATFORM_EXPORT TracingController
                                 const char* name, uint64_t handle) override;
 
   static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
-#endif  // !defined(V8_USE_PERFETTO)
 
   void AddTraceStateObserver(
       v8::TracingController::TraceStateObserver* observer) override;
   void RemoveTraceStateObserver(
       v8::TracingController::TraceStateObserver* observer) override;
+#endif  // !defined(V8_USE_PERFETTO)
 
   void StartTracing(TraceConfig* trace_config);
   void StopTracing();
@@ -307,7 +307,6 @@ class V8_PLATFORM_EXPORT TracingController
   std::unique_ptr<base::Mutex> mutex_;
   std::unique_ptr<TraceConfig> trace_config_;
   std::atomic_bool recording_{false};
-  std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
 
 #if defined(V8_USE_PERFETTO)
   std::ostream* output_stream_ = nullptr;
@@ -316,6 +315,7 @@ class V8_PLATFORM_EXPORT TracingController
   TraceEventListener* listener_for_testing_ = nullptr;
   std::unique_ptr<perfetto::TracingSession> tracing_session_;
 #else   // !defined(V8_USE_PERFETTO)
+  std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
   std::unique_ptr<TraceBuffer> trace_buffer_;
 #endif  // !defined(V8_USE_PERFETTO)
 
diff --git a/NativeScript/include/v8-array-buffer.h b/NativeScript/include/v8-array-buffer.h
index e9047b79..804fc42c 100644
--- a/NativeScript/include/v8-array-buffer.h
+++ b/NativeScript/include/v8-array-buffer.h
@@ -53,12 +53,28 @@ class V8_EXPORT BackingStore : public v8::internal::BackingStoreBase {
    */
   size_t ByteLength() const;
 
+  /**
+   * The maximum length (in bytes) that this backing store may grow to.
+   *
+   * If this backing store was created for a resizable ArrayBuffer or a growable
+   * SharedArrayBuffer, it is >= ByteLength(). Otherwise it is ==
+   * ByteLength().
+   */
+  size_t MaxByteLength() const;
+
   /**
    * Indicates whether the backing store was created for an ArrayBuffer or
    * a SharedArrayBuffer.
    */
   bool IsShared() const;
 
+  /**
+   * Indicates whether the backing store was created for a resizable ArrayBuffer
+   * or a growable SharedArrayBuffer, and thus may be resized by user JavaScript
+   * code.
+   */
+  bool IsResizableByUserJavaScript() const;
+
   /**
    * Prevent implicit instantiation of operator delete with size_t argument.
    * The size_t argument would be incorrect because ptr points to the
@@ -189,6 +205,11 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   size_t ByteLength() const;
 
+  /**
+   * Maximum length in bytes.
+   */
+  size_t MaxByteLength() const;
+
   /**
    * Create a new ArrayBuffer. Allocate |byte_length| bytes.
    * Allocated memory will be owned by a created ArrayBuffer and
@@ -235,27 +256,74 @@ class V8_EXPORT ArrayBuffer : public Object {
       void* data, size_t byte_length, v8::BackingStore::DeleterCallback deleter,
       void* deleter_data);
 
+  /**
+   * Returns a new resizable standalone BackingStore that is allocated using the
+   * array buffer allocator of the isolate. The result can be later passed to
+   * ArrayBuffer::New.
+   *
+   * |byte_length| must be <= |max_byte_length|.
+   *
+   * This function is usable without an isolate. Unlike |NewBackingStore| calls
+   * with an isolate, GCs cannot be triggered, and there are no
+   * retries. Allocation failure will cause the function to crash with an
+   * out-of-memory error.
+   */
+  static std::unique_ptr<BackingStore> NewResizableBackingStore(
+      size_t byte_length, size_t max_byte_length);
+
   /**
    * Returns true if this ArrayBuffer may be detached.
    */
   bool IsDetachable() const;
 
+  /**
+   * Returns true if this ArrayBuffer has been detached.
+   */
+  bool WasDetached() const;
+
   /**
    * Detaches this ArrayBuffer and all its views (typed arrays).
    * Detaching sets the byte length of the buffer and all typed arrays to zero,
    * preventing JavaScript from ever accessing underlying backing store.
    * ArrayBuffer should have been externalized and must be detachable.
    */
+  V8_DEPRECATE_SOON(
+      "Use the version which takes a key parameter (passing a null handle is "
+      "ok).")
   void Detach();
 
+  /**
+   * Detaches this ArrayBuffer and all its views (typed arrays).
+   * Detaching sets the byte length of the buffer and all typed arrays to zero,
+   * preventing JavaScript from ever accessing underlying backing store.
+   * ArrayBuffer should have been externalized and must be detachable. Returns
+   * Nothing if the key didn't pass the [[ArrayBufferDetachKey]] check,
+   * Just(true) otherwise.
+   */
+  V8_WARN_UNUSED_RESULT Maybe<bool> Detach(v8::Local<v8::Value> key);
+
+  /**
+   * Sets the ArrayBufferDetachKey.
+   */
+  void SetDetachKey(v8::Local<v8::Value> key);
+
   /**
    * Get a shared pointer to the backing store of this array buffer. This
    * pointer coordinates the lifetime management of the internal storage
    * with any live ArrayBuffers on the heap, even across isolates. The embedder
    * should not attempt to manage lifetime of the storage through other means.
+   *
+   * The returned shared pointer will not be empty, even if the ArrayBuffer has
+   * been detached. Use |WasDetached| to tell if it has been detached instead.
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
+  /**
+   * More efficient shortcut for GetBackingStore()->Data(). The returned pointer
+   * is valid as long as the ArrayBuffer is alive.
+   */
+  void* Data() const;
+
   V8_INLINE static ArrayBuffer* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
@@ -360,6 +428,11 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    */
   size_t ByteLength() const;
 
+  /**
+   * Maximum length in bytes.
+   */
+  size_t MaxByteLength() const;
+
   /**
    * Create a new SharedArrayBuffer. Allocate |byte_length| bytes.
    * Allocated memory will be owned by a created SharedArrayBuffer and
@@ -414,6 +487,12 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
+  /**
+   * More efficient shortcut for GetBackingStore()->Data(). The returned pointer
+   * is valid as long as the ArrayBuffer is alive.
+   */
+  void* Data() const;
+
   V8_INLINE static SharedArrayBuffer* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
diff --git a/NativeScript/include/v8-callbacks.h b/NativeScript/include/v8-callbacks.h
index 70b9c2ae..f3e96c37 100644
--- a/NativeScript/include/v8-callbacks.h
+++ b/NativeScript/include/v8-callbacks.h
@@ -12,6 +12,7 @@
 #include "cppgc/common.h"
 #include "v8-data.h"          // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-promise.h"       // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 #if defined(V8_OS_WIN)
@@ -105,7 +106,7 @@ struct JitCodeEvent {
     size_t line_number_table_size;
   };
 
-  wasm_source_info_t* wasm_source_info;
+  wasm_source_info_t* wasm_source_info = nullptr;
 
   union {
     // Only valid for CODE_ADDED.
@@ -216,7 +217,13 @@ using AddHistogramSampleCallback = void (*)(void* histogram, int sample);
 
 using FatalErrorCallback = void (*)(const char* location, const char* message);
 
-using OOMErrorCallback = void (*)(const char* location, bool is_heap_oom);
+struct OOMDetails {
+  bool is_heap_oom = false;
+  const char* detail = nullptr;
+};
+
+using OOMErrorCallback = void (*)(const char* location,
+                                  const OOMDetails& details);
 
 using MessageCallback = void (*)(Local<Message> message, Local<Value> data);
 
@@ -230,9 +237,13 @@ using LogEventCallback = void (*)(const char* name,
 enum class CrashKeyId {
   kIsolateAddress,
   kReadonlySpaceFirstPageAddress,
-  kMapSpaceFirstPageAddress,
+  kMapSpaceFirstPageAddress V8_ENUM_DEPRECATE_SOON("Map space got removed"),
+  kOldSpaceFirstPageAddress,
+  kCodeRangeBaseAddress,
   kCodeSpaceFirstPageAddress,
   kDumpType,
+  kSnapshotChecksumCalculated,
+  kSnapshotChecksumExpected,
 };
 
 using AddCrashKeyCallback = void (*)(CrashKeyId id, const std::string& value);
@@ -300,6 +311,13 @@ using ApiImplementationCallback = void (*)(const FunctionCallbackInfo<Value>&);
 // --- Callback for WebAssembly.compileStreaming ---
 using WasmStreamingCallback = void (*)(const FunctionCallbackInfo<Value>&);
 
+enum class WasmAsyncSuccess { kSuccess, kFail };
+
+// --- Callback called when async WebAssembly operations finish ---
+using WasmAsyncResolvePromiseCallback = void (*)(
+    Isolate* isolate, Local<Context> context, Local<Promise::Resolver> resolver,
+    Local<Value> result, WasmAsyncSuccess success);
+
 // --- Callback for loading source map file for Wasm profiling support
 using WasmLoadSourceMapCallback = Local<String> (*)(Isolate* isolate,
                                                     const char* name);
@@ -310,8 +328,9 @@ using WasmSimdEnabledCallback = bool (*)(Local<Context> context);
 // --- Callback for checking if WebAssembly exceptions are enabled ---
 using WasmExceptionsEnabledCallback = bool (*)(Local<Context> context);
 
-// --- Callback for checking if WebAssembly dynamic tiering is enabled ---
-using WasmDynamicTieringEnabledCallback = bool (*)(Local<Context> context);
+// --- Callback for checking if WebAssembly GC is enabled ---
+// If the callback returns true, it will also enable Wasm stringrefs.
+using WasmGCEnabledCallback = bool (*)(Local<Context> context);
 
 // --- Callback for checking if the SharedArrayBuffer constructor is enabled ---
 using SharedArrayBufferConstructorEnabledCallback =
diff --git a/NativeScript/include/v8-context.h b/NativeScript/include/v8-context.h
index 72dfbaad..3ce0eb0a 100644
--- a/NativeScript/include/v8-context.h
+++ b/NativeScript/include/v8-context.h
@@ -169,6 +169,9 @@ class V8_EXPORT Context : public Data {
   /** Returns the microtask queue associated with a current context. */
   MicrotaskQueue* GetMicrotaskQueue();
 
+  /** Sets the microtask queue associated with the current context. */
+  void SetMicrotaskQueue(MicrotaskQueue* queue);
+
   /**
    * The field at kDebugIdIndex used to be reserved for the inspector.
    * It now serves no purpose.
@@ -244,6 +247,12 @@ class V8_EXPORT Context : public Data {
    */
   void SetErrorMessageForCodeGenerationFromStrings(Local<String> message);
 
+  /**
+   * Sets the error description for the exception that is thrown when
+   * wasm code generation is not allowed.
+   */
+  void SetErrorMessageForWasmCodeGeneration(Local<String> message);
+
   /**
    * Return data that was previously attached to the context snapshot via
    * SnapshotCreator, and removes the reference to it.
@@ -284,6 +293,7 @@ class V8_EXPORT Context : public Data {
                        Local<Function> after_hook,
                        Local<Function> resolve_hook);
 
+  bool HasTemplateLiteralObject(Local<Value> object);
   /**
    * Stack-allocated class which sets the execution context for all
    * operations executed within a local scope.
@@ -374,15 +384,13 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
   A ctx = *reinterpret_cast<const A*>(this);
   A embedder_data =
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
-  int value_offset =
-      I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index);
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-  value_offset += I::kEmbedderDataSlotRawPayloadOffset;
-#endif
-  internal::Isolate* isolate = I::GetIsolateForSandbox(ctx);
+  int value_offset = I::kEmbedderDataArrayHeaderSize +
+                     (I::kEmbedderDataSlotSize * index) +
+                     I::kEmbedderDataSlotExternalPointerOffset;
+  Isolate* isolate = I::GetIsolateForSandbox(ctx);
   return reinterpret_cast<void*>(
-      I::ReadExternalPointerField(isolate, embedder_data, value_offset,
-                                  internal::kEmbedderDataSlotPayloadTag));
+      I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+          isolate, embedder_data, value_offset));
 #else
   return SlowGetAlignedPointerFromEmbedderData(index);
 #endif
diff --git a/NativeScript/include/v8-cppgc.h b/NativeScript/include/v8-cppgc.h
index 41215493..4a457027 100644
--- a/NativeScript/include/v8-cppgc.h
+++ b/NativeScript/include/v8-cppgc.h
@@ -77,12 +77,37 @@ struct WrapperDescriptor final {
 };
 
 struct V8_EXPORT CppHeapCreateParams {
+  CppHeapCreateParams(
+      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces,
+      WrapperDescriptor wrapper_descriptor)
+      : custom_spaces(std::move(custom_spaces)),
+        wrapper_descriptor(wrapper_descriptor) {}
+
+  CppHeapCreateParams(const CppHeapCreateParams&) = delete;
+  CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;
+
   std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
   WrapperDescriptor wrapper_descriptor;
+  /**
+   * Specifies which kind of marking are supported by the heap. The type may be
+   * further reduced via runtime flags when attaching the heap to an Isolate.
+   */
+  cppgc::Heap::MarkingType marking_support =
+      cppgc::Heap::MarkingType::kIncrementalAndConcurrent;
+  /**
+   * Specifies which kind of sweeping is supported by the heap. The type may be
+   * further reduced via runtime flags when attaching the heap to an Isolate.
+   */
+  cppgc::Heap::SweepingType sweeping_support =
+      cppgc::Heap::SweepingType::kIncrementalAndConcurrent;
 };
 
 /**
  * A heap for allocating managed C++ objects.
+ *
+ * Similar to v8::Isolate, the heap may only be accessed from one thread at a
+ * time. The heap may be used from different threads using the
+ * v8::Locker/v8::Unlocker APIs which is different from generic Oilpan.
  */
 class V8_EXPORT CppHeap {
  public:
diff --git a/NativeScript/include/v8-data.h b/NativeScript/include/v8-data.h
index cc51fefe..fc4dea92 100644
--- a/NativeScript/include/v8-data.h
+++ b/NativeScript/include/v8-data.h
@@ -53,7 +53,7 @@ class V8_EXPORT Data {
   bool IsContext() const;
 
  private:
-  Data();
+  Data() = delete;
 };
 
 /**
diff --git a/NativeScript/include/v8-date.h b/NativeScript/include/v8-date.h
index e7a01f29..8d82ccc9 100644
--- a/NativeScript/include/v8-date.h
+++ b/NativeScript/include/v8-date.h
@@ -27,6 +27,11 @@ class V8_EXPORT Date : public Object {
    */
   double ValueOf() const;
 
+  /**
+   * Generates ISO string representation.
+   */
+  v8::Local<v8::String> ToISOString() const;
+
   V8_INLINE static Date* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
diff --git a/NativeScript/include/v8-embedder-heap.h b/NativeScript/include/v8-embedder-heap.h
index 09dbae1f..9e2e3ef5 100644
--- a/NativeScript/include/v8-embedder-heap.h
+++ b/NativeScript/include/v8-embedder-heap.h
@@ -5,27 +5,14 @@
 #ifndef INCLUDE_V8_EMBEDDER_HEAP_H_
 #define INCLUDE_V8_EMBEDDER_HEAP_H_
 
-#include <stddef.h>
-#include <stdint.h>
-
-#include <utility>
-#include <vector>
-
-#include "cppgc/common.h"
-#include "v8-local-handle.h"   // NOLINT(build/include_directory)
 #include "v8-traced-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"          // NOLINT(build/include_directory)
 
 namespace v8 {
 
-class Data;
 class Isolate;
 class Value;
 
-namespace internal {
-class LocalEmbedderHeapTracer;
-}  // namespace internal
-
 /**
  * Handler for embedder roots on non-unified heap garbage collections.
  */
@@ -62,157 +49,6 @@ class V8_EXPORT EmbedderRootsHandler {
   virtual void ResetRoot(const v8::TracedReference<v8::Value>& handle) = 0;
 };
 
-/**
- * Interface for tracing through the embedder heap. During a V8 garbage
- * collection, V8 collects hidden fields of all potential wrappers, and at the
- * end of its marking phase iterates the collection and asks the embedder to
- * trace through its heap and use reporter to report each JavaScript object
- * reachable from any of the given wrappers.
- */
-class V8_EXPORT EmbedderHeapTracer {
- public:
-  using EmbedderStackState = cppgc::EmbedderStackState;
-
-  enum TraceFlags : uint64_t {
-    kNoFlags = 0,
-    kReduceMemory = 1 << 0,
-    kForced = 1 << 2,
-  };
-
-  /**
-   * Interface for iterating through |TracedReference| handles.
-   */
-  class V8_EXPORT TracedGlobalHandleVisitor {
-   public:
-    virtual ~TracedGlobalHandleVisitor() = default;
-    virtual void VisitTracedReference(const TracedReference<Value>& handle) {}
-  };
-
-  /**
-   * Summary of a garbage collection cycle. See |TraceEpilogue| on how the
-   * summary is reported.
-   */
-  struct TraceSummary {
-    /**
-     * Time spent managing the retained memory in milliseconds. This can e.g.
-     * include the time tracing through objects in the embedder.
-     */
-    double time = 0.0;
-
-    /**
-     * Memory retained by the embedder through the |EmbedderHeapTracer|
-     * mechanism in bytes.
-     */
-    size_t allocated_size = 0;
-  };
-
-  virtual ~EmbedderHeapTracer() = default;
-
-  /**
-   * Iterates all |TracedReference| handles created for the |v8::Isolate| the
-   * tracer is attached to.
-   */
-  void IterateTracedGlobalHandles(TracedGlobalHandleVisitor* visitor);
-
-  /**
-   * Called by the embedder to set the start of the stack which is e.g. used by
-   * V8 to determine whether handles are used from stack or heap.
-   */
-  void SetStackStart(void* stack_start);
-
-  /**
-   * Called by v8 to register internal fields of found wrappers.
-   *
-   * The embedder is expected to store them somewhere and trace reachable
-   * wrappers from them when called through |AdvanceTracing|.
-   */
-  virtual void RegisterV8References(
-      const std::vector<std::pair<void*, void*>>& embedder_fields) = 0;
-
-  void RegisterEmbedderReference(const BasicTracedReference<v8::Data>& ref);
-
-  /**
-   * Called at the beginning of a GC cycle.
-   */
-  virtual void TracePrologue(TraceFlags flags) {}
-
-  /**
-   * Called to advance tracing in the embedder.
-   *
-   * The embedder is expected to trace its heap starting from wrappers reported
-   * by RegisterV8References method, and report back all reachable wrappers.
-   * Furthermore, the embedder is expected to stop tracing by the given
-   * deadline. A deadline of infinity means that tracing should be finished.
-   *
-   * Returns |true| if tracing is done, and false otherwise.
-   */
-  virtual bool AdvanceTracing(double deadline_in_ms) = 0;
-
-  /*
-   * Returns true if there no more tracing work to be done (see AdvanceTracing)
-   * and false otherwise.
-   */
-  virtual bool IsTracingDone() = 0;
-
-  /**
-   * Called at the end of a GC cycle.
-   *
-   * Note that allocation is *not* allowed within |TraceEpilogue|. Can be
-   * overriden to fill a |TraceSummary| that is used by V8 to schedule future
-   * garbage collections.
-   */
-  virtual void TraceEpilogue(TraceSummary* trace_summary) {}
-
-  /**
-   * Called upon entering the final marking pause. No more incremental marking
-   * steps will follow this call.
-   */
-  virtual void EnterFinalPause(EmbedderStackState stack_state) = 0;
-
-  /*
-   * Called by the embedder to request immediate finalization of the currently
-   * running tracing phase that has been started with TracePrologue and not
-   * yet finished with TraceEpilogue.
-   *
-   * Will be a noop when currently not in tracing.
-   *
-   * This is an experimental feature.
-   */
-  void FinalizeTracing();
-
-  /**
-   * See documentation on EmbedderRootsHandler.
-   */
-  virtual bool IsRootForNonTracingGC(
-      const v8::TracedReference<v8::Value>& handle);
-
-  /**
-   * See documentation on EmbedderRootsHandler.
-   */
-  virtual void ResetHandleInNonTracingGC(
-      const v8::TracedReference<v8::Value>& handle);
-
-  /*
-   * Called by the embedder to signal newly allocated or freed memory. Not bound
-   * to tracing phases. Embedders should trade off when increments are reported
-   * as V8 may consult global heuristics on whether to trigger garbage
-   * collection on this change.
-   */
-  void IncreaseAllocatedSize(size_t bytes);
-  void DecreaseAllocatedSize(size_t bytes);
-
-  /*
-   * Returns the v8::Isolate this tracer is attached too and |nullptr| if it
-   * is not attached to any v8::Isolate.
-   */
-  v8::Isolate* isolate() const { return isolate_; }
-
- protected:
-  v8::Isolate* isolate_ = nullptr;
-
-  friend class internal::LocalEmbedderHeapTracer;
-};
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_EMBEDDER_HEAP_H_
diff --git a/NativeScript/include/v8-exception.h b/NativeScript/include/v8-exception.h
index 64126c42..bc058e3f 100644
--- a/NativeScript/include/v8-exception.h
+++ b/NativeScript/include/v8-exception.h
@@ -197,7 +197,7 @@ class V8_EXPORT TryCatch {
 
   void ResetInternal();
 
-  internal::Isolate* isolate_;
+  internal::Isolate* i_isolate_;
   TryCatch* next_;
   void* exception_;
   void* message_obj_;
diff --git a/NativeScript/include/v8-fast-api-calls.h b/NativeScript/include/v8-fast-api-calls.h
index 3403de93..0fe7cd24 100644
--- a/NativeScript/include/v8-fast-api-calls.h
+++ b/NativeScript/include/v8-fast-api-calls.h
@@ -240,13 +240,16 @@ class CTypeInfo {
   enum class Type : uint8_t {
     kVoid,
     kBool,
+    kUint8,
     kInt32,
     kUint32,
     kInt64,
     kUint64,
     kFloat32,
     kFloat64,
+    kPointer,
     kV8Value,
+    kSeqOneByteString,
     kApiObject,  // This will be deprecated once all users have
                  // migrated from v8::ApiObject to v8::Local<v8::Value>.
     kAny,        // This is added to enable untyped representation of fast
@@ -302,8 +305,9 @@ class CTypeInfo {
   constexpr Flags GetFlags() const { return flags_; }
 
   static constexpr bool IsIntegralType(Type type) {
-    return type == Type::kInt32 || type == Type::kUint32 ||
-           type == Type::kInt64 || type == Type::kUint64;
+    return type == Type::kUint8 || type == Type::kInt32 ||
+           type == Type::kUint32 || type == Type::kInt64 ||
+           type == Type::kUint64;
   }
 
   static constexpr bool IsFloatingPointType(Type type) {
@@ -377,6 +381,11 @@ struct FastApiArrayBuffer {
   size_t byte_length;
 };
 
+struct FastOneByteString {
+  const char* data;
+  uint32_t length;
+};
+
 class V8_EXPORT CFunctionInfo {
  public:
   // Construct a struct to hold a CFunction's type information.
@@ -427,14 +436,17 @@ struct AnyCType {
     uint64_t uint64_value;
     float float_value;
     double double_value;
+    void* pointer_value;
     Local<Object> object_value;
     Local<Array> sequence_value;
+    const FastApiTypedArray<uint8_t>* uint8_ta_value;
     const FastApiTypedArray<int32_t>* int32_ta_value;
     const FastApiTypedArray<uint32_t>* uint32_ta_value;
     const FastApiTypedArray<int64_t>* int64_ta_value;
     const FastApiTypedArray<uint64_t>* uint64_ta_value;
     const FastApiTypedArray<float>* float_ta_value;
     const FastApiTypedArray<double>* double_ta_value;
+    const FastOneByteString* string_value;
     FastApiCallbackOptions* options_value;
   };
 };
@@ -544,7 +556,7 @@ struct FastApiCallbackOptions {
    * returned instance may be filled with mock data.
    */
   static FastApiCallbackOptions CreateForTesting(Isolate* isolate) {
-    return {false, {0}};
+    return {false, {0}, nullptr};
   }
 
   /**
@@ -566,8 +578,13 @@ struct FastApiCallbackOptions {
    */
   union {
     uintptr_t data_ptr;
-    v8::Value data;
+    v8::Local<v8::Value> data;
   };
+
+  /**
+   * When called from WebAssembly, a view of the calling module's memory.
+   */
+  FastApiTypedArray<uint8_t>* const wasm_memory;
 };
 
 namespace internal {
@@ -605,8 +622,9 @@ class CFunctionInfoImpl : public CFunctionInfo {
                       kReturnType == CTypeInfo::Type::kUint32 ||
                       kReturnType == CTypeInfo::Type::kFloat32 ||
                       kReturnType == CTypeInfo::Type::kFloat64 ||
+                      kReturnType == CTypeInfo::Type::kPointer ||
                       kReturnType == CTypeInfo::Type::kAny,
-                  "64-bit int and api object values are not currently "
+                  "64-bit int, string and api object values are not currently "
                   "supported return types.");
   }
 
@@ -643,12 +661,14 @@ struct CTypeInfoTraits {};
 
 #define PRIMITIVE_C_TYPES(V) \
   V(bool, kBool)             \
+  V(uint8_t, kUint8)         \
   V(int32_t, kInt32)         \
   V(uint32_t, kUint32)       \
   V(int64_t, kInt64)         \
   V(uint64_t, kUint64)       \
   V(float, kFloat32)         \
-  V(double, kFloat64)
+  V(double, kFloat64)        \
+  V(void*, kPointer)
 
 // Same as above, but includes deprecated types for compatibility.
 #define ALL_C_TYPES(V)               \
@@ -682,6 +702,7 @@ PRIMITIVE_C_TYPES(DEFINE_TYPE_INFO_TRAITS)
   };
 
 #define TYPED_ARRAY_C_TYPES(V) \
+  V(uint8_t, kUint8)           \
   V(int32_t, kInt32)           \
   V(uint32_t, kUint32)         \
   V(int64_t, kInt64)           \
@@ -725,6 +746,18 @@ struct TypeInfoHelper<FastApiCallbackOptions&> {
   }
 };
 
+template <>
+struct TypeInfoHelper<const FastOneByteString&> {
+  static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
+
+  static constexpr CTypeInfo::Type Type() {
+    return CTypeInfo::Type::kSeqOneByteString;
+  }
+  static constexpr CTypeInfo::SequenceType SequenceType() {
+    return CTypeInfo::SequenceType::kScalar;
+  }
+};
+
 #define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG) \
   static_assert(((COND) == 0) || (ASSERTION), MSG)
 
@@ -802,6 +835,16 @@ class CFunctionBuilderWithFunction {
         std::make_index_sequence<sizeof...(ArgBuilders)>());
   }
 
+  // Provided for testing purposes.
+  template <typename Ret, typename... Args>
+  auto Patch(Ret (*patching_func)(Args...)) {
+    static_assert(
+        sizeof...(Args) == sizeof...(ArgBuilders),
+        "The patching function must have the same number of arguments.");
+    fn_ = reinterpret_cast<void*>(patching_func);
+    return *this;
+  }
+
   auto Build() {
     static CFunctionInfoImpl<RetBuilder, ArgBuilders...> instance;
     return CFunction(fn_, &instance);
@@ -881,31 +924,6 @@ static constexpr CTypeInfo kTypeInfoFloat64 =
  * to the requested destination type, is considered unsupported. The operation
  * returns true on success. `type_info` will be used for conversions.
  */
-template <const CTypeInfo* type_info, typename T>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-bool V8_EXPORT V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer(Local<Array> src, T* dst,
-                                      uint32_t max_length);
-
-template <>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-inline bool V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer<&kTypeInfoInt32, int32_t>(
-        Local<Array> src, int32_t* dst, uint32_t max_length) {
-  return false;
-}
-
-template <>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-inline bool V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer<&kTypeInfoFloat64, double>(
-        Local<Array> src, double* dst, uint32_t max_length) {
-  return false;
-}
-
 template <CTypeInfo::Identifier type_info_id, typename T>
 bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer(
     Local<Array> src, T* dst, uint32_t max_length);
diff --git a/NativeScript/include/v8-function.h b/NativeScript/include/v8-function.h
index 897e6ed6..2dc7e722 100644
--- a/NativeScript/include/v8-function.h
+++ b/NativeScript/include/v8-function.h
@@ -106,6 +106,14 @@ class V8_EXPORT Function : public Object {
   V8_WARN_UNUSED_RESULT MaybeLocal<String> FunctionProtoToString(
       Local<Context> context);
 
+  /**
+   * Returns true if the function does nothing.
+   * The function returns false on error.
+   * Note that this function is experimental. Embedders should not rely on
+   * this existing. We may remove this function in the future.
+   */
+  V8_WARN_UNUSED_RESULT bool Experimental_IsNopFunction() const;
+
   ScriptOrigin GetScriptOrigin() const;
   V8_INLINE static Function* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
diff --git a/NativeScript/include/v8-initialization.h b/NativeScript/include/v8-initialization.h
index 3d59c73f..d3e35d6e 100644
--- a/NativeScript/include/v8-initialization.h
+++ b/NativeScript/include/v8-initialization.h
@@ -100,9 +100,6 @@ class V8_EXPORT V8 {
     const int kBuildConfiguration =
         (internal::PointerCompressionIsEnabled() ? kPointerCompression : 0) |
         (internal::SmiValuesAre31Bits() ? k31BitSmis : 0) |
-        (internal::SandboxedExternalPointersAreEnabled()
-             ? kSandboxedExternalPointers
-             : 0) |
         (internal::SandboxIsEnabled() ? kSandbox : 0);
     return Initialize(kBuildConfiguration);
   }
@@ -184,30 +181,19 @@ class V8_EXPORT V8 {
    * V8 was disposed.
    */
   static void DisposePlatform();
-  V8_DEPRECATED("Use DisposePlatform()")
-  static void ShutdownPlatform() { DisposePlatform(); }
-
-#ifdef V8_SANDBOX
-  //
-  // Sandbox related API.
-  //
-  // This API is not yet stable and subject to changes in the future.
-  //
 
+#if defined(V8_ENABLE_SANDBOX)
   /**
-   * Initializes the V8 sandbox.
-   *
-   * This must be invoked after the platform was initialized but before V8 is
-   * initialized. The sandbox is torn down during platform shutdown.
-   * Returns true on success, false otherwise.
+   * Returns true if the sandbox is configured securely.
    *
-   * TODO(saelo) Once it is no longer optional to initialize the sandbox when
-   * compiling with V8_SANDBOX, the sandbox initialization will likely happen
-   * as part of V8::Initialize, at which point this function should be removed.
+   * If V8 cannot create a regular sandbox during initialization, for example
+   * because not enough virtual address space can be reserved, it will instead
+   * create a fallback sandbox that still allows it to function normally but
+   * does not have the same security properties as a regular sandbox. This API
+   * can be used to determine if such a fallback sandbox is being used, in
+   * which case it will return false.
    */
-  static bool InitializeSandbox();
-  V8_DEPRECATE_SOON("Use InitializeSandbox()")
-  static bool InitializeVirtualMemoryCage() { return InitializeSandbox(); }
+  static bool IsSandboxConfiguredSecurely();
 
   /**
    * Provides access to the virtual address subspace backing the sandbox.
@@ -220,39 +206,29 @@ class V8_EXPORT V8 {
    * and so in particular the contents of pages allocagted in this virtual
    * address space, arbitrarily and concurrently. Due to this, it is
    * recommended to to only place pure data buffers in them.
-   *
-   * This function must only be called after initializing the sandbox.
    */
   static VirtualAddressSpace* GetSandboxAddressSpace();
-  V8_DEPRECATE_SOON("Use GetSandboxAddressSpace()")
-  static PageAllocator* GetVirtualMemoryCagePageAllocator();
 
   /**
    * Returns the size of the sandbox in bytes.
    *
-   * If the sandbox has not been initialized, or if the initialization failed,
-   * this returns zero.
+   * This represents the size of the address space that V8 can directly address
+   * and in which it allocates its objects.
    */
   static size_t GetSandboxSizeInBytes();
-  V8_DEPRECATE_SOON("Use GetSandboxSizeInBytes()")
-  static size_t GetVirtualMemoryCageSizeInBytes() {
-    return GetSandboxSizeInBytes();
-  }
 
   /**
-   * Returns whether the sandbox is configured securely.
+   * Returns the size of the address space reservation backing the sandbox.
    *
-   * If V8 cannot create a proper sandbox, it will fall back to creating a
-   * sandbox that doesn't have the desired security properties but at least
-   * still allows V8 to function. This API can be used to determine if such an
-   * insecure sandbox is being used, in which case it will return false.
+   * This may be larger than the sandbox (i.e. |GetSandboxSizeInBytes()|) due
+   * to surrounding guard regions, or may be smaller than the sandbox in case a
+   * fallback sandbox is being used, which will use a smaller virtual address
+   * space reservation. In the latter case this will also be different from
+   * |GetSandboxAddressSpace()->size()| as that will cover a larger part of the
+   * address space than what has actually been reserved.
    */
-  static bool IsSandboxConfiguredSecurely();
-  V8_DEPRECATE_SOON("Use IsSandboxConfiguredSecurely()")
-  static bool IsUsingSecureVirtualMemoryCage() {
-    return IsSandboxConfiguredSecurely();
-  }
-#endif
+  static size_t GetSandboxReservationSizeInBytes();
+#endif  // V8_ENABLE_SANDBOX
 
   /**
    * Activate trap-based bounds checking for WebAssembly.
@@ -273,7 +249,7 @@ class V8_EXPORT V8 {
    * exceptions in V8-generated code.
    */
   static void SetUnhandledExceptionCallback(
-      UnhandledExceptionCallback unhandled_exception_callback);
+      UnhandledExceptionCallback callback);
 #endif
 
   /**
@@ -281,8 +257,7 @@ class V8_EXPORT V8 {
    * v8 has encountered a fatal failure to allocate memory and is about to
    * terminate.
    */
-
-  static void SetFatalMemoryErrorCallback(OOMErrorCallback oom_error_callback);
+  static void SetFatalMemoryErrorCallback(OOMErrorCallback callback);
 
   /**
    * Get statistics about the shared memory usage.
@@ -295,8 +270,7 @@ class V8_EXPORT V8 {
   enum BuildConfigurationFeatures {
     kPointerCompression = 1 << 0,
     k31BitSmis = 1 << 1,
-    kSandboxedExternalPointers = 1 << 2,
-    kSandbox = 1 << 3,
+    kSandbox = 1 << 2,
   };
 
   /**
diff --git a/NativeScript/include/v8-inspector.h b/NativeScript/include/v8-inspector.h
index ce5430bd..563ad196 100644
--- a/NativeScript/include/v8-inspector.h
+++ b/NativeScript/include/v8-inspector.h
@@ -32,19 +32,19 @@ namespace Debugger {
 namespace API {
 class SearchMatch;
 }
-}
+}  // namespace Debugger
 namespace Runtime {
 namespace API {
 class RemoteObject;
 class StackTrace;
 class StackTraceId;
-}
-}
+}  // namespace API
+}  // namespace Runtime
 namespace Schema {
 namespace API {
 class Domain;
 }
-}
+}  // namespace Schema
 }  // namespace protocol
 
 class V8_EXPORT StringView {
@@ -134,6 +134,13 @@ class V8_EXPORT V8DebuggerId {
   int64_t m_second = 0;
 };
 
+struct V8_EXPORT V8StackFrame {
+  StringView sourceURL;
+  StringView functionName;
+  int lineNumber;
+  int columnNumber;
+};
+
 class V8_EXPORT V8StackTrace {
  public:
   virtual StringView firstNonEmptySourceURL() const = 0;
@@ -151,6 +158,8 @@ class V8_EXPORT V8StackTrace {
 
   // Safe to pass between threads, drops async chain.
   virtual std::unique_ptr<V8StackTrace> clone() = 0;
+
+  virtual std::vector<V8StackFrame> frames() const = 0;
 };
 
 class V8_EXPORT V8InspectorSession {
@@ -203,14 +212,17 @@ class V8_EXPORT V8InspectorSession {
                             std::unique_ptr<StringBuffer>* objectGroup) = 0;
   virtual void releaseObjectGroup(StringView) = 0;
   virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
+
+  // Prepare for shutdown (disables debugger pausing, etc.).
+  virtual void stop() = 0;
 };
 
 class V8_EXPORT WebDriverValue {
  public:
-  explicit WebDriverValue(StringView type, v8::MaybeLocal<v8::Value> value = {})
-      : type(type), value(value) {}
-
-  StringView type;
+  explicit WebDriverValue(std::unique_ptr<StringBuffer> type,
+                          v8::MaybeLocal<v8::Value> value = {})
+      : type(std::move(type)), value(value) {}
+  std::unique_ptr<StringBuffer> type;
   v8::MaybeLocal<v8::Value> value;
 };
 
@@ -219,6 +231,9 @@ class V8_EXPORT V8InspectorClient {
   virtual ~V8InspectorClient() = default;
 
   virtual void runMessageLoopOnPause(int contextGroupId) {}
+  virtual void runMessageLoopOnInstrumentationPause(int contextGroupId) {
+    runMessageLoopOnPause(contextGroupId);
+  }
   virtual void quitMessageLoopOnPause() {}
   virtual void runIfWaitingForDebugger(int contextGroupId) {}
 
@@ -361,9 +376,15 @@ class V8_EXPORT V8Inspector {
     virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
     virtual void flushProtocolNotifications() = 0;
   };
-  virtual std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
-                                                      Channel*,
-                                                      StringView state) = 0;
+  enum ClientTrustLevel { kUntrusted, kFullyTrusted };
+  enum SessionPauseState { kWaitingForDebugger, kNotWaitingForDebugger };
+  // TODO(chromium:1352175): remove default value once downstream change lands.
+  virtual std::unique_ptr<V8InspectorSession> connect(
+      int contextGroupId, Channel*, StringView state,
+      ClientTrustLevel client_trust_level,
+      SessionPauseState = kNotWaitingForDebugger) {
+    return nullptr;
+  }
 
   // API methods.
   virtual std::unique_ptr<V8StackTrace> createStackTrace(
diff --git a/NativeScript/include/v8-internal.h b/NativeScript/include/v8-internal.h
index 37c5b336..53837aa5 100644
--- a/NativeScript/include/v8-internal.h
+++ b/NativeScript/include/v8-internal.h
@@ -8,6 +8,8 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
+
+#include <atomic>
 #include <type_traits>
 
 #include "v8-version.h"  // NOLINT(build/include_directory)
@@ -50,6 +52,7 @@ const int kHeapObjectTag = 1;
 const int kWeakHeapObjectTag = 3;
 const int kHeapObjectTagSize = 2;
 const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
+const intptr_t kHeapObjectReferenceTagMask = 1 << (kHeapObjectTagSize - 1);
 
 // Tag information for fowarding pointers stored in object headers.
 // 0b00 at the lowest 2 bits in the header indicates that the map word is a
@@ -157,15 +160,7 @@ V8_INLINE static constexpr internal::Address IntToSmi(int value) {
  * Sandbox related types, constants, and functions.
  */
 constexpr bool SandboxIsEnabled() {
-#ifdef V8_SANDBOX
-  return true;
-#else
-  return false;
-#endif
-}
-
-constexpr bool SandboxedExternalPointersAreEnabled() {
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
+#ifdef V8_ENABLE_SANDBOX
   return true;
 #else
   return false;
@@ -176,19 +171,18 @@ constexpr bool SandboxedExternalPointersAreEnabled() {
 // for example by storing them as offset rather than as raw pointers.
 using SandboxedPointer_t = Address;
 
-// ExternalPointers point to objects located outside the sandbox. When sandboxed
-// external pointers are enabled, these are stored in an external pointer table
-// and referenced from HeapObjects through indices.
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-using ExternalPointer_t = uint32_t;
-#else
-using ExternalPointer_t = Address;
-#endif
-
-#ifdef V8_SANDBOX_IS_AVAILABLE
+#ifdef V8_ENABLE_SANDBOX
 
 // Size of the sandbox, excluding the guard regions surrounding it.
+#ifdef V8_TARGET_OS_ANDROID
+// On Android, most 64-bit devices seem to be configured with only 39 bits of
+// virtual address space for userspace. As such, limit the sandbox to 128GB (a
+// quarter of the total available address space).
+constexpr size_t kSandboxSizeLog2 = 37;  // 128 GB
+#else
+// Everywhere else use a 1TB sandbox.
 constexpr size_t kSandboxSizeLog2 = 40;  // 1 TB
+#endif  // V8_TARGET_OS_ANDROID
 constexpr size_t kSandboxSize = 1ULL << kSandboxSizeLog2;
 
 // Required alignment of the sandbox. For simplicity, we require the
@@ -213,20 +207,6 @@ static_assert((kSandboxGuardRegionSize % kSandboxAlignment) == 0,
               "The size of the guard regions around the sandbox must be a "
               "multiple of its required alignment.");
 
-// Minimum size of the sandbox, excluding the guard regions surrounding it. If
-// the virtual memory reservation for the sandbox fails, its size is currently
-// halved until either the reservation succeeds or the minimum size is reached.
-// A minimum of 32GB allows the 4GB pointer compression region as well as the
-// ArrayBuffer partition and two 10GB Wasm memory cages to fit into the
-// sandbox. 32GB should also be the minimum possible size of the userspace
-// address space as there are some machine configurations with only 36 virtual
-// address bits.
-constexpr size_t kSandboxMinimumSize = 32ULL * GB;
-
-static_assert(kSandboxMinimumSize <= kSandboxSize,
-              "The minimal size of the sandbox must be smaller or equal to the "
-              "regular size.");
-
 // On OSes where reserving virtual memory is too expensive to reserve the
 // entire address space backing the sandbox, notably Windows pre 8.1, we create
 // a partially reserved sandbox that doesn't actually reserve most of the
@@ -239,82 +219,258 @@ static_assert(kSandboxMinimumSize <= kSandboxSize,
 // well as the ArrayBuffer partition.
 constexpr size_t kSandboxMinimumReservationSize = 8ULL * GB;
 
-static_assert(kSandboxMinimumSize > kPtrComprCageReservationSize,
-              "The sandbox must be larger than the pointer compression cage "
-              "contained within it.");
 static_assert(kSandboxMinimumReservationSize > kPtrComprCageReservationSize,
               "The minimum reservation size for a sandbox must be larger than "
               "the pointer compression cage contained within it.");
 
-// For now, even if the sandbox is enabled, we still allow backing stores to be
-// allocated outside of it as fallback. This will simplify the initial rollout.
-// However, if sandboxed pointers are also enabled, we must always place
-// backing stores inside the sandbox as they will be referenced though them.
-#ifdef V8_SANDBOXED_POINTERS
-constexpr bool kAllowBackingStoresOutsideSandbox = false;
-#else
-constexpr bool kAllowBackingStoresOutsideSandbox = true;
-#endif  // V8_SANDBOXED_POINTERS
+// The maximum buffer size allowed inside the sandbox. This is mostly dependent
+// on the size of the guard regions around the sandbox: an attacker must not be
+// able to construct a buffer that appears larger than the guard regions and
+// thereby "reach out of" the sandbox.
+constexpr size_t kMaxSafeBufferSizeForSandbox = 32ULL * GB - 1;
+static_assert(kMaxSafeBufferSizeForSandbox <= kSandboxGuardRegionSize,
+              "The maximum allowed buffer size must not be larger than the "
+              "sandbox's guard regions");
+
+constexpr size_t kBoundedSizeShift = 29;
+static_assert(1ULL << (64 - kBoundedSizeShift) ==
+                  kMaxSafeBufferSizeForSandbox + 1,
+              "The maximum size of a BoundedSize must be synchronized with the "
+              "kMaxSafeBufferSizeForSandbox");
+
+#endif  // V8_ENABLE_SANDBOX
+
+#ifdef V8_COMPRESS_POINTERS
 
+#ifdef V8_TARGET_OS_ANDROID
 // The size of the virtual memory reservation for an external pointer table.
 // This determines the maximum number of entries in a table. Using a maximum
 // size allows omitting bounds checks on table accesses if the indices are
 // guaranteed (e.g. through shifting) to be below the maximum index. This
 // value must be a power of two.
-static const size_t kExternalPointerTableReservationSize = 128 * MB;
-
-// The maximum number of entries in an external pointer table.
-static const size_t kMaxSandboxedExternalPointers =
-    kExternalPointerTableReservationSize / kApiSystemPointerSize;
+static const size_t kExternalPointerTableReservationSize = 512 * MB;
 
 // The external pointer table indices stored in HeapObjects as external
 // pointers are shifted to the left by this amount to guarantee that they are
 // smaller than the maximum table size.
-static const uint32_t kExternalPointerIndexShift = 8;
-static_assert((1 << (32 - kExternalPointerIndexShift)) ==
-                  kMaxSandboxedExternalPointers,
+static const uint32_t kExternalPointerIndexShift = 6;
+#else
+static const size_t kExternalPointerTableReservationSize = 1024 * MB;
+static const uint32_t kExternalPointerIndexShift = 5;
+#endif  // V8_TARGET_OS_ANDROID
+
+// The maximum number of entries in an external pointer table.
+static const size_t kMaxExternalPointers =
+    kExternalPointerTableReservationSize / kApiSystemPointerSize;
+static_assert((1 << (32 - kExternalPointerIndexShift)) == kMaxExternalPointers,
               "kExternalPointerTableReservationSize and "
               "kExternalPointerIndexShift don't match");
 
-#endif  // V8_SANDBOX_IS_AVAILABLE
-
-// If sandboxed external pointers are enabled, these tag values will be ORed
-// with the external pointers in the external pointer table to prevent use of
-// pointers of the wrong type. When a pointer is loaded, it is ANDed with the
-// inverse of the expected type's tag. The tags are constructed in a way that
-// guarantees that a failed type check will result in one or more of the top
-// bits of the pointer to be set, rendering the pointer inacessible. Besides
-// the type tag bits (48 through 62), the tags also have the GC mark bit (63)
-// set, so that the mark bit is automatically set when a pointer is written
-// into the external pointer table (in which case it is clearly alive) and is
-// cleared when the pointer is loaded. The exception to this is the free entry
-// tag, which doesn't have the mark bit set, as the entry is not alive. This
+#else  // !V8_COMPRESS_POINTERS
+
+// Needed for the V8.SandboxedExternalPointersCount histogram.
+static const size_t kMaxExternalPointers = 0;
+
+#endif  // V8_COMPRESS_POINTERS
+
+// A ExternalPointerHandle represents a (opaque) reference to an external
+// pointer that can be stored inside the sandbox. A ExternalPointerHandle has
+// meaning only in combination with an (active) Isolate as it references an
+// external pointer stored in the currently active Isolate's
+// ExternalPointerTable. Internally, an ExternalPointerHandles is simply an
+// index into an ExternalPointerTable that is shifted to the left to guarantee
+// that it is smaller than the size of the table.
+using ExternalPointerHandle = uint32_t;
+
+// ExternalPointers point to objects located outside the sandbox. When
+// sandboxed external pointers are enabled, these are stored on heap as
+// ExternalPointerHandles, otherwise they are simply raw pointers.
+#ifdef V8_ENABLE_SANDBOX
+using ExternalPointer_t = ExternalPointerHandle;
+#else
+using ExternalPointer_t = Address;
+#endif
+
+// When the sandbox is enabled, external pointers are stored in an external
+// pointer table and are referenced from HeapObjects through an index (a
+// "handle"). When stored in the table, the pointers are tagged with per-type
+// tags to prevent type confusion attacks between different external objects.
+// Besides type information bits, these tags also contain the GC marking bit
+// which indicates whether the pointer table entry is currently alive. When a
+// pointer is written into the table, the tag is ORed into the top bits. When
+// that pointer is later loaded from the table, it is ANDed with the inverse of
+// the expected tag. If the expected and actual type differ, this will leave
+// some of the top bits of the pointer set, rendering the pointer inaccessible.
+// The AND operation also removes the GC marking bit from the pointer.
+//
+// The tags are constructed such that UNTAG(TAG(0, T1), T2) != 0 for any two
+// (distinct) tags T1 and T2. In practice, this is achieved by generating tags
+// that all have the same number of zeroes and ones but different bit patterns.
+// With N type tag bits, this allows for (N choose N/2) possible type tags.
+// Besides the type tag bits, the tags also have the GC marking bit set so that
+// the marking bit is automatically set when a pointer is written into the
+// external pointer table (in which case it is clearly alive) and is cleared
+// when the pointer is loaded. The exception to this is the free entry tag,
+// which doesn't have the mark bit set, as the entry is not alive. This
 // construction allows performing the type check and removing GC marking bits
-// (the MSB) from the pointer at the same time.
-// Note: this scheme assumes a 48-bit address space and will likely break if
-// more virtual address bits are used.
-constexpr uint64_t kExternalPointerTagMask = 0xffff000000000000;
+// from the pointer in one efficient operation (bitwise AND). The number of
+// available bits is limited in the following way: on x64, bits [47, 64) are
+// generally available for tagging (userspace has 47 address bits available).
+// On Arm64, userspace typically has a 40 or 48 bit address space. However, due
+// to top-byte ignore (TBI) and memory tagging (MTE), the top byte is unusable
+// for type checks as type-check failures would go unnoticed or collide with
+// MTE bits. Some bits of the top byte can, however, still be used for the GC
+// marking bit. The bits available for the type tags are therefore limited to
+// [48, 56), i.e. (8 choose 4) = 70 different types.
+// The following options exist to increase the number of possible types:
+// - Using multiple ExternalPointerTables since tags can safely be reused
+//   across different tables
+// - Using "extended" type checks, where additional type information is stored
+//   either in an adjacent pointer table entry or at the pointed-to location
+// - Using a different tagging scheme, for example based on XOR which would
+//   allow for 2**8 different tags but require a separate operation to remove
+//   the marking bit
+//
+// The external pointer sandboxing mechanism ensures that every access to an
+// external pointer field will result in a valid pointer of the expected type
+// even in the presence of an attacker able to corrupt memory inside the
+// sandbox. However, if any data related to the external object is stored
+// inside the sandbox it may still be corrupted and so must be validated before
+// use or moved into the external object. Further, an attacker will always be
+// able to substitute different external pointers of the same type for each
+// other. Therefore, code using external pointers must be written in a
+// "substitution-safe" way, i.e. it must always be possible to substitute
+// external pointers of the same type without causing memory corruption outside
+// of the sandbox. Generally this is achieved by referencing any group of
+// related external objects through a single external pointer.
+//
+// Currently we use bit 62 for the marking bit which should always be unused as
+// it's part of the non-canonical address range. When Arm's top-byte ignore
+// (TBI) is enabled, this bit will be part of the ignored byte, and we assume
+// that the Embedder is not using this byte (really only this one bit) for any
+// other purpose. This bit also does not collide with the memory tagging
+// extension (MTE) which would use bits [56, 60).
+//
+// External pointer tables are also available even when the sandbox is off but
+// pointer compression is on. In that case, the mechanism can be used to easy
+// alignment requirements as it turns unaligned 64-bit raw pointers into
+// aligned 32-bit indices. To "opt-in" to the external pointer table mechanism
+// for this purpose, instead of using the ExternalPointer accessors one needs to
+// use ExternalPointerHandles directly and use them to access the pointers in an
+// ExternalPointerTable.
+constexpr uint64_t kExternalPointerMarkBit = 1ULL << 62;
+constexpr uint64_t kExternalPointerTagMask = 0x40ff000000000000;
 constexpr uint64_t kExternalPointerTagShift = 48;
-#define MAKE_TAG(v) (static_cast<uint64_t>(v) << kExternalPointerTagShift)
+
+// All possible 8-bit type tags.
+// These are sorted so that tags can be grouped together and it can efficiently
+// be checked if a tag belongs to a given group. See for example the
+// IsSharedExternalPointerType routine.
+constexpr uint64_t kAllExternalPointerTypeTags[] = {
+    0b00001111, 0b00010111, 0b00011011, 0b00011101, 0b00011110, 0b00100111,
+    0b00101011, 0b00101101, 0b00101110, 0b00110011, 0b00110101, 0b00110110,
+    0b00111001, 0b00111010, 0b00111100, 0b01000111, 0b01001011, 0b01001101,
+    0b01001110, 0b01010011, 0b01010101, 0b01010110, 0b01011001, 0b01011010,
+    0b01011100, 0b01100011, 0b01100101, 0b01100110, 0b01101001, 0b01101010,
+    0b01101100, 0b01110001, 0b01110010, 0b01110100, 0b01111000, 0b10000111,
+    0b10001011, 0b10001101, 0b10001110, 0b10010011, 0b10010101, 0b10010110,
+    0b10011001, 0b10011010, 0b10011100, 0b10100011, 0b10100101, 0b10100110,
+    0b10101001, 0b10101010, 0b10101100, 0b10110001, 0b10110010, 0b10110100,
+    0b10111000, 0b11000011, 0b11000101, 0b11000110, 0b11001001, 0b11001010,
+    0b11001100, 0b11010001, 0b11010010, 0b11010100, 0b11011000, 0b11100001,
+    0b11100010, 0b11100100, 0b11101000, 0b11110000};
+
+#define TAG(i)                                                    \
+  ((kAllExternalPointerTypeTags[i] << kExternalPointerTagShift) | \
+   kExternalPointerMarkBit)
+
 // clang-format off
+
+// When adding new tags, please ensure that the code using these tags is
+// "substitution-safe", i.e. still operate safely if external pointers of the
+// same type are swapped by an attacker. See comment above for more details.
+
+// Shared external pointers are owned by the shared Isolate and stored in the
+// shared external pointer table associated with that Isolate, where they can
+// be accessed from multiple threads at the same time. The objects referenced
+// in this way must therefore always be thread-safe.
+#define SHARED_EXTERNAL_POINTER_TAGS(V)                 \
+  V(kFirstSharedTag,                            TAG(0)) \
+  V(kWaiterQueueNodeTag,                        TAG(0)) \
+  V(kExternalStringResourceTag,                 TAG(1)) \
+  V(kExternalStringResourceDataTag,             TAG(2)) \
+  V(kLastSharedTag,                             TAG(2))
+
+// External pointers using these tags are kept in a per-Isolate external
+// pointer table and can only be accessed when this Isolate is active.
+#define PER_ISOLATE_EXTERNAL_POINTER_TAGS(V)             \
+  V(kForeignForeignAddressTag,                  TAG(10)) \
+  V(kNativeContextMicrotaskQueueTag,            TAG(11)) \
+  V(kEmbedderDataSlotPayloadTag,                TAG(12)) \
+/* This tag essentially stands for a `void*` pointer in the V8 API, and */ \
+/* it is the Embedder's responsibility to ensure type safety (against */   \
+/* substitution) and lifetime validity of these objects. */                \
+  V(kExternalObjectValueTag,                    TAG(13)) \
+  V(kCallHandlerInfoCallbackTag,                TAG(14)) \
+  V(kAccessorInfoGetterTag,                     TAG(15)) \
+  V(kAccessorInfoSetterTag,                     TAG(16)) \
+  V(kWasmInternalFunctionCallTargetTag,         TAG(17)) \
+  V(kWasmTypeInfoNativeTypeTag,                 TAG(18)) \
+  V(kWasmExportedFunctionDataSignatureTag,      TAG(19)) \
+  V(kWasmContinuationJmpbufTag,                 TAG(20)) \
+  V(kArrayBufferExtensionTag,                   TAG(21))
+
+// All external pointer tags.
+#define ALL_EXTERNAL_POINTER_TAGS(V) \
+  SHARED_EXTERNAL_POINTER_TAGS(V)    \
+  PER_ISOLATE_EXTERNAL_POINTER_TAGS(V)
+
+#define EXTERNAL_POINTER_TAG_ENUM(Name, Tag) Name = Tag,
+#define MAKE_TAG(HasMarkBit, TypeTag)                             \
+  ((static_cast<uint64_t>(TypeTag) << kExternalPointerTagShift) | \
+  (HasMarkBit ? kExternalPointerMarkBit : 0))
 enum ExternalPointerTag : uint64_t {
-  kExternalPointerNullTag =         MAKE_TAG(0b0000000000000000),
-  kExternalPointerFreeEntryTag =    MAKE_TAG(0b0111111110000000),
-  kExternalStringResourceTag =      MAKE_TAG(0b1000000011111111),
-  kExternalStringResourceDataTag =  MAKE_TAG(0b1000000101111111),
-  kForeignForeignAddressTag =       MAKE_TAG(0b1000000110111111),
-  kNativeContextMicrotaskQueueTag = MAKE_TAG(0b1000000111011111),
-  kEmbedderDataSlotPayloadTag =     MAKE_TAG(0b1000000111101111),
-  kCodeEntryPointTag =              MAKE_TAG(0b1000000111110111),
-  kExternalObjectValueTag =         MAKE_TAG(0b1000000111111011),
+  // Empty tag value. Mostly used as placeholder.
+  kExternalPointerNullTag =            MAKE_TAG(0, 0b00000000),
+  // External pointer tag that will match any external pointer. Use with care!
+  kAnyExternalPointerTag =             MAKE_TAG(1, 0b11111111),
+  // The free entry tag has all type bits set so every type check with a
+  // different type fails. It also doesn't have the mark bit set as free
+  // entries are (by definition) not alive.
+  kExternalPointerFreeEntryTag =       MAKE_TAG(0, 0b11111111),
+  // Evacuation entries are used during external pointer table compaction.
+  kExternalPointerEvacuationEntryTag = MAKE_TAG(1, 0b11100111),
+
+  ALL_EXTERNAL_POINTER_TAGS(EXTERNAL_POINTER_TAG_ENUM)
 };
-// clang-format on
+
 #undef MAKE_TAG
+#undef TAG
+#undef EXTERNAL_POINTER_TAG_ENUM
+
+// clang-format on
+
+// True if the external pointer must be accessed from the shared isolate's
+// external pointer table.
+V8_INLINE static constexpr bool IsSharedExternalPointerType(
+    ExternalPointerTag tag) {
+  return tag >= kFirstSharedTag && tag <= kLastSharedTag;
+}
 
-// Converts encoded external pointer to address.
-V8_EXPORT Address DecodeExternalPointerImpl(const Isolate* isolate,
-                                            ExternalPointer_t pointer,
-                                            ExternalPointerTag tag);
+// Sanity checks.
+#define CHECK_SHARED_EXTERNAL_POINTER_TAGS(Tag, ...) \
+  static_assert(IsSharedExternalPointerType(Tag));
+#define CHECK_NON_SHARED_EXTERNAL_POINTER_TAGS(Tag, ...) \
+  static_assert(!IsSharedExternalPointerType(Tag));
+
+SHARED_EXTERNAL_POINTER_TAGS(CHECK_SHARED_EXTERNAL_POINTER_TAGS)
+PER_ISOLATE_EXTERNAL_POINTER_TAGS(CHECK_NON_SHARED_EXTERNAL_POINTER_TAGS)
+
+#undef CHECK_NON_SHARED_EXTERNAL_POINTER_TAGS
+#undef CHECK_SHARED_EXTERNAL_POINTER_TAGS
+
+#undef SHARED_EXTERNAL_POINTER_TAGS
+#undef EXTERNAL_POINTER_TAGS
 
 // {obj} must be the raw tagged pointer representation of a HeapObject
 // that's guaranteed to never be in ReadOnlySpace.
@@ -324,9 +480,6 @@ V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj);
 // mode based on the current context and the closure. This returns true if the
 // language mode is strict.
 V8_EXPORT bool ShouldThrowOnError(v8::internal::Isolate* isolate);
-
-V8_EXPORT bool CanHaveInternalField(int instance_type);
-
 /**
  * This class exports constants and functionality from within v8 that
  * is necessary to implement inline functions in the v8 api.  Don't
@@ -354,8 +507,10 @@ class Internals {
   static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;
   static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;
   static const int kEmbedderDataSlotSize = kApiSystemPointerSize;
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-  static const int kEmbedderDataSlotRawPayloadOffset = kApiTaggedSize;
+#ifdef V8_ENABLE_SANDBOX
+  static const int kEmbedderDataSlotExternalPointerOffset = kApiTaggedSize;
+#else
+  static const int kEmbedderDataSlotExternalPointerOffset = 0;
 #endif
   static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize;
   static const int kStringRepresentationAndEncodingMask = 0x0f;
@@ -365,15 +520,21 @@ class Internals {
 
   static const uint32_t kNumIsolateDataSlots = 4;
   static const int kStackGuardSize = 7 * kApiSystemPointerSize;
-  static const int kBuiltinTier0EntryTableSize = 9 * kApiSystemPointerSize;
-  static const int kBuiltinTier0TableSize = 9 * kApiSystemPointerSize;
+  static const int kBuiltinTier0EntryTableSize = 7 * kApiSystemPointerSize;
+  static const int kBuiltinTier0TableSize = 7 * kApiSystemPointerSize;
+
+  // ExternalPointerTable layout guarantees.
+  static const int kExternalPointerTableBufferOffset = 0;
+  static const int kExternalPointerTableSize = 4 * kApiSystemPointerSize;
 
   // IsolateData layout guarantees.
   static const int kIsolateCageBaseOffset = 0;
   static const int kIsolateStackGuardOffset =
       kIsolateCageBaseOffset + kApiSystemPointerSize;
-  static const int kBuiltinTier0EntryTableOffset =
+  static const int kVariousBooleanFlagsOffset =
       kIsolateStackGuardOffset + kStackGuardSize;
+  static const int kBuiltinTier0EntryTableOffset =
+      kVariousBooleanFlagsOffset + 8;
   static const int kBuiltinTier0TableOffset =
       kBuiltinTier0EntryTableOffset + kBuiltinTier0EntryTableSize;
   static const int kIsolateEmbedderDataOffset =
@@ -386,14 +547,17 @@ class Internals {
       kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize;
   static const int kIsolateLongTaskStatsCounterOffset =
       kIsolateFastApiCallTargetOffset + kApiSystemPointerSize;
+#ifdef V8_COMPRESS_POINTERS
+  static const int kIsolateExternalPointerTableOffset =
+      kIsolateLongTaskStatsCounterOffset + kApiSizetSize;
+  static const int kIsolateSharedExternalPointerTableAddressOffset =
+      kIsolateExternalPointerTableOffset + kExternalPointerTableSize;
+  static const int kIsolateRootsOffset =
+      kIsolateSharedExternalPointerTableAddressOffset + kApiSystemPointerSize;
+#else
   static const int kIsolateRootsOffset =
       kIsolateLongTaskStatsCounterOffset + kApiSizetSize;
-
-  static const int kExternalPointerTableBufferOffset = 0;
-  static const int kExternalPointerTableCapacityOffset =
-      kExternalPointerTableBufferOffset + kApiSystemPointerSize;
-  static const int kExternalPointerTableFreelistHeadOffset =
-      kExternalPointerTableCapacityOffset + kApiInt32Size;
+#endif
 
   static const int kUndefinedValueRootIndex = 4;
   static const int kTheHoleValueRootIndex = 5;
@@ -404,9 +568,10 @@ class Internals {
 
   static const int kNodeClassIdOffset = 1 * kApiSystemPointerSize;
   static const int kNodeFlagsOffset = 1 * kApiSystemPointerSize + 3;
-  static const int kNodeStateMask = 0x7;
+  static const int kNodeStateMask = 0x3;
   static const int kNodeStateIsWeakValue = 2;
-  static const int kNodeStateIsPendingValue = 3;
+
+  static const int kTracedNodeClassIdOffset = kApiSystemPointerSize;
 
   static const int kFirstNonstringType = 0x80;
   static const int kOddballType = 0x83;
@@ -481,6 +646,18 @@ class Internals {
     return representation == kExternalTwoByteRepresentationTag;
   }
 
+  V8_INLINE static constexpr bool CanHaveInternalField(int instance_type) {
+    static_assert(kJSObjectType + 1 == kFirstJSApiObjectType);
+    static_assert(kJSObjectType < kLastJSApiObjectType);
+    static_assert(kFirstJSApiObjectType < kLastJSApiObjectType);
+    // Check for IsJSObject() || IsJSSpecialApiObject() || IsJSApiObject()
+    return instance_type == kJSSpecialApiObjectType ||
+           // inlined version of base::IsInRange
+           (static_cast<unsigned>(static_cast<unsigned>(instance_type) -
+                                  static_cast<unsigned>(kJSObjectType)) <=
+            static_cast<unsigned>(kLastJSApiObjectType - kJSObjectType));
+  }
+
   V8_INLINE static uint8_t GetNodeFlag(internal::Address* obj, int shift) {
     uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
     return *addr & static_cast<uint8_t>(1U << shift);
@@ -532,6 +709,25 @@ class Internals {
     return reinterpret_cast<internal::Address*>(addr);
   }
 
+#ifdef V8_ENABLE_SANDBOX
+  V8_INLINE static internal::Address* GetExternalPointerTableBase(
+      v8::Isolate* isolate) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateExternalPointerTableOffset +
+                             kExternalPointerTableBufferOffset;
+    return *reinterpret_cast<internal::Address**>(addr);
+  }
+
+  V8_INLINE static internal::Address* GetSharedExternalPointerTableBase(
+      v8::Isolate* isolate) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateSharedExternalPointerTableAddressOffset;
+    addr = *reinterpret_cast<internal::Address*>(addr);
+    addr += kExternalPointerTableBufferOffset;
+    return *reinterpret_cast<internal::Address**>(addr);
+  }
+#endif
+
   template <typename T>
   V8_INLINE static T ReadRawField(internal::Address heap_object_ptr,
                                   int offset) {
@@ -572,38 +768,37 @@ class Internals {
 #endif
   }
 
-  V8_INLINE static internal::Isolate* GetIsolateForSandbox(
-      internal::Address obj) {
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-    return internal::IsolateFromNeverReadOnlySpaceObject(obj);
+  V8_INLINE static v8::Isolate* GetIsolateForSandbox(internal::Address obj) {
+#ifdef V8_ENABLE_SANDBOX
+    return reinterpret_cast<v8::Isolate*>(
+        internal::IsolateFromNeverReadOnlySpaceObject(obj));
 #else
     // Not used in non-sandbox mode.
     return nullptr;
 #endif
   }
 
-  V8_INLINE static Address DecodeExternalPointer(
-      const Isolate* isolate, ExternalPointer_t encoded_pointer,
-      ExternalPointerTag tag) {
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-    return internal::DecodeExternalPointerImpl(isolate, encoded_pointer, tag);
-#else
-    return encoded_pointer;
-#endif
-  }
-
+  template <ExternalPointerTag tag>
   V8_INLINE static internal::Address ReadExternalPointerField(
-      internal::Isolate* isolate, internal::Address heap_object_ptr, int offset,
-      ExternalPointerTag tag) {
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-    internal::ExternalPointer_t encoded_value =
-        ReadRawField<uint32_t>(heap_object_ptr, offset);
-    // We currently have to treat zero as nullptr in embedder slots.
-    return encoded_value ? DecodeExternalPointer(isolate, encoded_value, tag)
-                         : 0;
+      v8::Isolate* isolate, internal::Address heap_object_ptr, int offset) {
+#ifdef V8_ENABLE_SANDBOX
+    static_assert(tag != kExternalPointerNullTag);
+    // See src/sandbox/external-pointer-table-inl.h. Logic duplicated here so
+    // it can be inlined and doesn't require an additional call.
+    internal::Address* table = IsSharedExternalPointerType(tag)
+                                   ? GetSharedExternalPointerTableBase(isolate)
+                                   : GetExternalPointerTableBase(isolate);
+    internal::ExternalPointerHandle handle =
+        ReadRawField<ExternalPointerHandle>(heap_object_ptr, offset);
+    uint32_t index = handle >> kExternalPointerIndexShift;
+    std::atomic<internal::Address>* ptr =
+        reinterpret_cast<std::atomic<internal::Address>*>(&table[index]);
+    internal::Address entry =
+        std::atomic_load_explicit(ptr, std::memory_order_relaxed);
+    return entry & ~tag;
 #else
     return ReadRawField<Address>(heap_object_ptr, offset);
-#endif
+#endif  // V8_ENABLE_SANDBOX
   }
 
 #ifdef V8_COMPRESS_POINTERS
@@ -652,7 +847,7 @@ class BackingStoreBase {};
 
 // The maximum value in enum GarbageCollectionReason, defined in heap.h.
 // This is needed for histograms sampling garbage collection reasons.
-constexpr int kGarbageCollectionReasonMaxValue = 25;
+constexpr int kGarbageCollectionReasonMaxValue = 27;
 
 }  // namespace internal
 
diff --git a/NativeScript/include/v8-isolate.h b/NativeScript/include/v8-isolate.h
index 2849d7ca..4571b2c3 100644
--- a/NativeScript/include/v8-isolate.h
+++ b/NativeScript/include/v8-isolate.h
@@ -194,6 +194,11 @@ enum RAILMode : unsigned {
  */
 enum class MemoryPressureLevel { kNone, kModerate, kCritical };
 
+/**
+ * Indicator for the stack state.
+ */
+using StackState = cppgc::EmbedderStackState;
+
 /**
  * Isolate represents an isolated instance of the V8 engine.  V8 isolates have
  * completely separate states.  Objects from one isolate must not be used in
@@ -211,6 +216,8 @@ class V8_EXPORT Isolate {
     CreateParams();
     ~CreateParams();
 
+    ALLOW_COPY_AND_MOVE_WITH_DEPRECATED_FIELDS(CreateParams)
+
     /**
      * Allows the host application to provide the address of a function that is
      * notified each time code is added, moved or removed.
@@ -226,7 +233,7 @@ class V8_EXPORT Isolate {
      * Explicitly specify a startup snapshot blob. The embedder owns the blob.
      * The embedder *must* ensure that the snapshot is from a trusted source.
      */
-    StartupData* snapshot_blob = nullptr;
+    const StartupData* snapshot_blob = nullptr;
 
     /**
      * Enables the host application to provide a mechanism for recording
@@ -287,12 +294,6 @@ class V8_EXPORT Isolate {
      */
     FatalErrorCallback fatal_error_callback = nullptr;
     OOMErrorCallback oom_error_callback = nullptr;
-
-    /**
-     * The following parameter is experimental and may change significantly.
-     * This is currently for internal testing.
-     */
-    Isolate* experimental_attach_to_shared_isolate = nullptr;
   };
 
   /**
@@ -301,16 +302,18 @@ class V8_EXPORT Isolate {
    */
   class V8_EXPORT V8_NODISCARD Scope {
    public:
-    explicit Scope(Isolate* isolate) : isolate_(isolate) { isolate->Enter(); }
+    explicit Scope(Isolate* isolate) : v8_isolate_(isolate) {
+      v8_isolate_->Enter();
+    }
 
-    ~Scope() { isolate_->Exit(); }
+    ~Scope() { v8_isolate_->Exit(); }
 
     // Prevent copying of Scope objects.
     Scope(const Scope&) = delete;
     Scope& operator=(const Scope&) = delete;
 
    private:
-    Isolate* const isolate_;
+    Isolate* const v8_isolate_;
   };
 
   /**
@@ -331,7 +334,7 @@ class V8_EXPORT Isolate {
 
    private:
     OnFailure on_failure_;
-    Isolate* isolate_;
+    v8::Isolate* v8_isolate_;
 
     bool was_execution_allowed_assert_;
     bool was_execution_allowed_throws_;
@@ -353,7 +356,7 @@ class V8_EXPORT Isolate {
         const AllowJavascriptExecutionScope&) = delete;
 
    private:
-    Isolate* isolate_;
+    Isolate* v8_isolate_;
     bool was_execution_allowed_assert_;
     bool was_execution_allowed_throws_;
     bool was_execution_allowed_dump_;
@@ -376,7 +379,7 @@ class V8_EXPORT Isolate {
         const SuppressMicrotaskExecutionScope&) = delete;
 
    private:
-    internal::Isolate* const isolate_;
+    internal::Isolate* const i_isolate_;
     internal::MicrotaskQueue* const microtask_queue_;
     internal::Address previous_stack_height_;
 
@@ -389,7 +392,7 @@ class V8_EXPORT Isolate {
    */
   class V8_EXPORT V8_NODISCARD SafeForTerminationScope {
    public:
-    explicit SafeForTerminationScope(v8::Isolate* isolate);
+    explicit SafeForTerminationScope(v8::Isolate* v8_isolate);
     ~SafeForTerminationScope();
 
     // Prevent copying of Scope objects.
@@ -397,7 +400,7 @@ class V8_EXPORT Isolate {
     SafeForTerminationScope& operator=(const SafeForTerminationScope&) = delete;
 
    private:
-    internal::Isolate* isolate_;
+    internal::Isolate* i_isolate_;
     bool prev_value_;
   };
 
@@ -531,6 +534,10 @@ class V8_EXPORT Isolate {
     kInvalidatedMegaDOMProtector = 112,
     kFunctionPrototypeArguments = 113,
     kFunctionPrototypeCaller = 114,
+    kTurboFanOsrCompileStarted = 115,
+    kAsyncStackTaggingCreateTaskCall = 116,
+    kDurationFormat = 117,
+    kInvalidatedNumberStringPrototypeNoReplaceProtector = 118,
 
     // If you add new values here, you'll also need to update Chromium's:
     // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to
@@ -636,9 +643,6 @@ class V8_EXPORT Isolate {
    * This specifies the callback called by the upcoming dynamic
    * import() language feature to load modules.
    */
-  V8_DEPRECATED("Use HostImportModuleDynamicallyCallback")
-  void SetHostImportModuleDynamicallyCallback(
-      HostImportModuleDynamicallyWithImportAssertionsCallback callback);
   void SetHostImportModuleDynamicallyCallback(
       HostImportModuleDynamicallyCallback callback);
 
@@ -839,12 +843,6 @@ class V8_EXPORT Isolate {
    */
   int64_t AdjustAmountOfExternalAllocatedMemory(int64_t change_in_bytes);
 
-  /**
-   * Returns the number of phantom handles without callbacks that were reset
-   * by the garbage collector since the last call to this function.
-   */
-  size_t NumberOfPhantomHandleResetsSinceLastCall();
-
   /**
    * Returns heap profiler for this isolate. Will return NULL until the isolate
    * is initialized.
@@ -927,25 +925,10 @@ class V8_EXPORT Isolate {
   void RemoveGCPrologueCallback(GCCallbackWithData, void* data = nullptr);
   void RemoveGCPrologueCallback(GCCallback callback);
 
-  /**
-   * Sets the embedder heap tracer for the isolate.
-   * SetEmbedderHeapTracer cannot be used simultaneously with AttachCppHeap.
-   */
-  void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer);
-
-  /*
-   * Gets the currently active heap tracer for the isolate that was set with
-   * SetEmbedderHeapTracer.
-   */
-  EmbedderHeapTracer* GetEmbedderHeapTracer();
-
   /**
    * Sets an embedder roots handle that V8 should consider when performing
-   * non-unified heap garbage collections.
-   *
-   * Using only EmbedderHeapTracer automatically sets up a default handler.
-   * The intended use case is for setting a custom handler after invoking
-   * `AttachCppHeap()`.
+   * non-unified heap garbage collections. The intended use case is for setting
+   * a custom handler after invoking `AttachCppHeap()`.
    *
    * V8 does not take ownership of the handler.
    */
@@ -955,22 +938,18 @@ class V8_EXPORT Isolate {
    * Attaches a managed C++ heap as an extension to the JavaScript heap. The
    * embedder maintains ownership of the CppHeap. At most one C++ heap can be
    * attached to V8.
-   * AttachCppHeap cannot be used simultaneously with SetEmbedderHeapTracer.
    *
-   * This is an experimental feature and may still change significantly.
+   * Multi-threaded use requires the use of v8::Locker/v8::Unlocker, see
+   * CppHeap.
    */
   void AttachCppHeap(CppHeap*);
 
   /**
    * Detaches a managed C++ heap if one was attached using `AttachCppHeap()`.
-   *
-   * This is an experimental feature and may still change significantly.
    */
   void DetachCppHeap();
 
   /**
-   * This is an experimental feature and may still change significantly.
-
    * \returns the C++ heap managed by V8. Only available if such a heap has been
    *   attached using `AttachCppHeap()`.
    */
@@ -1163,9 +1142,8 @@ class V8_EXPORT Isolate {
    * LowMemoryNotification() instead to influence the garbage collection
    * schedule.
    */
-  void RequestGarbageCollectionForTesting(
-      GarbageCollectionType type,
-      EmbedderHeapTracer::EmbedderStackState stack_state);
+  void RequestGarbageCollectionForTesting(GarbageCollectionType type,
+                                          StackState stack_state);
 
   /**
    * Set the callback to invoke for logging event.
@@ -1350,11 +1328,13 @@ class V8_EXPORT Isolate {
    * V8 uses this notification to guide heuristics which may result in a
    * smaller memory footprint at the cost of reduced runtime performance.
    */
+  V8_DEPRECATED("Use IsolateInBackgroundNotification() instead")
   void EnableMemorySavingsMode();
 
   /**
    * Optional notification which will disable the memory savings mode.
    */
+  V8_DEPRECATED("Use IsolateInBackgroundNotification() instead")
   void DisableMemorySavingsMode();
 
   /**
@@ -1523,14 +1503,23 @@ class V8_EXPORT Isolate {
 
   void SetWasmStreamingCallback(WasmStreamingCallback callback);
 
+  void SetWasmAsyncResolvePromiseCallback(
+      WasmAsyncResolvePromiseCallback callback);
+
   void SetWasmLoadSourceMapCallback(WasmLoadSourceMapCallback callback);
 
+  V8_DEPRECATED("Wasm SIMD is always enabled")
   void SetWasmSimdEnabledCallback(WasmSimdEnabledCallback callback);
 
+  V8_DEPRECATED("Wasm exceptions are always enabled")
   void SetWasmExceptionsEnabledCallback(WasmExceptionsEnabledCallback callback);
 
-  void SetWasmDynamicTieringEnabledCallback(
-      WasmDynamicTieringEnabledCallback callback);
+  /**
+   * Register callback to control whehter Wasm GC is enabled.
+   * The callback overwrites the value of the flag.
+   * If the callback returns true, it will also enable Wasm stringrefs.
+   */
+  void SetWasmGCEnabledCallback(WasmGCEnabledCallback callback);
 
   void SetSharedArrayBufferConstructorEnabledCallback(
       SharedArrayBufferConstructorEnabledCallback callback);
@@ -1598,19 +1587,6 @@ class V8_EXPORT Isolate {
    */
   void VisitExternalResources(ExternalResourceVisitor* visitor);
 
-  /**
-   * Iterates through all the persistent handles in the current isolate's heap
-   * that have class_ids.
-   */
-  void VisitHandlesWithClassIds(PersistentHandleVisitor* visitor);
-
-  /**
-   * Iterates through all the persistent handles in the current isolate's heap
-   * that have class_ids and are weak to be marked as inactive if there is no
-   * pending activity for the handle.
-   */
-  void VisitWeakHandles(PersistentHandleVisitor* visitor);
-
   /**
    * Check if this isolate is in use.
    * True if at least one thread Enter'ed this isolate.
diff --git a/NativeScript/include/v8-local-handle.h b/NativeScript/include/v8-local-handle.h
index 5ae97408..633c5633 100644
--- a/NativeScript/include/v8-local-handle.h
+++ b/NativeScript/include/v8-local-handle.h
@@ -53,6 +53,7 @@ class Utils;
 namespace internal {
 template <typename T>
 class CustomArguments;
+class SamplingHeapProfiler;
 }  // namespace internal
 
 namespace api_internal {
@@ -86,7 +87,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   static int NumberOfHandles(Isolate* isolate);
 
   V8_INLINE Isolate* GetIsolate() const {
-    return reinterpret_cast<Isolate*>(isolate_);
+    return reinterpret_cast<Isolate*>(i_isolate_);
   }
 
   HandleScope(const HandleScope&) = delete;
@@ -97,7 +98,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
 
   void Initialize(Isolate* isolate);
 
-  static internal::Address* CreateHandle(internal::Isolate* isolate,
+  static internal::Address* CreateHandle(internal::Isolate* i_isolate,
                                          internal::Address value);
 
  private:
@@ -108,7 +109,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   void operator delete(void*, size_t);
   void operator delete[](void*, size_t);
 
-  internal::Isolate* isolate_;
+  internal::Isolate* i_isolate_;
   internal::Address* prev_next_;
   internal::Address* prev_limit_;
 
@@ -313,6 +314,7 @@ class Local {
   friend class BasicTracedReference;
   template <class F>
   friend class TracedReference;
+  friend class v8::internal::SamplingHeapProfiler;
 
   explicit V8_INLINE Local(T* that) : val_(that) {}
   V8_INLINE static Local<T> New(Isolate* isolate, T* that) {
@@ -354,7 +356,7 @@ class MaybeLocal {
 
   /**
    * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty,
-   * |false| is returned and |out| is left untouched.
+   * |false| is returned and |out| is assigned with nullptr.
    */
   template <class S>
   V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S>* out) const {
@@ -445,7 +447,7 @@ class V8_EXPORT V8_NODISCARD SealHandleScope {
   void operator delete(void*, size_t);
   void operator delete[](void*, size_t);
 
-  internal::Isolate* const isolate_;
+  internal::Isolate* const i_isolate_;
   internal::Address* prev_limit_;
   int prev_sealed_level_;
 };
diff --git a/NativeScript/include/v8-locker.h b/NativeScript/include/v8-locker.h
index 7ca5bf6e..22b7a876 100644
--- a/NativeScript/include/v8-locker.h
+++ b/NativeScript/include/v8-locker.h
@@ -121,17 +121,6 @@ class V8_EXPORT Locker {
    */
   static bool IsLocked(Isolate* isolate);
 
-  /**
-   * Returns whether any v8::Locker has ever been used in this process.
-   * TODO(cbruni, chromium:1240851): Fix locking checks on a per-thread basis.
-   * The current implementation is quite confusing and leads to unexpected
-   * results if anybody uses v8::Locker in the current process.
-   */
-  V8_DEPRECATE_SOON("This method will be removed.")
-  static bool WasEverUsed();
-  V8_DEPRECATED("Use WasEverUsed instead")
-  static bool IsActive();
-
   // Disallow copying and assigning.
   Locker(const Locker&) = delete;
   void operator=(const Locker&) = delete;
diff --git a/NativeScript/include/v8-maybe.h b/NativeScript/include/v8-maybe.h
index 0532a510..8d3aeabe 100644
--- a/NativeScript/include/v8-maybe.h
+++ b/NativeScript/include/v8-maybe.h
@@ -5,6 +5,9 @@
 #ifndef INCLUDE_V8_MAYBE_H_
 #define INCLUDE_V8_MAYBE_H_
 
+#include <type_traits>
+#include <utility>
+
 #include "v8-internal.h"  // NOLINT(build/include_directory)
 #include "v8config.h"     // NOLINT(build/include_directory)
 
@@ -57,11 +60,20 @@ class Maybe {
    * Converts this Maybe<> to a value of type T. If this Maybe<> is
    * nothing (empty), V8 will crash the process.
    */
-  V8_INLINE T FromJust() const {
+  V8_INLINE T FromJust() const& {
     if (V8_UNLIKELY(!IsJust())) api_internal::FromJustIsNothing();
     return value_;
   }
 
+  /**
+   * Converts this Maybe<> to a value of type T. If this Maybe<> is
+   * nothing (empty), V8 will crash the process.
+   */
+  V8_INLINE T FromJust() && {
+    if (V8_UNLIKELY(!IsJust())) api_internal::FromJustIsNothing();
+    return std::move(value_);
+  }
+
   /**
    * Converts this Maybe<> to a value of type T, using a default value if this
    * Maybe<> is nothing (empty).
@@ -82,6 +94,7 @@ class Maybe {
  private:
   Maybe() : has_value_(false) {}
   explicit Maybe(const T& t) : has_value_(true), value_(t) {}
+  explicit Maybe(T&& t) : has_value_(true), value_(std::move(t)) {}
 
   bool has_value_;
   T value_;
@@ -90,6 +103,8 @@ class Maybe {
   friend Maybe<U> Nothing();
   template <class U>
   friend Maybe<U> Just(const U& u);
+  template <class U, std::enable_if_t<!std::is_lvalue_reference_v<U>>*>
+  friend Maybe<U> Just(U&& u);
 };
 
 template <class T>
@@ -102,6 +117,14 @@ inline Maybe<T> Just(const T& t) {
   return Maybe<T>(t);
 }
 
+// Don't use forwarding references here but instead use two overloads.
+// Forwarding references only work when type deduction takes place, which is not
+// the case for callsites such as Just<Type>(t).
+template <class T, std::enable_if_t<!std::is_lvalue_reference_v<T>>* = nullptr>
+inline Maybe<T> Just(T&& t) {
+  return Maybe<T>(std::move(t));
+}
+
 // A template specialization of Maybe<T> for the case of T = void.
 template <>
 class Maybe<void> {
diff --git a/NativeScript/include/v8-message.h b/NativeScript/include/v8-message.h
index a1327641..09f9a0a9 100644
--- a/NativeScript/include/v8-message.h
+++ b/NativeScript/include/v8-message.h
@@ -70,7 +70,7 @@ class V8_EXPORT ScriptOrigin {
                          bool resource_is_opaque = false, bool is_wasm = false,
                          bool is_module = false,
                          Local<Data> host_defined_options = Local<Data>())
-      : isolate_(isolate),
+      : v8_isolate_(isolate),
         resource_name_(resource_name),
         resource_line_offset_(resource_line_offset),
         resource_column_offset_(resource_column_offset),
@@ -87,14 +87,12 @@ class V8_EXPORT ScriptOrigin {
   V8_INLINE int ColumnOffset() const;
   V8_INLINE int ScriptId() const;
   V8_INLINE Local<Value> SourceMapUrl() const;
-  V8_DEPRECATE_SOON("Use GetHostDefinedOptions")
-  Local<PrimitiveArray> HostDefinedOptions() const;
   V8_INLINE Local<Data> GetHostDefinedOptions() const;
   V8_INLINE ScriptOriginOptions Options() const { return options_; }
 
  private:
   void VerifyHostDefinedOptions() const;
-  Isolate* isolate_;
+  Isolate* v8_isolate_;
   Local<Value> resource_name_;
   int resource_line_offset_;
   int resource_column_offset_;
diff --git a/NativeScript/include/v8-metrics.h b/NativeScript/include/v8-metrics.h
index d8e8bd86..418531e2 100644
--- a/NativeScript/include/v8-metrics.h
+++ b/NativeScript/include/v8-metrics.h
@@ -12,6 +12,7 @@
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
 
@@ -96,16 +97,88 @@ struct GarbageCollectionYoungCycle {
 };
 
 struct WasmModuleDecoded {
+  WasmModuleDecoded() = default;
+  WasmModuleDecoded(bool async, bool streamed, bool success,
+                    size_t module_size_in_bytes, size_t function_count,
+                    int64_t wall_clock_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        success(success),
+        module_size_in_bytes(module_size_in_bytes),
+        function_count(function_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us) {}
+
+  V8_DEPRECATED("Use the version without cpu_duration_in_us")
+  WasmModuleDecoded(bool async, bool streamed, bool success,
+                    size_t module_size_in_bytes, size_t function_count,
+                    int64_t wall_clock_duration_in_us,
+                    int64_t cpu_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        success(success),
+        module_size_in_bytes(module_size_in_bytes),
+        function_count(function_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us),
+        cpu_duration_in_us(cpu_duration_in_us) {}
+
+  START_ALLOW_USE_DEPRECATED()
+  // Copy constructor and copy assignment operator are allowed to copy the
+  // {cpu_duration_in_us} field.
+  WasmModuleDecoded(const WasmModuleDecoded&) = default;
+  WasmModuleDecoded& operator=(const WasmModuleDecoded&) = default;
+  END_ALLOW_USE_DEPRECATED()
+
   bool async = false;
   bool streamed = false;
   bool success = false;
   size_t module_size_in_bytes = 0;
   size_t function_count = 0;
   int64_t wall_clock_duration_in_us = -1;
+  V8_DEPRECATED("We do not collect cpu times any more")
   int64_t cpu_duration_in_us = -1;
 };
 
 struct WasmModuleCompiled {
+  WasmModuleCompiled() = default;
+
+  WasmModuleCompiled(bool async, bool streamed, bool cached, bool deserialized,
+                     bool lazy, bool success, size_t code_size_in_bytes,
+                     size_t liftoff_bailout_count,
+                     int64_t wall_clock_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        cached(cached),
+        deserialized(deserialized),
+        lazy(lazy),
+        success(success),
+        code_size_in_bytes(code_size_in_bytes),
+        liftoff_bailout_count(liftoff_bailout_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us) {}
+
+  V8_DEPRECATED("Use the version without cpu_duration_in_us")
+  WasmModuleCompiled(bool async, bool streamed, bool cached, bool deserialized,
+                     bool lazy, bool success, size_t code_size_in_bytes,
+                     size_t liftoff_bailout_count,
+                     int64_t wall_clock_duration_in_us,
+                     int64_t cpu_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        cached(cached),
+        deserialized(deserialized),
+        lazy(lazy),
+        success(success),
+        code_size_in_bytes(code_size_in_bytes),
+        liftoff_bailout_count(liftoff_bailout_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us),
+        cpu_duration_in_us(cpu_duration_in_us) {}
+
+  START_ALLOW_USE_DEPRECATED()
+  // Copy constructor and copy assignment operator are allowed to copy the
+  // {cpu_duration_in_us} field.
+  WasmModuleCompiled(const WasmModuleCompiled&) = default;
+  WasmModuleCompiled& operator=(const WasmModuleCompiled&) = default;
+  END_ALLOW_USE_DEPRECATED()
+
   bool async = false;
   bool streamed = false;
   bool cached = false;
@@ -115,6 +188,7 @@ struct WasmModuleCompiled {
   size_t code_size_in_bytes = 0;
   size_t liftoff_bailout_count = 0;
   int64_t wall_clock_duration_in_us = -1;
+  V8_DEPRECATED("We do not collect cpu times any more")
   int64_t cpu_duration_in_us = -1;
 };
 
@@ -125,31 +199,10 @@ struct WasmModuleInstantiated {
   int64_t wall_clock_duration_in_us = -1;
 };
 
-struct WasmModuleTieredUp {
-  bool lazy = false;
-  size_t code_size_in_bytes = 0;
-  int64_t wall_clock_duration_in_us = -1;
-  int64_t cpu_duration_in_us = -1;
-};
-
 struct WasmModulesPerIsolate {
   size_t count = 0;
 };
 
-#define V8_MAIN_THREAD_METRICS_EVENTS(V)                    \
-  V(GarbageCollectionFullCycle)                             \
-  V(GarbageCollectionFullMainThreadIncrementalMark)         \
-  V(GarbageCollectionFullMainThreadBatchedIncrementalMark)  \
-  V(GarbageCollectionFullMainThreadIncrementalSweep)        \
-  V(GarbageCollectionFullMainThreadBatchedIncrementalSweep) \
-  V(GarbageCollectionYoungCycle)                            \
-  V(WasmModuleDecoded)                                      \
-  V(WasmModuleCompiled)                                     \
-  V(WasmModuleInstantiated)                                 \
-  V(WasmModuleTieredUp)
-
-#define V8_THREAD_SAFE_METRICS_EVENTS(V) V(WasmModulesPerIsolate)
-
 /**
  * This class serves as a base class for recording event-based metrics in V8.
  * There a two kinds of metrics, those which are expected to be thread-safe and
@@ -159,19 +212,6 @@ struct WasmModulesPerIsolate {
  * background thread, it will be delayed and executed by the foreground task
  * runner.
  *
- * The thread-safe events are listed in the V8_THREAD_SAFE_METRICS_EVENTS
- * macro above while the main thread event are listed in
- * V8_MAIN_THREAD_METRICS_EVENTS above. For the former, a virtual method
- * AddMainThreadEvent(const E& event, v8::Context::Token token) will be
- * generated and for the latter AddThreadSafeEvent(const E& event).
- *
- * Thread-safe events are not allowed to access the context and therefore do
- * not carry a context ID with them. These IDs can be generated using
- * Recorder::GetContextId() and the ID will be valid throughout the lifetime
- * of the isolate. It is not guaranteed that the ID will still resolve to
- * a valid context using Recorder::GetContext() at the time the metric is
- * recorded. In this case, an empty handle will be returned.
- *
  * The embedder is expected to call v8::Isolate::SetMetricsRecorder()
  * providing its implementation and have the virtual methods overwritten
  * for the events it cares about.
@@ -202,14 +242,30 @@ class V8_EXPORT Recorder {
 
   virtual ~Recorder() = default;
 
+  // Main thread events. Those are only triggered on the main thread, and hence
+  // can access the context.
 #define ADD_MAIN_THREAD_EVENT(E) \
-  virtual void AddMainThreadEvent(const E& event, ContextId context_id) {}
-  V8_MAIN_THREAD_METRICS_EVENTS(ADD_MAIN_THREAD_EVENT)
+  virtual void AddMainThreadEvent(const E&, ContextId) {}
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullCycle)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadIncrementalMark)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadBatchedIncrementalMark)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadIncrementalSweep)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadBatchedIncrementalSweep)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionYoungCycle)
+  ADD_MAIN_THREAD_EVENT(WasmModuleDecoded)
+  ADD_MAIN_THREAD_EVENT(WasmModuleCompiled)
+  ADD_MAIN_THREAD_EVENT(WasmModuleInstantiated)
 #undef ADD_MAIN_THREAD_EVENT
 
+  // Thread-safe events are not allowed to access the context and therefore do
+  // not carry a context ID with them. These IDs can be generated using
+  // Recorder::GetContextId() and the ID will be valid throughout the lifetime
+  // of the isolate. It is not guaranteed that the ID will still resolve to
+  // a valid context using Recorder::GetContext() at the time the metric is
+  // recorded. In this case, an empty handle will be returned.
 #define ADD_THREAD_SAFE_EVENT(E) \
-  virtual void AddThreadSafeEvent(const E& event) {}
-  V8_THREAD_SAFE_METRICS_EVENTS(ADD_THREAD_SAFE_EVENT)
+  virtual void AddThreadSafeEvent(const E&) {}
+  ADD_THREAD_SAFE_EVENT(WasmModulesPerIsolate)
 #undef ADD_THREAD_SAFE_EVENT
 
   virtual void NotifyIsolateDisposal() {}
diff --git a/NativeScript/include/v8-microtask-queue.h b/NativeScript/include/v8-microtask-queue.h
index af9caa54..85d227fa 100644
--- a/NativeScript/include/v8-microtask-queue.h
+++ b/NativeScript/include/v8-microtask-queue.h
@@ -118,7 +118,12 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
  public:
   enum Type { kRunMicrotasks, kDoNotRunMicrotasks };
 
+  V8_DEPRECATE_SOON(
+      "May be incorrect if context was created with non-default microtask "
+      "queue")
   MicrotasksScope(Isolate* isolate, Type type);
+
+  MicrotasksScope(Local<Context> context, Type type);
   MicrotasksScope(Isolate* isolate, MicrotaskQueue* microtask_queue, Type type);
   ~MicrotasksScope();
 
@@ -142,7 +147,7 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
   MicrotasksScope& operator=(const MicrotasksScope&) = delete;
 
  private:
-  internal::Isolate* const isolate_;
+  internal::Isolate* const i_isolate_;
   internal::MicrotaskQueue* const microtask_queue_;
   bool run_;
 };
diff --git a/NativeScript/include/v8-object.h b/NativeScript/include/v8-object.h
index bad299fc..d7332ba0 100644
--- a/NativeScript/include/v8-object.h
+++ b/NativeScript/include/v8-object.h
@@ -594,8 +594,6 @@ class V8_EXPORT Object : public Value {
   /**
    * Returns the context in which the object was created.
    */
-  V8_DEPRECATED("Use MaybeLocal<Context> GetCreationContext()")
-  Local<Context> CreationContext();
   MaybeLocal<Context> GetCreationContext();
 
   /**
@@ -604,10 +602,6 @@ class V8_EXPORT Object : public Value {
   Local<Context> GetCreationContextChecked();
 
   /** Same as above, but works for Persistents */
-  V8_DEPRECATED(
-      "Use MaybeLocal<Context> GetCreationContext(const "
-      "PersistentBase<Object>& object)")
-  static Local<Context> CreationContext(const PersistentBase<Object>& object);
   V8_INLINE static MaybeLocal<Context> GetCreationContext(
       const PersistentBase<Object>& object) {
     return object.val_->GetCreationContext();
@@ -717,7 +711,7 @@ Local<Value> Object::GetInternalField(int index) {
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   int instance_type = I::GetInstanceType(obj);
-  if (v8::internal::CanHaveInternalField(instance_type)) {
+  if (I::CanHaveInternalField(instance_type)) {
     int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index);
     A value = I::ReadRawField<A>(obj, offset);
 #ifdef V8_COMPRESS_POINTERS
@@ -742,14 +736,13 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   auto instance_type = I::GetInstanceType(obj);
-  if (v8::internal::CanHaveInternalField(instance_type)) {
-    int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index);
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-    offset += I::kEmbedderDataSlotRawPayloadOffset;
-#endif
-    internal::Isolate* isolate = I::GetIsolateForSandbox(obj);
-    A value = I::ReadExternalPointerField(
-        isolate, obj, offset, internal::kEmbedderDataSlotPayloadTag);
+  if (I::CanHaveInternalField(instance_type)) {
+    int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) +
+                 I::kEmbedderDataSlotExternalPointerOffset;
+    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    A value =
+        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+            isolate, obj, offset);
     return reinterpret_cast<void*>(value);
   }
 #endif
diff --git a/NativeScript/include/v8-persistent-handle.h b/NativeScript/include/v8-persistent-handle.h
index a6c21268..4fe79862 100644
--- a/NativeScript/include/v8-persistent-handle.h
+++ b/NativeScript/include/v8-persistent-handle.h
@@ -169,8 +169,6 @@ class PersistentBase {
    * Turns this handle into a weak phantom handle without finalization callback.
    * The handle will be reset automatically when the garbage collector detects
    * that the object is no longer reachable.
-   * A related function Isolate::NumberOfPhantomHandleResetsSinceLastCall
-   * returns how many phantom handles were reset by the garbage collector.
    */
   V8_INLINE void SetWeak();
 
@@ -254,7 +252,7 @@ class NonCopyablePersistentTraits {
  * This will clone the contents of storage cell, but not any of the flags, etc.
  */
 template <class T>
-struct CopyablePersistentTraits {
+struct V8_DEPRECATED("Use v8::Global instead") CopyablePersistentTraits {
   using CopyablePersistent = Persistent<T, CopyablePersistentTraits<T>>;
   static const bool kResetInDestructor = true;
   template <class S, class M>
diff --git a/NativeScript/include/v8-platform.h b/NativeScript/include/v8-platform.h
index 91b3fd9c..32898e7e 100644
--- a/NativeScript/include/v8-platform.h
+++ b/NativeScript/include/v8-platform.h
@@ -158,9 +158,10 @@ class TaskRunner {
 class JobDelegate {
  public:
   /**
-   * Returns true if this thread should return from the worker task on the
+   * Returns true if this thread *must* return from the worker task on the
    * current thread ASAP. Workers should periodically invoke ShouldYield (or
    * YieldIfNeeded()) as often as is reasonable.
+   * After this method returned true, ShouldYield must not be called again.
    */
   virtual bool ShouldYield() = 0;
 
@@ -284,6 +285,8 @@ class ConvertableToTraceFormat {
  * V8 Tracing controller.
  *
  * Can be implemented by an embedder to record trace events from V8.
+ *
+ * Will become obsolete in Perfetto SDK build (v8_use_perfetto = true).
  */
 class TracingController {
  public:
@@ -347,10 +350,16 @@ class TracingController {
     virtual void OnTraceDisabled() = 0;
   };
 
-  /** Adds tracing state change observer. */
+  /**
+   * Adds tracing state change observer.
+   * Does nothing in Perfetto SDK build (v8_use_perfetto = true).
+   */
   virtual void AddTraceStateObserver(TraceStateObserver*) {}
 
-  /** Removes tracing state change observer. */
+  /**
+   * Removes tracing state change observer.
+   * Does nothing in Perfetto SDK build (v8_use_perfetto = true).
+   */
   virtual void RemoveTraceStateObserver(TraceStateObserver*) {}
 };
 
@@ -429,6 +438,17 @@ class PageAllocator {
   virtual bool SetPermissions(void* address, size_t length,
                               Permission permissions) = 0;
 
+  /**
+   * Recommits discarded pages in the given range with given permissions.
+   * Discarded pages must be recommitted with their original permissions
+   * before they are used again.
+   */
+  virtual bool RecommitPages(void* address, size_t length,
+                             Permission permissions) {
+    // TODO(v8:12797): make it pure once it's implemented on Chromium side.
+    return false;
+  }
+
   /**
    * Frees memory in the given [address, address + size) range. address and size
    * should be operating system page-aligned. The next write to this
@@ -698,6 +718,10 @@ class VirtualAddressSpace {
   /**
    * Sets permissions of all allocated pages in the given range.
    *
+   * This operation can fail due to OOM, in which case false is returned. If
+   * the operation fails for a reason other than OOM, this function will
+   * terminate the process as this implies a bug in the client.
+   *
    * \param address The start address of the range. Must be aligned to
    * page_size().
    *
@@ -706,7 +730,7 @@ class VirtualAddressSpace {
    *
    * \param permissions The new permissions for the range.
    *
-   * \returns true on success, false otherwise.
+   * \returns true on success, false on OOM.
    */
   virtual V8_WARN_UNUSED_RESULT bool SetPagePermissions(
       Address address, size_t size, PagePermissions permissions) = 0;
@@ -820,6 +844,24 @@ class VirtualAddressSpace {
   // takes a command enum as parameter.
   //
 
+  /**
+   * Recommits discarded pages in the given range with given permissions.
+   * Discarded pages must be recommitted with their original permissions
+   * before they are used again.
+   *
+   * \param address The start address of the range. Must be aligned to
+   * page_size().
+   *
+   * \param size The size in bytes of the range. Must be a multiple
+   * of page_size().
+   *
+   * \param permissions The permissions for the range that the pages must have.
+   *
+   * \returns true on success, false otherwise.
+   */
+  virtual V8_WARN_UNUSED_RESULT bool RecommitPages(
+      Address address, size_t size, PagePermissions permissions) = 0;
+
   /**
    * Frees memory in the given [address, address + size) range. address and
    * size should be aligned to the page_size(). The next write to this memory
@@ -889,11 +931,9 @@ class Platform {
 
   /**
    * Allows the embedder to manage memory page allocations.
+   * Returning nullptr will cause V8 to use the default page allocator.
    */
-  virtual PageAllocator* GetPageAllocator() {
-    // TODO(bbudge) Make this abstract after all embedders implement this.
-    return nullptr;
-  }
+  virtual PageAllocator* GetPageAllocator() = 0;
 
   /**
    * Allows the embedder to specify a custom allocator used for zones.
@@ -910,21 +950,7 @@ class Platform {
    * error.
    * Embedder overrides of this function must NOT call back into V8.
    */
-  virtual void OnCriticalMemoryPressure() {
-    // TODO(bbudge) Remove this when embedders override the following method.
-    // See crbug.com/634547.
-  }
-
-  /**
-   * Enables the embedder to respond in cases where V8 can't allocate large
-   * memory regions. The |length| parameter is the amount of memory needed.
-   * Returns true if memory is now available. Returns false if no memory could
-   * be made available. V8 will retry allocations until this method returns
-   * false.
-   *
-   * Embedder overrides of this function must NOT call back into V8.
-   */
-  virtual bool OnCriticalMemoryPressure(size_t length) { return false; }
+  virtual void OnCriticalMemoryPressure() {}
 
   /**
    * Gets the number of worker threads used by
@@ -1022,16 +1048,28 @@ class Platform {
    * thread (A=>B/B=>A deadlock) and [2] JobTask::Run or
    * JobTask::GetMaxConcurrency may be invoked synchronously from JobHandle
    * (B=>JobHandle::foo=>B deadlock).
+   */
+  virtual std::unique_ptr<JobHandle> PostJob(
+      TaskPriority priority, std::unique_ptr<JobTask> job_task) {
+    auto handle = CreateJob(priority, std::move(job_task));
+    handle->NotifyConcurrencyIncrease();
+    return handle;
+  }
+
+  /**
+   * Creates and returns a JobHandle associated with a Job. Unlike PostJob(),
+   * this doesn't immediately schedules |worker_task| to run; the Job is then
+   * scheduled by calling either NotifyConcurrencyIncrease() or Join().
    *
-   * A sufficient PostJob() implementation that uses the default Job provided in
-   * libplatform looks like:
-   *  std::unique_ptr<JobHandle> PostJob(
+   * A sufficient CreateJob() implementation that uses the default Job provided
+   * in libplatform looks like:
+   *  std::unique_ptr<JobHandle> CreateJob(
    *      TaskPriority priority, std::unique_ptr<JobTask> job_task) override {
    *    return v8::platform::NewDefaultJobHandle(
    *        this, priority, std::move(job_task), NumberOfWorkerThreads());
    * }
    */
-  virtual std::unique_ptr<JobHandle> PostJob(
+  virtual std::unique_ptr<JobHandle> CreateJob(
       TaskPriority priority, std::unique_ptr<JobTask> job_task) = 0;
 
   /**
diff --git a/NativeScript/include/v8-primitive.h b/NativeScript/include/v8-primitive.h
index 1b6de166..4fef8da7 100644
--- a/NativeScript/include/v8-primitive.h
+++ b/NativeScript/include/v8-primitive.h
@@ -20,6 +20,7 @@ class String;
 namespace internal {
 class ExternalString;
 class ScopedExternalStringLock;
+class StringForwardingTable;
 }  // namespace internal
 
 /**
@@ -269,6 +270,7 @@ class V8_EXPORT String : public Name {
    private:
     friend class internal::ExternalString;
     friend class v8::String;
+    friend class internal::StringForwardingTable;
     friend class internal::ScopedExternalStringLock;
   };
 
@@ -785,10 +787,9 @@ String::ExternalStringResource* String::GetExternalStringResource() const {
 
   ExternalStringResource* result;
   if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
-    internal::Isolate* isolate = I::GetIsolateForSandbox(obj);
-    A value =
-        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset,
-                                    internal::kExternalStringResourceTag);
+    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
+        isolate, obj, I::kStringResourceOffset);
     result = reinterpret_cast<String::ExternalStringResource*>(value);
   } else {
     result = GetExternalStringResourceSlow();
@@ -809,10 +810,9 @@ String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
   ExternalStringResourceBase* resource;
   if (type == I::kExternalOneByteRepresentationTag ||
       type == I::kExternalTwoByteRepresentationTag) {
-    internal::Isolate* isolate = I::GetIsolateForSandbox(obj);
-    A value =
-        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset,
-                                    internal::kExternalStringResourceTag);
+    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
+        isolate, obj, I::kStringResourceOffset);
     resource = reinterpret_cast<ExternalStringResourceBase*>(value);
   } else {
     resource = GetExternalStringResourceBaseSlow(encoding_out);
diff --git a/NativeScript/include/v8-profiler.h b/NativeScript/include/v8-profiler.h
index 26810407..d3941512 100644
--- a/NativeScript/include/v8-profiler.h
+++ b/NativeScript/include/v8-profiler.h
@@ -175,6 +175,32 @@ class V8_EXPORT CpuProfileNode {
   static const int kNoColumnNumberInfo = Message::kNoColumnInfo;
 };
 
+/**
+ * An interface for exporting data from V8, using "push" model.
+ */
+class V8_EXPORT OutputStream {
+ public:
+  enum WriteResult { kContinue = 0, kAbort = 1 };
+  virtual ~OutputStream() = default;
+  /** Notify about the end of stream. */
+  virtual void EndOfStream() = 0;
+  /** Get preferred output chunk size. Called only once. */
+  virtual int GetChunkSize() { return 1024; }
+  /**
+   * Writes the next chunk of snapshot data into the stream. Writing
+   * can be stopped by returning kAbort as function result. EndOfStream
+   * will not be called in case writing was aborted.
+   */
+  virtual WriteResult WriteAsciiChunk(char* data, int size) = 0;
+  /**
+   * Writes the next chunk of heap stats data into the stream. Writing
+   * can be stopped by returning kAbort as function result. EndOfStream
+   * will not be called in case writing was aborted.
+   */
+  virtual WriteResult WriteHeapStatsChunk(HeapStatsUpdate* data, int count) {
+    return kAbort;
+  }
+};
 
 /**
  * CpuProfile contains a CPU profile in a form of top-down call tree
@@ -182,6 +208,9 @@ class V8_EXPORT CpuProfileNode {
  */
 class V8_EXPORT CpuProfile {
  public:
+  enum SerializationFormat {
+    kJSON = 0  // See format description near 'Serialize' method.
+  };
   /** Returns CPU profile title. */
   Local<String> GetTitle() const;
 
@@ -235,6 +264,25 @@ class V8_EXPORT CpuProfile {
    * All pointers to nodes previously returned become invalid.
    */
   void Delete();
+
+  /**
+   * Prepare a serialized representation of the profile. The result
+   * is written into the stream provided in chunks of specified size.
+   *
+   * For the JSON format, heap contents are represented as an object
+   * with the following structure:
+   *
+   *  {
+   *    nodes: [nodes array],
+   *    startTime: number,
+   *    endTime: number
+   *    samples: [strings array]
+   *    timeDeltas: [numbers array]
+   *  }
+   *
+   */
+  void Serialize(OutputStream* stream,
+                 SerializationFormat format = kJSON) const;
 };
 
 enum CpuProfilingMode {
@@ -331,6 +379,9 @@ class V8_EXPORT CpuProfilingOptions {
       unsigned max_samples = kNoSampleLimit, int sampling_interval_us = 0,
       MaybeLocal<Context> filter_context = MaybeLocal<Context>());
 
+  CpuProfilingOptions(CpuProfilingOptions&&) = default;
+  CpuProfilingOptions& operator=(CpuProfilingOptions&&) = default;
+
   CpuProfilingMode mode() const { return mode_; }
   unsigned max_samples() const { return max_samples_; }
   int sampling_interval_us() const { return sampling_interval_us_; }
@@ -344,7 +395,7 @@ class V8_EXPORT CpuProfilingOptions {
   CpuProfilingMode mode_;
   unsigned max_samples_;
   int sampling_interval_us_;
-  CopyablePersistentTraits<Context>::CopyablePersistent filter_context_;
+  Global<Context> filter_context_;
 };
 
 /**
@@ -542,7 +593,10 @@ class V8_EXPORT HeapGraphNode {
     kConsString = 10,    // Concatenated string. A pair of pointers to strings.
     kSlicedString = 11,  // Sliced string. A fragment of another string.
     kSymbol = 12,        // A Symbol (ES6).
-    kBigInt = 13         // BigInt.
+    kBigInt = 13,        // BigInt.
+    kObjectShape = 14,   // Internal data used for tracking the shapes (or
+                         // "hidden classes") of JS objects.
+    kWasmObject = 15,    // A WasmGC struct or array.
   };
 
   /** Returns node type (see HeapGraphNode::Type). */
@@ -571,37 +625,6 @@ class V8_EXPORT HeapGraphNode {
   const HeapGraphEdge* GetChild(int index) const;
 };
 
-
-/**
- * An interface for exporting data from V8, using "push" model.
- */
-class V8_EXPORT OutputStream {
- public:
-  enum WriteResult {
-    kContinue = 0,
-    kAbort = 1
-  };
-  virtual ~OutputStream() = default;
-  /** Notify about the end of stream. */
-  virtual void EndOfStream() = 0;
-  /** Get preferred output chunk size. Called only once. */
-  virtual int GetChunkSize() { return 1024; }
-  /**
-   * Writes the next chunk of snapshot data into the stream. Writing
-   * can be stopped by returning kAbort as function result. EndOfStream
-   * will not be called in case writing was aborted.
-   */
-  virtual WriteResult WriteAsciiChunk(char* data, int size) = 0;
-  /**
-   * Writes the next chunk of heap stats data into the stream. Writing
-   * can be stopped by returning kAbort as function result. EndOfStream
-   * will not be called in case writing was aborted.
-   */
-  virtual WriteResult WriteHeapStatsChunk(HeapStatsUpdate* data, int count) {
-    return kAbort;
-  }
-};
-
 /**
  * HeapSnapshots record the state of the JS heap at some moment.
  */
@@ -898,6 +921,8 @@ class V8_EXPORT HeapProfiler {
   enum SamplingFlags {
     kSamplingNoFlags = 0,
     kSamplingForceGC = 1 << 0,
+    kSamplingIncludeObjectsCollectedByMajorGC = 1 << 1,
+    kSamplingIncludeObjectsCollectedByMinorGC = 1 << 2,
   };
 
   /**
@@ -975,14 +1000,71 @@ class V8_EXPORT HeapProfiler {
     virtual ~ObjectNameResolver() = default;
   };
 
+  enum class HeapSnapshotMode {
+    /**
+     * Heap snapshot for regular developers.
+     */
+    kRegular,
+    /**
+     * Heap snapshot is exposing internals that may be useful for experts.
+     */
+    kExposeInternals,
+  };
+
+  enum class NumericsMode {
+    /**
+     * Numeric values are hidden as they are values of the corresponding
+     * objects.
+     */
+    kHideNumericValues,
+    /**
+     * Numeric values are exposed in artificial fields.
+     */
+    kExposeNumericValues
+  };
+
+  struct HeapSnapshotOptions final {
+    // Manually define default constructor here to be able to use it in
+    // `TakeSnapshot()` below.
+    // NOLINTNEXTLINE
+    HeapSnapshotOptions() {}
+
+    /**
+     * The control used to report intermediate progress to.
+     */
+    ActivityControl* control = nullptr;
+    /**
+     * The resolver used by the snapshot generator to get names for V8 objects.
+     */
+    ObjectNameResolver* global_object_name_resolver = nullptr;
+    /**
+     * Mode for taking the snapshot, see `HeapSnapshotMode`.
+     */
+    HeapSnapshotMode snapshot_mode = HeapSnapshotMode::kRegular;
+    /**
+     * Mode for dealing with numeric values, see `NumericsMode`.
+     */
+    NumericsMode numerics_mode = NumericsMode::kHideNumericValues;
+  };
+
+  /**
+   * Takes a heap snapshot.
+   *
+   * \returns the snapshot.
+   */
+  const HeapSnapshot* TakeHeapSnapshot(
+      const HeapSnapshotOptions& options = HeapSnapshotOptions());
+
   /**
-   * Takes a heap snapshot and returns it.
+   * Takes a heap snapshot. See `HeapSnapshotOptions` for details on the
+   * parameters.
+   *
+   * \returns the snapshot.
    */
   const HeapSnapshot* TakeHeapSnapshot(
-      ActivityControl* control = nullptr,
+      ActivityControl* control,
       ObjectNameResolver* global_object_name_resolver = nullptr,
-      bool treat_global_objects_as_roots = true,
-      bool capture_numeric_value = false);
+      bool hide_internals = true, bool capture_numeric_value = false);
 
   /**
    * Starts tracking of heap objects population statistics. After calling
@@ -1035,10 +1117,8 @@ class V8_EXPORT HeapProfiler {
    * |stack_depth| parameter controls the maximum number of stack frames to be
    * captured on each allocation.
    *
-   * NOTE: This is a proof-of-concept at this point. Right now we only sample
-   * newspace allocations. Support for paged space allocation (e.g. pre-tenured
-   * objects, large objects, code objects, etc.) and native allocations
-   * doesn't exist yet, but is anticipated in the future.
+   * NOTE: Support for native allocations doesn't exist yet, but is anticipated
+   * in the future.
    *
    * Objects allocated before the sampling is started will not be included in
    * the profile.
@@ -1101,18 +1181,18 @@ struct HeapStatsUpdate {
   uint32_t size;  // New value of size field for the interval with this index.
 };
 
-#define CODE_EVENTS_LIST(V) \
-  V(Builtin)                \
-  V(Callback)               \
-  V(Eval)                   \
-  V(Function)               \
-  V(InterpretedFunction)    \
-  V(Handler)                \
-  V(BytecodeHandler)        \
-  V(LazyCompile)            \
-  V(RegExp)                 \
-  V(Script)                 \
-  V(Stub)                   \
+#define CODE_EVENTS_LIST(V)                          \
+  V(Builtin)                                         \
+  V(Callback)                                        \
+  V(Eval)                                            \
+  V(Function)                                        \
+  V(InterpretedFunction)                             \
+  V(Handler)                                         \
+  V(BytecodeHandler)                                 \
+  V(LazyCompile) /* Unused, use kFunction instead */ \
+  V(RegExp)                                          \
+  V(Script)                                          \
+  V(Stub)                                            \
   V(Relocation)
 
 /**
diff --git a/NativeScript/include/v8-regexp.h b/NativeScript/include/v8-regexp.h
index 3791bc03..135977bf 100644
--- a/NativeScript/include/v8-regexp.h
+++ b/NativeScript/include/v8-regexp.h
@@ -37,9 +37,10 @@ class V8_EXPORT RegExp : public Object {
     kDotAll = 1 << 5,
     kLinear = 1 << 6,
     kHasIndices = 1 << 7,
+    kUnicodeSets = 1 << 8,
   };
 
-  static constexpr int kFlagCount = 8;
+  static constexpr int kFlagCount = 9;
 
   /**
    * Creates a regular expression from the given pattern string and
diff --git a/NativeScript/include/v8-script.h b/NativeScript/include/v8-script.h
index 88252ac1..ea4933dc 100644
--- a/NativeScript/include/v8-script.h
+++ b/NativeScript/include/v8-script.h
@@ -20,6 +20,7 @@
 namespace v8 {
 
 class Function;
+class Message;
 class Object;
 class PrimitiveArray;
 class Script;
@@ -47,8 +48,6 @@ class V8_EXPORT ScriptOrModule {
    * The options that were passed by the embedder as HostDefinedOptions to
    * the ScriptOrigin.
    */
-  V8_DEPRECATED("Use HostDefinedOptions")
-  Local<PrimitiveArray> GetHostDefinedOptions();
   Local<Data> HostDefinedOptions();
 };
 
@@ -78,7 +77,13 @@ class V8_EXPORT UnboundScript {
    * Returns zero based line number of the code_pos location in the script.
    * -1 will be returned if no information available.
    */
-  int GetLineNumber(int code_pos);
+  int GetLineNumber(int code_pos = 0);
+
+  /**
+   * Returns zero based column number of the code_pos location in the script.
+   * -1 will be returned if no information available.
+   */
+  int GetColumnNumber(int code_pos = 0);
 
   static const int kNoScriptId = 0;
 };
@@ -87,7 +92,15 @@ class V8_EXPORT UnboundScript {
  * A compiled JavaScript module, not yet tied to a Context.
  */
 class V8_EXPORT UnboundModuleScript : public Data {
-  // Only used as a container for code caching.
+ public:
+  /**
+   * Data read from magic sourceURL comments.
+   */
+  Local<Value> GetSourceURL();
+  /**
+   * Data read from magic sourceMappingURL comments.
+   */
+  Local<Value> GetSourceMappingURL();
 };
 
 /**
@@ -286,6 +299,16 @@ class V8_EXPORT Module : public Data {
   V8_WARN_UNUSED_RESULT Maybe<bool> SetSyntheticModuleExport(
       Isolate* isolate, Local<String> export_name, Local<Value> export_value);
 
+  /**
+   * Search the modules requested directly or indirectly by the module for
+   * any top-level await that has not yet resolved. If there is any, the
+   * returned vector contains a tuple of the unresolved module and a message
+   * with the pending top-level await.
+   * An embedder may call this before exiting to improve error messages.
+   */
+  std::vector<std::tuple<Local<Module>, Local<Message>>>
+  GetStalledTopLevelAwaitMessage(Isolate* isolate);
+
   V8_INLINE static Module* Cast(Data* data);
 
  private:
@@ -324,6 +347,12 @@ class V8_EXPORT Script {
    * ScriptOrigin. This can be either a v8::String or v8::Undefined.
    */
   Local<Value> GetResourceName();
+
+  /**
+   * If the script was compiled, returns the positions of lazy functions which
+   * were eventually compiled and executed.
+   */
+  std::vector<int> GetProducedCompileHints() const;
 };
 
 enum class ScriptType { kClassic, kModule };
@@ -489,7 +518,7 @@ class V8_EXPORT ScriptCompiler {
   /**
    * A task which the embedder must run on a background thread to
    * consume a V8 code cache. Returned by
-   * ScriptCompiler::StarConsumingCodeCache.
+   * ScriptCompiler::StartConsumingCodeCache.
    */
   class V8_EXPORT ConsumeCodeCacheTask final {
    public:
@@ -497,6 +526,36 @@ class V8_EXPORT ScriptCompiler {
 
     void Run();
 
+    /**
+     * Provides the source text string and origin information to the consumption
+     * task. May be called before, during, or after Run(). This step checks
+     * whether the script matches an existing script in the Isolate's
+     * compilation cache. To check whether such a script was found, call
+     * ShouldMergeWithExistingScript.
+     *
+     * The Isolate provided must be the same one used during
+     * StartConsumingCodeCache and must be currently entered on the thread that
+     * calls this function. The source text and origin provided in this step
+     * must precisely match those used later in the ScriptCompiler::Source that
+     * will contain this ConsumeCodeCacheTask.
+     */
+    void SourceTextAvailable(Isolate* isolate, Local<String> source_text,
+                             const ScriptOrigin& origin);
+
+    /**
+     * Returns whether the embedder should call MergeWithExistingScript. This
+     * function may be called from any thread, any number of times, but its
+     * return value is only meaningful after SourceTextAvailable has completed.
+     */
+    bool ShouldMergeWithExistingScript() const;
+
+    /**
+     * Merges newly deserialized data into an existing script which was found
+     * during SourceTextAvailable. May be called only after Run() has completed.
+     * Can execute on any thread, like Run().
+     */
+    void MergeWithExistingScript();
+
    private:
     friend class ScriptCompiler;
 
@@ -509,7 +568,8 @@ class V8_EXPORT ScriptCompiler {
   enum CompileOptions {
     kNoCompileOptions = 0,
     kConsumeCodeCache,
-    kEagerCompile
+    kEagerCompile,
+    kProduceCompileHints
   };
 
   /**
@@ -581,7 +641,8 @@ class V8_EXPORT ScriptCompiler {
    */
   static ScriptStreamingTask* StartStreaming(
       Isolate* isolate, StreamedSource* source,
-      ScriptType type = ScriptType::kClassic);
+      ScriptType type = ScriptType::kClassic,
+      CompileOptions options = kNoCompileOptions);
 
   static ConsumeCodeCacheTask* StartConsumingCodeCache(
       Isolate* isolate, std::unique_ptr<CachedData> source);
@@ -658,6 +719,7 @@ class V8_EXPORT ScriptCompiler {
       CompileOptions options = kNoCompileOptions,
       NoCacheReason no_cache_reason = kNoCacheNoReason,
       Local<ScriptOrModule>* script_or_module_out = nullptr);
+
   static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunction(
       Local<Context> context, Source* source, size_t arguments_count = 0,
       Local<String> arguments[] = nullptr, size_t context_extension_count = 0,
diff --git a/NativeScript/include/v8-snapshot.h b/NativeScript/include/v8-snapshot.h
index 2400357c..b15a2b19 100644
--- a/NativeScript/include/v8-snapshot.h
+++ b/NativeScript/include/v8-snapshot.h
@@ -91,7 +91,7 @@ class V8_EXPORT SnapshotCreator {
    */
   SnapshotCreator(Isolate* isolate,
                   const intptr_t* external_references = nullptr,
-                  StartupData* existing_blob = nullptr);
+                  const StartupData* existing_blob = nullptr);
 
   /**
    * Create and enter an isolate, and set it up for serialization.
@@ -102,7 +102,7 @@ class V8_EXPORT SnapshotCreator {
    *        that must be equivalent to CreateParams::external_references.
    */
   SnapshotCreator(const intptr_t* external_references = nullptr,
-                  StartupData* existing_blob = nullptr);
+                  const StartupData* existing_blob = nullptr);
 
   /**
    * Destroy the snapshot creator, and exit and dispose of the Isolate
diff --git a/NativeScript/include/v8-template.h b/NativeScript/include/v8-template.h
index 0afdccaa..11296cd4 100644
--- a/NativeScript/include/v8-template.h
+++ b/NativeScript/include/v8-template.h
@@ -14,7 +14,6 @@
 
 namespace v8 {
 
-class AccessorSignature;
 class CFunction;
 class FunctionTemplate;
 class ObjectTemplate;
@@ -31,7 +30,9 @@ class Signature;
   F(AsyncIteratorPrototype, initial_async_iterator_prototype) \
   F(ErrorPrototype, initial_error_prototype)                  \
   F(IteratorPrototype, initial_iterator_prototype)            \
-  F(ObjProto_valueOf, object_value_of_function)
+  F(MapIteratorPrototype, initial_map_iterator_prototype)     \
+  F(ObjProto_valueOf, object_value_of_function)               \
+  F(SetIteratorPrototype, initial_set_iterator_prototype)
 
 enum Intrinsic {
 #define V8_DECL_INTRINSIC(name, iname) k##name,
@@ -83,28 +84,7 @@ class V8_EXPORT Template : public Data {
    *   cross-context access.
    * \param attribute The attributes of the property for which an accessor
    *   is added.
-   * \param signature The signature describes valid receivers for the accessor
-   *   and is used to perform implicit instance checks against them. If the
-   *   receiver is incompatible (i.e. is not an instance of the constructor as
-   *   defined by FunctionTemplate::HasInstance()), an implicit TypeError is
-   *   thrown and no callback is invoked.
    */
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetNativeDataProperty(
-      Local<String> name, AccessorGetterCallback getter,
-      AccessorSetterCallback setter, Local<Value> data,
-      PropertyAttribute attribute, Local<AccessorSignature> signature,
-      AccessControl settings = DEFAULT,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetNativeDataProperty(
-      Local<Name> name, AccessorNameGetterCallback getter,
-      AccessorNameSetterCallback setter, Local<Value> data,
-      PropertyAttribute attribute, Local<AccessorSignature> signature,
-      AccessControl settings = DEFAULT,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
   void SetNativeDataProperty(
       Local<String> name, AccessorGetterCallback getter,
       AccessorSetterCallback setter = nullptr,
@@ -151,7 +131,8 @@ class V8_EXPORT Template : public Data {
  * Interceptor for get requests on an object.
  *
  * Use `info.GetReturnValue().Set()` to set the return value of the
- * intercepted get request.
+ * intercepted get request. If the property does not exist the callback should
+ * not set the result and must not produce side effects.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -192,9 +173,9 @@ using GenericNamedPropertyGetterCallback =
  * Use `info.GetReturnValue()` to indicate whether the request was intercepted
  * or not. If the setter successfully intercepts the request, i.e., if the
  * request should not be further executed, call
- * `info.GetReturnValue().Set(value)`. If the setter
- * did not intercept the request, i.e., if the request should be handled as
- * if no interceptor is present, do not not call `Set()`.
+ * `info.GetReturnValue().Set(value)`. If the setter did not intercept the
+ * request, i.e., if the request should be handled as if no interceptor is
+ * present, do not not call `Set()` and do not produce side effects.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -217,7 +198,9 @@ using GenericNamedPropertySetterCallback =
  * defineProperty().
  *
  * Use `info.GetReturnValue().Set(value)` to set the property attributes. The
- * value is an integer encoding a `v8::PropertyAttribute`.
+ * value is an integer encoding a `v8::PropertyAttribute`. If the property does
+ * not exist the callback should not set the result and must not produce side
+ * effects.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -242,7 +225,8 @@ using GenericNamedPropertyQueryCallback =
  * or not. If the deleter successfully intercepts the request, i.e., if the
  * request should not be further executed, call
  * `info.GetReturnValue().Set(value)` with a boolean `value`. The `value` is
- * used as the return value of `delete`.
+ * used as the return value of `delete`. If the deleter does not intercept the
+ * request then it should not set the result and must not produce side effects.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -274,9 +258,9 @@ using GenericNamedPropertyEnumeratorCallback =
  * Use `info.GetReturnValue()` to indicate whether the request was intercepted
  * or not. If the definer successfully intercepts the request, i.e., if the
  * request should not be further executed, call
- * `info.GetReturnValue().Set(value)`. If the definer
- * did not intercept the request, i.e., if the request should be handled as
- * if no interceptor is present, do not not call `Set()`.
+ * `info.GetReturnValue().Set(value)`. If the definer did not intercept the
+ * request, i.e., if the request should be handled as if no interceptor is
+ * present, do not not call `Set()` and do not produce side effects.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -821,27 +805,7 @@ class V8_EXPORT ObjectTemplate : public Template {
    *   cross-context access.
    * \param attribute The attributes of the property for which an accessor
    *   is added.
-   * \param signature The signature describes valid receivers for the accessor
-   *   and is used to perform implicit instance checks against them. If the
-   *   receiver is incompatible (i.e. is not an instance of the constructor as
-   *   defined by FunctionTemplate::HasInstance()), an implicit TypeError is
-   *   thrown and no callback is invoked.
    */
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetAccessor(
-      Local<String> name, AccessorGetterCallback getter,
-      AccessorSetterCallback setter, Local<Value> data, AccessControl settings,
-      PropertyAttribute attribute, Local<AccessorSignature> signature,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetAccessor(
-      Local<Name> name, AccessorNameGetterCallback getter,
-      AccessorNameSetterCallback setter, Local<Value> data,
-      AccessControl settings, PropertyAttribute attribute,
-      Local<AccessorSignature> signature,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
   void SetAccessor(
       Local<String> name, AccessorGetterCallback getter,
       AccessorSetterCallback setter = nullptr,
@@ -1019,24 +983,6 @@ class V8_EXPORT Signature : public Data {
   static void CheckCast(Data* that);
 };
 
-/**
- * An AccessorSignature specifies which receivers are valid parameters
- * to an accessor callback.
- */
-class V8_EXPORT AccessorSignature : public Data {
- public:
-  static Local<AccessorSignature> New(
-      Isolate* isolate,
-      Local<FunctionTemplate> receiver = Local<FunctionTemplate>());
-
-  V8_INLINE static AccessorSignature* Cast(Data* data);
-
- private:
-  AccessorSignature();
-
-  static void CheckCast(Data* that);
-};
-
 // --- Implementation ---
 
 void Template::Set(Isolate* isolate, const char* name, Local<Data> value,
@@ -1067,13 +1013,6 @@ Signature* Signature::Cast(Data* data) {
   return reinterpret_cast<Signature*>(data);
 }
 
-AccessorSignature* AccessorSignature::Cast(Data* data) {
-#ifdef V8_ENABLE_CHECKS
-  CheckCast(data);
-#endif
-  return reinterpret_cast<AccessorSignature*>(data);
-}
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_TEMPLATE_H_
diff --git a/NativeScript/include/v8-traced-handle.h b/NativeScript/include/v8-traced-handle.h
index 7719b9bc..784016b3 100644
--- a/NativeScript/include/v8-traced-handle.h
+++ b/NativeScript/include/v8-traced-handle.h
@@ -117,11 +117,11 @@ class TracedReferenceBase {
 
 /**
  * A traced handle with copy and move semantics. The handle is to be used
- * together with |v8::EmbedderHeapTracer| or as part of GarbageCollected objects
- * (see v8-cppgc.h) and specifies edges from C++ objects to JavaScript.
+ * together as part of GarbageCollected objects (see v8-cppgc.h) or from stack
+ * and specifies edges from C++ objects to JavaScript.
  *
  * The exact semantics are:
- * - Tracing garbage collections use |v8::EmbedderHeapTracer| or cppgc.
+ * - Tracing garbage collections using CppHeap.
  * - Non-tracing garbage collections refer to
  *   |v8::EmbedderRootsHandler::IsRoot()| whether the handle should
  * be treated as root or not.
@@ -166,7 +166,6 @@ class BasicTracedReference : public TracedReferenceBase {
       Isolate* isolate, T* that, void* slot,
       internal::GlobalHandleStoreMode store_mode);
 
-  friend class EmbedderHeapTracer;
   template <typename F>
   friend class Local;
   friend class Object;
@@ -181,13 +180,7 @@ class BasicTracedReference : public TracedReferenceBase {
 /**
  * A traced handle without destructor that clears the handle. The embedder needs
  * to ensure that the handle is not accessed once the V8 object has been
- * reclaimed. This can happen when the handle is not passed through the
- * EmbedderHeapTracer. For more details see BasicTracedReference.
- *
- * The reference assumes the embedder has precise knowledge about references at
- * all times. In case V8 needs to separately handle on-stack references, the
- * embedder is required to set the stack start through
- * |EmbedderHeapTracer::SetStackStart|.
+ * reclaimed. For more details see BasicTracedReference.
  */
 template <typename T>
 class TracedReference : public BasicTracedReference<T> {
@@ -403,7 +396,7 @@ void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
   using I = internal::Internals;
   if (IsEmpty()) return;
   internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
+  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kTracedNodeClassIdOffset;
   *reinterpret_cast<uint16_t*>(addr) = class_id;
 }
 
@@ -411,7 +404,7 @@ uint16_t TracedReferenceBase::WrapperClassId() const {
   using I = internal::Internals;
   if (IsEmpty()) return 0;
   internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
+  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kTracedNodeClassIdOffset;
   return *reinterpret_cast<uint16_t*>(addr);
 }
 
diff --git a/NativeScript/include/v8-unwinder-state.h b/NativeScript/include/v8-unwinder-state.h
index a30f7325..18bb410d 100644
--- a/NativeScript/include/v8-unwinder-state.h
+++ b/NativeScript/include/v8-unwinder-state.h
@@ -17,10 +17,10 @@ struct CalleeSavedRegisters {
   void* arm_r9;
   void* arm_r10;
 };
-#elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 ||   \
-    V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC ||    \
-    V8_TARGET_ARCH_PPC64 || V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390 || \
-    V8_TARGET_ARCH_LOONG64
+#elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 ||     \
+    V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_PPC64 ||     \
+    V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390 || V8_TARGET_ARCH_LOONG64 || \
+    V8_TARGET_ARCH_RISCV32
 struct CalleeSavedRegisters {};
 #else
 #error Target architecture was not detected as supported by v8
diff --git a/NativeScript/include/v8-util.h b/NativeScript/include/v8-util.h
index c54418aa..159027d3 100644
--- a/NativeScript/include/v8-util.h
+++ b/NativeScript/include/v8-util.h
@@ -537,7 +537,6 @@ class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
       : GlobalValueMap<K, V, Traits>(isolate) {}
 };
 
-
 class DefaultPersistentValueVectorTraits {
  public:
   typedef std::vector<PersistentContainerValue> Impl;
@@ -562,7 +561,6 @@ class DefaultPersistentValueVectorTraits {
   }
 };
 
-
 /**
  * A vector wrapper that safely stores Global values.
  * C++11 embedders don't need this class, as they can use Global
@@ -573,8 +571,8 @@ class DefaultPersistentValueVectorTraits {
  * PersistentContainerValue, with all conversion into and out of V8
  * handles being transparently handled by this class.
  */
-template<typename V, typename Traits = DefaultPersistentValueVectorTraits>
-class PersistentValueVector {
+template <typename V, typename Traits = DefaultPersistentValueVectorTraits>
+class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
  public:
   explicit PersistentValueVector(Isolate* isolate) : isolate_(isolate) { }
 
diff --git a/NativeScript/include/v8-value-serializer.h b/NativeScript/include/v8-value-serializer.h
index 078f367c..729730c6 100644
--- a/NativeScript/include/v8-value-serializer.h
+++ b/NativeScript/include/v8-value-serializer.h
@@ -8,6 +8,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
@@ -26,8 +27,37 @@ class Value;
 
 namespace internal {
 struct ScriptStreamingData;
+class SharedObjectConveyorHandles;
+class ValueDeserializer;
+class ValueSerializer;
 }  // namespace internal
 
+/**
+ * A move-only class for managing the lifetime of shared value conveyors used
+ * by V8 to keep JS shared values alive in transit when serialized.
+ *
+ * This class is not directly constructible and is always passed to a
+ * ValueSerializer::Delegate via ValueSerializer::SetSharedValueConveyor.
+ *
+ * The embedder must not destruct the SharedValueConveyor until the associated
+ * serialized data will no longer be deserialized.
+ */
+class V8_EXPORT SharedValueConveyor final {
+ public:
+  SharedValueConveyor(SharedValueConveyor&&) noexcept;
+  ~SharedValueConveyor();
+
+  SharedValueConveyor& operator=(SharedValueConveyor&&) noexcept;
+
+ private:
+  friend class internal::ValueSerializer;
+  friend class internal::ValueDeserializer;
+
+  explicit SharedValueConveyor(Isolate* isolate);
+
+  std::unique_ptr<internal::SharedObjectConveyorHandles> private_;
+};
+
 /**
  * Value serialization compatible with the HTML structured clone algorithm.
  * The format is backward-compatible (i.e. safe to store to disk).
@@ -69,20 +99,20 @@ class V8_EXPORT ValueSerializer {
         Isolate* isolate, Local<WasmModuleObject> module);
 
     /**
-     * Returns whether shared values are supported. GetSharedValueId is only
-     * called if SupportsSharedValues() returns true.
-     */
-    virtual bool SupportsSharedValues() const;
-
-    /**
-     * Called when the ValueSerializer serializes a value that is shared across
-     * Isolates. The embedder must return an ID for the object. This function
-     * must be idempotent for the same object. When deserializing, the ID will
-     * be passed to ValueDeserializer::Delegate::GetSharedValueFromId as
-     * |shared_value_id|.
+     * Called when the first shared value is serialized. All subsequent shared
+     * values will use the same conveyor.
+     *
+     * The embedder must ensure the lifetime of the conveyor matches the
+     * lifetime of the serialized data.
+     *
+     * If the embedder supports serializing shared values, this method should
+     * return true. Otherwise the embedder should throw an exception and return
+     * false.
+     *
+     * This method is called at most once per serializer.
      */
-    virtual Maybe<uint32_t> GetSharedValueId(Isolate* isolate,
-                                             Local<Value> shared_value);
+    virtual bool AdoptSharedValueConveyor(Isolate* isolate,
+                                          SharedValueConveyor&& conveyor);
 
     /**
      * Allocates memory for the buffer of at least the size provided. The actual
@@ -196,17 +226,10 @@ class V8_EXPORT ValueDeserializer {
         Isolate* isolate, uint32_t clone_id);
 
     /**
-     * Returns whether shared values are supported. GetSharedValueFromId is only
-     * called if SupportsSharedValues() returns true.
-     */
-    virtual bool SupportsSharedValues() const;
-
-    /**
-     * Get a value shared across Isolates given a shared_value_id provided by
-     * ValueSerializer::Delegate::GetSharedValueId.
+     * Get the SharedValueConveyor previously provided by
+     * ValueSerializer::Delegate::AdoptSharedValueConveyor.
      */
-    virtual MaybeLocal<Value> GetSharedValueFromId(Isolate* isolate,
-                                                   uint32_t shared_value_id);
+    virtual const SharedValueConveyor* GetSharedValueConveyor(Isolate* isolate);
   };
 
   ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size);
diff --git a/NativeScript/include/v8-value.h b/NativeScript/include/v8-value.h
index adca989e..866da201 100644
--- a/NativeScript/include/v8-value.h
+++ b/NativeScript/include/v8-value.h
@@ -244,6 +244,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsWeakSet() const;
 
+  /**
+   * Returns true if this value is a WeakRef.
+   */
+  bool IsWeakRef() const;
+
   /**
    * Returns true if this value is an ArrayBuffer.
    */
diff --git a/NativeScript/include/v8-version.h b/NativeScript/include/v8-version.h
index fb95e7ab..7874db63 100644
--- a/NativeScript/include/v8-version.h
+++ b/NativeScript/include/v8-version.h
@@ -8,10 +8,10 @@
 // These macros define the version number for the current version.
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
-#define V8_MAJOR_VERSION 10
-#define V8_MINOR_VERSION 3
-#define V8_BUILD_NUMBER 22
-#define V8_PATCH_LEVEL 0
+#define V8_MAJOR_VERSION 11
+#define V8_MINOR_VERSION 1
+#define V8_BUILD_NUMBER 277
+#define V8_PATCH_LEVEL 17
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/NativeScript/include/v8-wasm.h b/NativeScript/include/v8-wasm.h
index 59b2a69b..05acd2e8 100644
--- a/NativeScript/include/v8-wasm.h
+++ b/NativeScript/include/v8-wasm.h
@@ -5,6 +5,7 @@
 #ifndef INCLUDE_V8_WASM_H_
 #define INCLUDE_V8_WASM_H_
 
+#include <functional>
 #include <memory>
 #include <string>
 
@@ -130,19 +131,6 @@ class V8_EXPORT WasmStreaming final {
  public:
   class WasmStreamingImpl;
 
-  /**
-   * Client to receive streaming event notifications.
-   */
-  class Client {
-   public:
-    virtual ~Client() = default;
-    /**
-     * Passes the fully compiled module to the client. This can be used to
-     * implement code caching.
-     */
-    virtual void OnModuleCompiled(CompiledWasmModule compiled_module) = 0;
-  };
-
   explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl);
 
   ~WasmStreaming();
@@ -183,10 +171,11 @@ class V8_EXPORT WasmStreaming final {
   bool SetCompiledModuleBytes(const uint8_t* bytes, size_t size);
 
   /**
-   * Sets the client object that will receive streaming event notifications.
-   * This must be called before {OnBytesReceived}, {Finish}, or {Abort}.
+   * Sets a callback which is called whenever a significant number of new
+   * functions are ready for serialization.
    */
-  void SetClient(std::shared_ptr<Client> client);
+  void SetMoreFunctionsCanBeSerializedCallback(
+      std::function<void(CompiledWasmModule)>);
 
   /*
    * Sets the UTF-8 encoded source URL for the {Script} object. This must be
@@ -206,52 +195,6 @@ class V8_EXPORT WasmStreaming final {
   std::unique_ptr<WasmStreamingImpl> impl_;
 };
 
-// TODO(mtrofin): when streaming compilation is done, we can rename this
-// to simply WasmModuleObjectBuilder
-class V8_EXPORT WasmModuleObjectBuilderStreaming final {
- public:
-  explicit WasmModuleObjectBuilderStreaming(Isolate* isolate);
-  /**
-   * The buffer passed into OnBytesReceived is owned by the caller.
-   */
-  void OnBytesReceived(const uint8_t*, size_t size);
-  void Finish();
-  /**
-   * Abort streaming compilation. If {exception} has a value, then the promise
-   * associated with streaming compilation is rejected with that value. If
-   * {exception} does not have value, the promise does not get rejected.
-   */
-  void Abort(MaybeLocal<Value> exception);
-  Local<Promise> GetPromise();
-
-  ~WasmModuleObjectBuilderStreaming() = default;
-
- private:
-  WasmModuleObjectBuilderStreaming(const WasmModuleObjectBuilderStreaming&) =
-      delete;
-  WasmModuleObjectBuilderStreaming(WasmModuleObjectBuilderStreaming&&) =
-      default;
-  WasmModuleObjectBuilderStreaming& operator=(
-      const WasmModuleObjectBuilderStreaming&) = delete;
-  WasmModuleObjectBuilderStreaming& operator=(
-      WasmModuleObjectBuilderStreaming&&) = default;
-  Isolate* isolate_ = nullptr;
-
-#if V8_CC_MSVC
-  /**
-   * We don't need the static Copy API, so the default
-   * NonCopyablePersistentTraits would be sufficient, however,
-   * MSVC eagerly instantiates the Copy.
-   * We ensure we don't use Copy, however, by compiling with the
-   * defaults everywhere else.
-   */
-  Persistent<Promise, CopyablePersistentTraits<Promise>> promise_;
-#else
-  Persistent<Promise> promise_;
-#endif
-  std::shared_ptr<internal::wasm::StreamingDecoder> streaming_decoder_;
-};
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_WASM_H_
diff --git a/NativeScript/include/v8-weak-callback-info.h b/NativeScript/include/v8-weak-callback-info.h
index 750eff19..df4dcb8e 100644
--- a/NativeScript/include/v8-weak-callback-info.h
+++ b/NativeScript/include/v8-weak-callback-info.h
@@ -63,12 +63,6 @@ enum class WeakCallbackType {
    * Passes the first two internal fields of the object back to the callback.
    */
   kInternalFields,
-  /**
-   * Passes a user-defined void* parameter back to the callback. Will do so
-   * before the object is actually reclaimed, allowing it to be resurrected. In
-   * this case it is not possible to set a second-pass callback.
-   */
-  kFinalizer
 };
 
 template <class T>
diff --git a/NativeScript/include/v8config.h b/NativeScript/include/v8config.h
index 77fd65c6..b44995e7 100644
--- a/NativeScript/include/v8config.h
+++ b/NativeScript/include/v8config.h
@@ -288,6 +288,9 @@ path. Add it with -I<path> to the command line
 //
 //  V8_HAS_ATTRIBUTE_ALWAYS_INLINE      - __attribute__((always_inline))
 //                                        supported
+//  V8_HAS_ATTRIBUTE_CONSTINIT          - __attribute__((require_constant_
+//                                                       initialization))
+//                                        supported
 //  V8_HAS_ATTRIBUTE_NONNULL            - __attribute__((nonnull)) supported
 //  V8_HAS_ATTRIBUTE_NOINLINE           - __attribute__((noinline)) supported
 //  V8_HAS_ATTRIBUTE_UNUSED             - __attribute__((unused)) supported
@@ -305,9 +308,13 @@ path. Add it with -I<path> to the command line
 //  V8_HAS_BUILTIN_EXPECT               - __builtin_expect() supported
 //  V8_HAS_BUILTIN_FRAME_ADDRESS        - __builtin_frame_address() supported
 //  V8_HAS_BUILTIN_POPCOUNT             - __builtin_popcount() supported
+//  V8_HAS_BUILTIN_ADD_OVERFLOW         - __builtin_add_overflow() supported
+//  V8_HAS_BUILTIN_SUB_OVERFLOW         - __builtin_sub_overflow() supported
+//  V8_HAS_BUILTIN_MUL_OVERFLOW         - __builtin_mul_overflow() supported
 //  V8_HAS_BUILTIN_SADD_OVERFLOW        - __builtin_sadd_overflow() supported
 //  V8_HAS_BUILTIN_SSUB_OVERFLOW        - __builtin_ssub_overflow() supported
 //  V8_HAS_BUILTIN_UADD_OVERFLOW        - __builtin_uadd_overflow() supported
+//  V8_HAS_BUILTIN_SMUL_OVERFLOW        - __builtin_smul_overflow() supported
 //  V8_HAS_COMPUTED_GOTO                - computed goto/labels as values
 //                                        supported
 //  V8_HAS_DECLSPEC_NOINLINE            - __declspec(noinline) supported
@@ -333,9 +340,23 @@ path. Add it with -I<path> to the command line
 #endif
 
 # define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (__has_attribute(always_inline))
+# define V8_HAS_ATTRIBUTE_CONSTINIT \
+    (__has_attribute(require_constant_initialization))
+# define V8_HAS_ATTRIBUTE_CONST (__has_attribute(const))
 # define V8_HAS_ATTRIBUTE_NONNULL (__has_attribute(nonnull))
 # define V8_HAS_ATTRIBUTE_NOINLINE (__has_attribute(noinline))
 # define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused))
+// Support for the "preserve_most" attribute is limited:
+// - 32-bit platforms do not implement it,
+// - component builds fail because _dl_runtime_resolve clobbers registers,
+// - we see crashes on arm64 on Windows (https://crbug.com/1409934), which can
+//   hopefully be fixed in the future.
+#if (defined(_M_X64) || defined(__x86_64__)            /* x64 (everywhere) */  \
+     || ((defined(__AARCH64EL__) || defined(_M_ARM64)) /* arm64, but ... */    \
+         && !defined(_WIN32)))                         /* not on windows */    \
+     && !defined(COMPONENT_BUILD)                      /* no component build */
+# define V8_HAS_ATTRIBUTE_PRESERVE_MOST (__has_attribute(preserve_most))
+#endif
 # define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility))
 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \
     (__has_attribute(warn_unused_result))
@@ -344,6 +365,7 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS \
     (V8_HAS_CPP_ATTRIBUTE(no_unique_address))
 
+# define V8_HAS_BUILTIN_ASSUME (__has_builtin(__builtin_assume))
 # define V8_HAS_BUILTIN_ASSUME_ALIGNED (__has_builtin(__builtin_assume_aligned))
 # define V8_HAS_BUILTIN_BSWAP16 (__has_builtin(__builtin_bswap16))
 # define V8_HAS_BUILTIN_BSWAP32 (__has_builtin(__builtin_bswap32))
@@ -353,9 +375,14 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_BUILTIN_EXPECT (__has_builtin(__builtin_expect))
 # define V8_HAS_BUILTIN_FRAME_ADDRESS (__has_builtin(__builtin_frame_address))
 # define V8_HAS_BUILTIN_POPCOUNT (__has_builtin(__builtin_popcount))
+# define V8_HAS_BUILTIN_ADD_OVERFLOW (__has_builtin(__builtin_add_overflow))
+# define V8_HAS_BUILTIN_SUB_OVERFLOW (__has_builtin(__builtin_sub_overflow))
+# define V8_HAS_BUILTIN_MUL_OVERFLOW (__has_builtin(__builtin_mul_overflow))
 # define V8_HAS_BUILTIN_SADD_OVERFLOW (__has_builtin(__builtin_sadd_overflow))
 # define V8_HAS_BUILTIN_SSUB_OVERFLOW (__has_builtin(__builtin_ssub_overflow))
 # define V8_HAS_BUILTIN_UADD_OVERFLOW (__has_builtin(__builtin_uadd_overflow))
+# define V8_HAS_BUILTIN_SMUL_OVERFLOW (__has_builtin(__builtin_smul_overflow))
+# define V8_HAS_BUILTIN_UNREACHABLE (__has_builtin(__builtin_unreachable))
 
 // Clang has no __has_feature for computed gotos.
 // GCC doc: https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html
@@ -394,6 +421,7 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_BUILTIN_EXPECT 1
 # define V8_HAS_BUILTIN_FRAME_ADDRESS 1
 # define V8_HAS_BUILTIN_POPCOUNT 1
+# define V8_HAS_BUILTIN_UNREACHABLE 1
 
 // GCC doc: https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html
 #define V8_HAS_COMPUTED_GOTO 1
@@ -425,6 +453,18 @@ path. Add it with -I<path> to the command line
 # define V8_INLINE inline
 #endif
 
+#ifdef DEBUG
+// In debug mode, check assumptions instead of actually adding annotations.
+# define V8_ASSUME(condition) DCHECK(condition)
+#elif V8_HAS_BUILTIN_ASSUME
+# define V8_ASSUME(condition) __builtin_assume(condition)
+#elif V8_HAS_BUILTIN_UNREACHABLE
+# define V8_ASSUME(condition) \
+  do { if (!(condition)) __builtin_unreachable(); } while (false)
+#else
+# define V8_ASSUME(condition)
+#endif
+
 #if V8_HAS_BUILTIN_ASSUME_ALIGNED
 # define V8_ASSUME_ALIGNED(ptr, alignment) \
   __builtin_assume_aligned((ptr), (alignment))
@@ -433,6 +473,26 @@ path. Add it with -I<path> to the command line
 #endif
 
 
+// A macro to mark functions whose values don't change (e.g. across calls)
+// and thereby compiler is free to hoist and fold multiple calls together.
+// Use like:
+//   V8_CONST int foo() { ... }
+#if V8_HAS_ATTRIBUTE_CONST
+# define V8_CONST __attribute__((const))
+#else
+# define V8_CONST
+#endif
+
+// A macro to mark a declaration as requiring constant initialization.
+// Use like:
+//   int* foo V8_CONSTINIT;
+#if V8_HAS_ATTRIBUTE_CONSTINIT
+# define V8_CONSTINIT __attribute__((require_constant_initialization))
+#else
+# define V8_CONSTINIT
+#endif
+
+
 // A macro to mark specific arguments as non-null.
 // Use like:
 //   int add(int* x, int y, int* z) V8_NONNULL(1, 3) { return *x + y + *z; }
@@ -455,6 +515,21 @@ path. Add it with -I<path> to the command line
 #endif
 
 
+// A macro used to change the calling conventions to preserve all registers (no
+// caller-saved registers). Use this for cold functions called from hot
+// functions.
+// Note: The attribute is considered experimental, so apply with care. Also,
+// "preserve_most" is currently not handling the return value correctly, so only
+// use it for functions returning void (see https://reviews.llvm.org/D141020).
+// Use like:
+//   V8_NOINLINE V8_PRESERVE_MOST void UnlikelyMethod();
+#if V8_HAS_ATTRIBUTE_PRESERVE_MOST
+# define V8_PRESERVE_MOST __attribute__((preserve_most))
+#else
+# define V8_PRESERVE_MOST /* NOT SUPPORTED */
+#endif
+
+
 // A macro (V8_DEPRECATED) to mark classes or functions as deprecated.
 #if defined(V8_DEPRECATION_WARNINGS)
 # define V8_DEPRECATED(message) [[deprecated(message)]]
@@ -471,6 +546,34 @@ path. Add it with -I<path> to the command line
 #endif
 
 
+#if defined(V8_IMMINENT_DEPRECATION_WARNINGS) || \
+    defined(V8_DEPRECATION_WARNINGS)
+#if defined(V8_CC_MSVC)
+# define START_ALLOW_USE_DEPRECATED() \
+    __pragma(warning(push))           \
+    __pragma(warning(disable : 4996))
+# define END_ALLOW_USE_DEPRECATED() __pragma(warning(pop))
+#else  // !defined(V8_CC_MSVC)
+# define START_ALLOW_USE_DEPRECATED()                               \
+    _Pragma("GCC diagnostic push")                                  \
+    _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#define END_ALLOW_USE_DEPRECATED() _Pragma("GCC diagnostic pop")
+#endif  // !defined(V8_CC_MSVC)
+#else  // !(defined(V8_IMMINENT_DEPRECATION_WARNINGS) ||
+       // defined(V8_DEPRECATION_WARNINGS))
+#define START_ALLOW_USE_DEPRECATED()
+#define END_ALLOW_USE_DEPRECATED()
+#endif  // !(defined(V8_IMMINENT_DEPRECATION_WARNINGS) ||
+        // defined(V8_DEPRECATION_WARNINGS))
+#define ALLOW_COPY_AND_MOVE_WITH_DEPRECATED_FIELDS(ClassName) \
+  START_ALLOW_USE_DEPRECATED()                                \
+  ClassName(const ClassName&) = default;                      \
+  ClassName(ClassName&&) = default;                           \
+  ClassName& operator=(const ClassName&) = default;           \
+  ClassName& operator=(ClassName&&) = default;                \
+  END_ALLOW_USE_DEPRECATED()
+
+
 #if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ < 6)
 # define V8_ENUM_DEPRECATED(message)
 # define V8_ENUM_DEPRECATE_SOON(message)
@@ -534,6 +637,37 @@ path. Add it with -I<path> to the command line
 #define V8_NO_UNIQUE_ADDRESS /* NOT SUPPORTED */
 #endif
 
+// Marks a type as being eligible for the "trivial" ABI despite having a
+// non-trivial destructor or copy/move constructor. Such types can be relocated
+// after construction by simply copying their memory, which makes them eligible
+// to be passed in registers. The canonical example is std::unique_ptr.
+//
+// Use with caution; this has some subtle effects on constructor/destructor
+// ordering and will be very incorrect if the type relies on its address
+// remaining constant. When used as a function argument (by value), the value
+// may be constructed in the caller's stack frame, passed in a register, and
+// then used and destructed in the callee's stack frame. A similar thing can
+// occur when values are returned.
+//
+// TRIVIAL_ABI is not needed for types which have a trivial destructor and
+// copy/move constructors, since those are automatically trivial by the ABI
+// spec.
+//
+// It is also not likely to be effective on types too large to be passed in one
+// or two registers on typical target ABIs.
+//
+// See also:
+//   https://clang.llvm.org/docs/AttributeReference.html#trivial-abi
+//   https://libcxx.llvm.org/docs/DesignDocs/UniquePtrTrivialAbi.html
+#if defined(__clang__) && defined(__has_attribute)
+#if __has_attribute(trivial_abi)
+#define V8_TRIVIAL_ABI [[clang::trivial_abi]]
+#endif // __has_attribute(trivial_abi)
+#endif // defined(__clang__) && defined(__has_attribute)
+#if !defined(V8_TRIVIAL_ABI)
+#define V8_TRIVIAL_ABI
+#endif //!defined(V8_TRIVIAL_ABI)
+
 // Helper macro to define no_sanitize attributes only with clang.
 #if defined(__clang__) && defined(__has_attribute)
 #if __has_attribute(no_sanitize)
@@ -580,25 +714,216 @@ V8 shared library set USING_V8_SHARED.
 
 #endif  // V8_OS_WIN
 
-// The sandbox is available (i.e. defined) when pointer compression
-// is enabled, but it is only used when V8_SANDBOX is enabled as
-// well. This allows better test coverage of the sandbox.
-#if defined(V8_COMPRESS_POINTERS)
-#define V8_SANDBOX_IS_AVAILABLE
+// clang-format on
+
+// Processor architecture detection.  For more info on what's defined, see:
+//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+//   http://www.agner.org/optimize/calling_conventions.pdf
+//   or with gcc, run: "echo | gcc -E -dM -"
+// The V8_HOST_ARCH_* macros correspond to the architecture on which V8, as a
+// virtual machine and compiler, runs. Don't confuse this with the architecture
+// on which V8 is built.
+#if defined(_M_X64) || defined(__x86_64__)
+#define V8_HOST_ARCH_X64 1
+#if defined(__x86_64__) && __SIZEOF_POINTER__ == 4  // Check for x32.
+#define V8_HOST_ARCH_32_BIT 1
+#else
+#define V8_HOST_ARCH_64_BIT 1
+#endif
+#elif defined(_M_IX86) || defined(__i386__)
+#define V8_HOST_ARCH_IA32 1
+#define V8_HOST_ARCH_32_BIT 1
+#elif defined(__AARCH64EL__) || defined(_M_ARM64)
+#define V8_HOST_ARCH_ARM64 1
+#define V8_HOST_ARCH_64_BIT 1
+#elif defined(__ARMEL__)
+#define V8_HOST_ARCH_ARM 1
+#define V8_HOST_ARCH_32_BIT 1
+#elif defined(__mips64)
+#define V8_HOST_ARCH_MIPS64 1
+#define V8_HOST_ARCH_64_BIT 1
+#elif defined(__loongarch64)
+#define V8_HOST_ARCH_LOONG64 1
+#define V8_HOST_ARCH_64_BIT 1
+#elif defined(__PPC64__) || defined(_ARCH_PPC64)
+#define V8_HOST_ARCH_PPC64 1
+#define V8_HOST_ARCH_64_BIT 1
+#elif defined(__PPC__) || defined(_ARCH_PPC)
+#define V8_HOST_ARCH_PPC 1
+#define V8_HOST_ARCH_32_BIT 1
+#elif defined(__s390__) || defined(__s390x__)
+#define V8_HOST_ARCH_S390 1
+#if defined(__s390x__)
+#define V8_HOST_ARCH_64_BIT 1
+#else
+#define V8_HOST_ARCH_32_BIT 1
+#endif
+#elif defined(__riscv) || defined(__riscv__)
+#if __riscv_xlen == 64
+#define V8_HOST_ARCH_RISCV64 1
+#define V8_HOST_ARCH_64_BIT 1
+#elif __riscv_xlen == 32
+#define V8_HOST_ARCH_RISCV32 1
+#define V8_HOST_ARCH_32_BIT 1
+#else
+#error "Cannot detect Riscv's bitwidth"
+#endif
+#else
+#error "Host architecture was not detected as supported by v8"
+#endif
+
+// Target architecture detection. This corresponds to the architecture for which
+// V8's JIT will generate code (the last stage of the canadian cross-compiler).
+// The macros may be set externally. If not, detect in the same way as the host
+// architecture, that is, target the native environment as presented by the
+// compiler.
+#if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_IA32 && !V8_TARGET_ARCH_ARM &&     \
+    !V8_TARGET_ARCH_ARM64 && !V8_TARGET_ARCH_MIPS64 && !V8_TARGET_ARCH_PPC && \
+    !V8_TARGET_ARCH_PPC64 && !V8_TARGET_ARCH_S390 &&                          \
+    !V8_TARGET_ARCH_RISCV64 && !V8_TARGET_ARCH_LOONG64 &&                     \
+    !V8_TARGET_ARCH_RISCV32
+#if defined(_M_X64) || defined(__x86_64__)
+#define V8_TARGET_ARCH_X64 1
+#elif defined(_M_IX86) || defined(__i386__)
+#define V8_TARGET_ARCH_IA32 1
+#elif defined(__AARCH64EL__) || defined(_M_ARM64)
+#define V8_TARGET_ARCH_ARM64 1
+#elif defined(__ARMEL__)
+#define V8_TARGET_ARCH_ARM 1
+#elif defined(__mips64)
+#define V8_TARGET_ARCH_MIPS64 1
+#elif defined(__loongarch64)
+#define V8_TARGET_ARCH_LOONG64 1
+#elif defined(_ARCH_PPC64)
+#define V8_TARGET_ARCH_PPC64 1
+#elif defined(_ARCH_PPC)
+#define V8_TARGET_ARCH_PPC 1
+#elif defined(__s390__)
+#define V8_TARGET_ARCH_S390 1
+#if defined(__s390x__)
+#define V8_TARGET_ARCH_S390X 1
+#endif
+#elif defined(__riscv) || defined(__riscv__)
+#if __riscv_xlen == 64
+#define V8_TARGET_ARCH_RISCV64 1
+#elif __riscv_xlen == 32
+#define V8_TARGET_ARCH_RISCV32 1
+#endif
+#else
+#error Target architecture was not detected as supported by v8
+#endif
 #endif
 
-#if defined(V8_SANDBOX) && !defined(V8_SANDBOX_IS_AVAILABLE)
-#error Inconsistent configuration: sandbox is enabled but not available
+// Determine architecture pointer size.
+#if V8_TARGET_ARCH_IA32
+#define V8_TARGET_ARCH_32_BIT 1
+#elif V8_TARGET_ARCH_X64
+#if !V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_64_BIT
+#if defined(__x86_64__) && __SIZEOF_POINTER__ == 4  // Check for x32.
+#define V8_TARGET_ARCH_32_BIT 1
+#else
+#define V8_TARGET_ARCH_64_BIT 1
+#endif
+#endif
+#elif V8_TARGET_ARCH_ARM
+#define V8_TARGET_ARCH_32_BIT 1
+#elif V8_TARGET_ARCH_ARM64
+#define V8_TARGET_ARCH_64_BIT 1
+#elif V8_TARGET_ARCH_MIPS
+#define V8_TARGET_ARCH_32_BIT 1
+#elif V8_TARGET_ARCH_MIPS64
+#define V8_TARGET_ARCH_64_BIT 1
+#elif V8_TARGET_ARCH_LOONG64
+#define V8_TARGET_ARCH_64_BIT 1
+#elif V8_TARGET_ARCH_PPC
+#define V8_TARGET_ARCH_32_BIT 1
+#elif V8_TARGET_ARCH_PPC64
+#define V8_TARGET_ARCH_64_BIT 1
+#elif V8_TARGET_ARCH_S390
+#if V8_TARGET_ARCH_S390X
+#define V8_TARGET_ARCH_64_BIT 1
+#else
+#define V8_TARGET_ARCH_32_BIT 1
+#endif
+#elif V8_TARGET_ARCH_RISCV64
+#define V8_TARGET_ARCH_64_BIT 1
+#elif V8_TARGET_ARCH_RISCV32
+#define V8_TARGET_ARCH_32_BIT 1
+#else
+#error Unknown target architecture pointer size
 #endif
 
-// From C++17 onwards, static constexpr member variables are defined to be
-// "inline", and adding a separate definition for them can trigger deprecation
-// warnings. For C++14 and below, however, these definitions are required.
-#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
-#define V8_STATIC_CONSTEXPR_VARIABLES_NEED_DEFINITIONS
+// Check for supported combinations of host and target architectures.
+#if V8_TARGET_ARCH_IA32 && !V8_HOST_ARCH_IA32
+#error Target architecture ia32 is only supported on ia32 host
+#endif
+#if (V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_64_BIT && \
+     !((V8_HOST_ARCH_X64 || V8_HOST_ARCH_ARM64) && V8_HOST_ARCH_64_BIT))
+#error Target architecture x64 is only supported on x64 and arm64 host
+#endif
+#if (V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_32_BIT && \
+     !(V8_HOST_ARCH_X64 && V8_HOST_ARCH_32_BIT))
+#error Target architecture x32 is only supported on x64 host with x32 support
+#endif
+#if (V8_TARGET_ARCH_ARM && !(V8_HOST_ARCH_IA32 || V8_HOST_ARCH_ARM))
+#error Target architecture arm is only supported on arm and ia32 host
+#endif
+#if (V8_TARGET_ARCH_ARM64 && !(V8_HOST_ARCH_X64 || V8_HOST_ARCH_ARM64))
+#error Target architecture arm64 is only supported on arm64 and x64 host
+#endif
+#if (V8_TARGET_ARCH_MIPS64 && !(V8_HOST_ARCH_X64 || V8_HOST_ARCH_MIPS64))
+#error Target architecture mips64 is only supported on mips64 and x64 host
+#endif
+#if (V8_TARGET_ARCH_RISCV64 && !(V8_HOST_ARCH_X64 || V8_HOST_ARCH_RISCV64))
+#error Target architecture riscv64 is only supported on riscv64 and x64 host
+#endif
+#if (V8_TARGET_ARCH_RISCV32 && !(V8_HOST_ARCH_IA32 || V8_HOST_ARCH_RISCV32))
+#error Target architecture riscv32 is only supported on riscv32 and ia32 host
+#endif
+#if (V8_TARGET_ARCH_LOONG64 && !(V8_HOST_ARCH_X64 || V8_HOST_ARCH_LOONG64))
+#error Target architecture loong64 is only supported on loong64 and x64 host
 #endif
 
-// clang-format on
+// Determine architecture endianness.
+#if V8_TARGET_ARCH_IA32
+#define V8_TARGET_LITTLE_ENDIAN 1
+#elif V8_TARGET_ARCH_X64
+#define V8_TARGET_LITTLE_ENDIAN 1
+#elif V8_TARGET_ARCH_ARM
+#define V8_TARGET_LITTLE_ENDIAN 1
+#elif V8_TARGET_ARCH_ARM64
+#define V8_TARGET_LITTLE_ENDIAN 1
+#elif V8_TARGET_ARCH_LOONG64
+#define V8_TARGET_LITTLE_ENDIAN 1
+#elif V8_TARGET_ARCH_MIPS64
+#if defined(__MIPSEB__) || defined(V8_TARGET_ARCH_MIPS64_BE)
+#define V8_TARGET_BIG_ENDIAN 1
+#else
+#define V8_TARGET_LITTLE_ENDIAN 1
+#endif
+#elif defined(__BIG_ENDIAN__)  // FOR PPCGR on AIX
+#define V8_TARGET_BIG_ENDIAN 1
+#elif V8_TARGET_ARCH_PPC_LE
+#define V8_TARGET_LITTLE_ENDIAN 1
+#elif V8_TARGET_ARCH_PPC_BE
+#define V8_TARGET_BIG_ENDIAN 1
+#elif V8_TARGET_ARCH_S390
+#if V8_TARGET_ARCH_S390_LE_SIM
+#define V8_TARGET_LITTLE_ENDIAN 1
+#else
+#define V8_TARGET_BIG_ENDIAN 1
+#endif
+#elif V8_TARGET_ARCH_RISCV32 || V8_TARGET_ARCH_RISCV64
+#define V8_TARGET_LITTLE_ENDIAN 1
+#elif defined(__BYTE_ORDER__)
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define V8_TARGET_BIG_ENDIAN 1
+#else
+#define V8_TARGET_LITTLE_ENDIAN 1
+#endif
+#else
+#error Unknown target architecture endianness
+#endif
 
 #undef V8_HAS_CPP_ATTRIBUTE
 
diff --git a/NativeScript/inspector/JsV8InspectorClient.mm b/NativeScript/inspector/JsV8InspectorClient.mm
index 25c0c54f..1b9447f7 100644
--- a/NativeScript/inspector/JsV8InspectorClient.mm
+++ b/NativeScript/inspector/JsV8InspectorClient.mm
@@ -163,7 +163,8 @@
 }
 
 void JsV8InspectorClient::createInspectorSession() {
-    this->session_ = this->inspector_->connect(JsV8InspectorClient::contextGroupId, this, {});
+    // FIXME: Consider a more restrictive default approach, or perhaps implement a blacklist of untrusted connections?
+    this->session_ = this->inspector_->connect(JsV8InspectorClient::contextGroupId, this, {}, V8Inspector::kFullyTrusted);
 }
 
 void JsV8InspectorClient::disconnect() {
@@ -205,9 +206,9 @@
             shouldWait = true;
         }
 
-        std::shared_ptr<Platform> platform = tns::Runtime::GetPlatform();
+        v8::Platform* platform = tns::Runtime::GetPlatform();
         Isolate* isolate = isolate_;
-        platform::PumpMessageLoop(platform.get(), isolate, platform::MessageLoopBehavior::kDoNotWait);
+        platform::PumpMessageLoop(platform, isolate, platform::MessageLoopBehavior::kDoNotWait);
         if(shouldWait && !terminated_) {
             dispatch_semaphore_wait(messageArrived_, dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_MSEC)); // 1ms
         }
diff --git a/NativeScript/inspector/src/debug/debug-coverage.h b/NativeScript/inspector/src/debug/debug-coverage.h
index 81b17818..bb0922f5 100644
--- a/NativeScript/inspector/src/debug/debug-coverage.h
+++ b/NativeScript/inspector/src/debug/debug-coverage.h
@@ -10,7 +10,6 @@
 
 #include "src/debug/debug-interface.h"
 #include "src/handles/handles.h"
-#include "src/objects/objects.h"
 
 namespace v8 {
 namespace internal {
diff --git a/NativeScript/inspector/src/debug/debug-evaluate.h b/NativeScript/inspector/src/debug/debug-evaluate.h
index 469d4a74..3962d00e 100644
--- a/NativeScript/inspector/src/debug/debug-evaluate.h
+++ b/NativeScript/inspector/src/debug/debug-evaluate.h
@@ -10,8 +10,8 @@
 #include "src/base/macros.h"
 #include "src/common/globals.h"
 #include "src/debug/debug-frames.h"
+#include "src/debug/debug-interface.h"
 #include "src/debug/debug-scopes.h"
-#include "src/debug/debug.h"
 #include "src/execution/frames.h"
 #include "src/objects/objects.h"
 #include "src/objects/shared-function-info.h"
diff --git a/NativeScript/inspector/src/debug/debug-frames.h b/NativeScript/inspector/src/debug/debug-frames.h
index 5197f862..3afa4ce7 100644
--- a/NativeScript/inspector/src/debug/debug-frames.h
+++ b/NativeScript/inspector/src/debug/debug-frames.h
@@ -19,7 +19,7 @@ class JavaScriptFrame;
 class CommonFrame;
 class WasmFrame;
 
-class FrameInspector {
+class V8_EXPORT_PRIVATE FrameInspector {
  public:
   FrameInspector(CommonFrame* frame, int inlined_frame_index, Isolate* isolate);
   FrameInspector(const FrameInspector&) = delete;
diff --git a/NativeScript/inspector/src/debug/debug-interface.h b/NativeScript/inspector/src/debug/debug-interface.h
index 0cac2ad9..c0f9f34f 100644
--- a/NativeScript/inspector/src/debug/debug-interface.h
+++ b/NativeScript/inspector/src/debug/debug-interface.h
@@ -11,6 +11,7 @@
 #include "include/v8-date.h"
 #include "include/v8-debug.h"
 #include "include/v8-embedder-heap.h"
+#include "include/v8-isolate.h"
 #include "include/v8-local-handle.h"
 #include "include/v8-memory-span.h"
 #include "include/v8-promise.h"
@@ -33,13 +34,10 @@ namespace internal {
 struct CoverageBlock;
 struct CoverageFunction;
 struct CoverageScript;
-struct TypeProfileEntry;
-struct TypeProfileScript;
 class Coverage;
 class DisableBreak;
 class PostponeInterruptsScope;
 class Script;
-class TypeProfile;
 }  // namespace internal
 
 namespace debug {
@@ -50,6 +48,9 @@ int GetContextId(Local<Context> context);
 void SetInspector(Isolate* isolate, v8_inspector::V8Inspector*);
 v8_inspector::V8Inspector* GetInspector(Isolate* isolate);
 
+// Returns a debug string representation of the bigint without tailing `n`.
+Local<String> GetBigIntStringValue(Isolate* isolate, Local<BigInt> bigint);
+
 // Returns a debug string representation of the bigint.
 Local<String> GetBigIntDescription(Isolate* isolate, Local<BigInt> bigint);
 
@@ -98,8 +99,9 @@ MaybeLocal<Context> GetCreationContext(Local<Object> value);
 
 enum ExceptionBreakState {
   NoBreakOnException = 0,
-  BreakOnUncaughtException = 1,
-  BreakOnAnyException = 2
+  BreakOnCaughtException = 1,
+  BreakOnUncaughtException = 2,
+  BreakOnAnyException = 3,
 };
 
 /**
@@ -135,6 +137,7 @@ enum class BreakReason : uint8_t {
 typedef base::EnumSet<BreakReason> BreakReasons;
 
 void PrepareStep(Isolate* isolate, StepAction action);
+bool PrepareRestartFrame(Isolate* isolate, int callFrameOrdinal);
 void ClearStepping(Isolate* isolate);
 V8_EXPORT_PRIVATE void BreakRightNow(
     Isolate* isolate, base::EnumSet<BreakReason> break_reason = {});
@@ -161,6 +164,7 @@ struct LiveEditResult {
   bool stack_changed = false;
   // Available only for OK.
   v8::Local<v8::debug::Script> script;
+  bool restart_top_frame_required = false;
   // Fields below are available only for COMPILE_ERROR.
   v8::Local<v8::String> message;
   int line_number = -1;
@@ -207,6 +211,7 @@ class V8_EXPORT_PRIVATE Script {
   MaybeLocal<String> Name() const;
   MaybeLocal<String> SourceURL() const;
   MaybeLocal<String> SourceMappingURL() const;
+  MaybeLocal<String> GetSha256Hash() const;
   Maybe<int> ContextId() const;
   Local<ScriptSource> Source() const;
   bool IsModule() const;
@@ -214,9 +219,13 @@ class V8_EXPORT_PRIVATE Script {
       const debug::Location& start, const debug::Location& end,
       bool restrict_to_function,
       std::vector<debug::BreakLocation>* locations) const;
-  int GetSourceOffset(const debug::Location& location) const;
+  enum class GetSourceOffsetMode { kStrict, kClamp };
+  Maybe<int> GetSourceOffset(
+      const debug::Location& location,
+      GetSourceOffsetMode mode = GetSourceOffsetMode::kStrict) const;
   v8::debug::Location GetSourceLocation(int offset) const;
   bool SetScriptSource(v8::Local<v8::String> newSource, bool preview,
+                       bool allow_top_frame_live_editing,
                        LiveEditResult* result) const;
   bool SetBreakpoint(v8::Local<v8::String> condition, debug::Location* location,
                      BreakpointId* id) const;
@@ -227,6 +236,13 @@ class V8_EXPORT_PRIVATE Script {
   bool SetInstrumentationBreakpoint(BreakpointId* id) const;
 };
 
+class DisassemblyCollector {
+ public:
+  virtual void ReserveLineCount(size_t count) = 0;
+  virtual void AddLine(const char* src, size_t length,
+                       uint32_t bytecode_offset) = 0;
+};
+
 #if V8_ENABLE_WEBASSEMBLY
 // Specialization for wasm Scripts.
 class WasmScript : public Script {
@@ -242,6 +258,9 @@ class WasmScript : public Script {
   std::pair<int, int> GetFunctionRange(int function_index) const;
   int GetContainingFunction(int byte_offset) const;
 
+  void Disassemble(DisassemblyCollector* collector,
+                   std::vector<int>* function_body_offsets);
+
   uint32_t GetFunctionHash(int function_index);
 
   int CodeOffset() const;
@@ -249,8 +268,8 @@ class WasmScript : public Script {
 };
 #endif  // V8_ENABLE_WEBASSEMBLY
 
-V8_EXPORT_PRIVATE void GetLoadedScripts(Isolate* isolate,
-                                        PersistentValueVector<Script>& scripts);
+V8_EXPORT_PRIVATE void GetLoadedScripts(
+    Isolate* isolate, std::vector<v8::Global<Script>>& scripts);
 
 MaybeLocal<UnboundScript> CompileInspectorScript(Isolate* isolate,
                                                  Local<String> source);
@@ -268,9 +287,16 @@ class DebugDelegate {
       v8::Local<v8::Context> paused_context,
       const std::vector<debug::BreakpointId>& inspector_break_points_hit,
       base::EnumSet<BreakReason> break_reasons = {}) {}
-  virtual void BreakOnInstrumentation(
+  enum class ActionAfterInstrumentation {
+    kPause,
+    kPauseIfBreakpointsHit,
+    kContinue
+  };
+  virtual ActionAfterInstrumentation BreakOnInstrumentation(
       v8::Local<v8::Context> paused_context,
-      const debug::BreakpointId instrumentationId) {}
+      const debug::BreakpointId instrumentationId) {
+    return ActionAfterInstrumentation::kPauseIfBreakpointsHit;
+  }
   virtual void ExceptionThrown(v8::Local<v8::Context> paused_context,
                                v8::Local<v8::Value> exception,
                                v8::Local<v8::Value> promise, bool is_uncaught,
@@ -290,8 +316,8 @@ V8_EXPORT_PRIVATE void SetDebugDelegate(Isolate* isolate,
                                         DebugDelegate* listener);
 
 #if V8_ENABLE_WEBASSEMBLY
-V8_EXPORT_PRIVATE void TierDownAllModulesPerIsolate(Isolate* isolate);
-V8_EXPORT_PRIVATE void TierUpAllModulesPerIsolate(Isolate* isolate);
+V8_EXPORT_PRIVATE void EnterDebuggingForIsolate(Isolate* isolate);
+V8_EXPORT_PRIVATE void LeaveDebuggingForIsolate(Isolate* isolate);
 #endif  // V8_ENABLE_WEBASSEMBLY
 
 class AsyncEventDelegate {
@@ -417,64 +443,6 @@ class V8_EXPORT_PRIVATE Coverage {
   std::shared_ptr<i::Coverage> coverage_;
 };
 
-/*
- * Provide API layer between inspector and type profile.
- */
-class V8_EXPORT_PRIVATE TypeProfile {
- public:
-  MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(TypeProfile);
-
-  class ScriptData;  // Forward declaration.
-
-  class V8_EXPORT_PRIVATE Entry {
-   public:
-    MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(Entry);
-
-    int SourcePosition() const;
-    std::vector<MaybeLocal<String>> Types() const;
-
-   private:
-    explicit Entry(const i::TypeProfileEntry* entry,
-                   std::shared_ptr<i::TypeProfile> type_profile)
-        : entry_(entry), type_profile_(std::move(type_profile)) {}
-
-    const i::TypeProfileEntry* entry_;
-    std::shared_ptr<i::TypeProfile> type_profile_;
-
-    friend class v8::debug::TypeProfile::ScriptData;
-  };
-
-  class V8_EXPORT_PRIVATE ScriptData {
-   public:
-    MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(ScriptData);
-
-    Local<debug::Script> GetScript() const;
-    std::vector<Entry> Entries() const;
-
-   private:
-    explicit ScriptData(size_t index,
-                        std::shared_ptr<i::TypeProfile> type_profile);
-
-    i::TypeProfileScript* script_;
-    std::shared_ptr<i::TypeProfile> type_profile_;
-
-    friend class v8::debug::TypeProfile;
-  };
-
-  static TypeProfile Collect(Isolate* isolate);
-
-  static void SelectMode(Isolate* isolate, TypeProfileMode mode);
-
-  size_t ScriptCount() const;
-  ScriptData GetScriptData(size_t i) const;
-
- private:
-  explicit TypeProfile(std::shared_ptr<i::TypeProfile> type_profile)
-      : type_profile_(std::move(type_profile)) {}
-
-  std::shared_ptr<i::TypeProfile> type_profile_;
-};
-
 class V8_EXPORT_PRIVATE ScopeIterator {
  public:
   static std::unique_ptr<ScopeIterator> CreateForFunction(
@@ -548,17 +516,18 @@ class QueryObjectPredicate {
 
 void QueryObjects(v8::Local<v8::Context> context,
                   QueryObjectPredicate* predicate,
-                  v8::PersistentValueVector<v8::Object>* objects);
+                  std::vector<v8::Global<v8::Object>>* objects);
 
 void GlobalLexicalScopeNames(v8::Local<v8::Context> context,
-                             v8::PersistentValueVector<v8::String>* names);
+                             std::vector<v8::Global<v8::String>>* names);
 
 void SetReturnValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
 
 enum class NativeAccessorType {
   None = 0,
   HasGetter = 1 << 0,
-  HasSetter = 1 << 1
+  HasSetter = 1 << 1,
+  IsValueUnavailable = 1 << 2
 };
 
 int64_t GetNextRandomInt64(v8::Isolate* isolate);
@@ -584,14 +553,14 @@ V8_EXPORT_PRIVATE v8::MaybeLocal<v8::Value> EvaluateGlobalForTesting(
 
 int GetDebuggingId(v8::Local<v8::Function> function);
 
-bool SetFunctionBreakpoint(v8::Local<v8::Function> function,
-                           v8::Local<v8::String> condition, BreakpointId* id);
+V8_EXPORT_PRIVATE bool SetFunctionBreakpoint(v8::Local<v8::Function> function,
+                                             v8::Local<v8::String> condition,
+                                             BreakpointId* id);
 
 v8::Platform* GetCurrentPlatform();
 
-void ForceGarbageCollection(
-    v8::Isolate* isolate,
-    v8::EmbedderHeapTracer::EmbedderStackState embedder_stack_state);
+void ForceGarbageCollection(v8::Isolate* isolate,
+                            v8::StackState embedder_stack_state);
 
 class V8_NODISCARD PostponeInterruptsScope {
  public:
@@ -710,7 +679,9 @@ AccessorPair* AccessorPair::Cast(v8::Value* value) {
 
 MaybeLocal<Message> GetMessageFromPromise(Local<Promise> promise);
 
-bool isExperimentalAsyncStackTaggingApiEnabled();
+void RecordAsyncStackTaggingCreateTaskCall(v8::Isolate* isolate);
+
+void NotifyDebuggerPausedEventSent(v8::Isolate* isolate);
 
 }  // namespace debug
 }  // namespace v8
diff --git a/NativeScript/inspector/src/debug/debug-scopes.h b/NativeScript/inspector/src/debug/debug-scopes.h
index a499a6f3..d11a6059 100644
--- a/NativeScript/inspector/src/debug/debug-scopes.h
+++ b/NativeScript/inspector/src/debug/debug-scopes.h
@@ -18,7 +18,7 @@ class ParseInfo;
 // The iteration proceeds from the innermost visible nested scope outwards.
 // All scopes are backed by an actual context except the local scope,
 // which is inserted "artificially" in the context chain.
-class ScopeIterator {
+class V8_EXPORT_PRIVATE ScopeIterator {
  public:
   enum ScopeType {
     ScopeTypeGlobal = 0,
@@ -41,8 +41,11 @@ class ScopeIterator {
   static const int kScopeDetailsSize = 6;
 
   enum class ReparseStrategy {
-    kScript,
     kFunctionLiteral,
+    // Checks whether the paused function (and its scope chain) already has
+    // its blocklist calculated and re-parses the whole script if not.
+    // Otherwise only the function literal is re-parsed.
+    kScriptIfNeeded,
   };
 
   ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
@@ -101,7 +104,7 @@ class ScopeIterator {
 
   bool InInnerScope() const { return !function_.is_null(); }
   bool HasContext() const;
-  bool NeedsAndHasContext() const;
+  bool NeedsContext() const;
   Handle<Context> CurrentContext() const {
     DCHECK(HasContext());
     return context_;
@@ -125,17 +128,27 @@ class ScopeIterator {
   Scope* start_scope_ = nullptr;
   Scope* current_scope_ = nullptr;
   bool seen_script_scope_ = false;
+  bool calculate_blocklists_ = false;
 
   inline JavaScriptFrame* GetFrame() const {
     return frame_inspector_->javascript_frame();
   }
 
-  void AdvanceOneScope();
-  void AdvanceToNonHiddenScope();
+  bool AdvanceOneScope();
+  void AdvanceOneContext();
+  void AdvanceScope();
   void AdvanceContext();
   void CollectLocalsFromCurrentScope();
 
-  int GetSourcePosition();
+  // Calculates all the block list starting at the current scope and stores
+  // them in the global "LocalsBlocklistCache".
+  //
+  // Is a no-op unless `calculate_blocklists_` is true and
+  // current_scope_ == closure_scope_. Otherwise `context_` does not match
+  // with current_scope_/closure_scope_.
+  void MaybeCollectAndStoreLocalBlocklists() const;
+
+  int GetSourcePosition() const;
 
   void TryParseAndRetrieveScopes(ReparseStrategy strategy);
 
diff --git a/NativeScript/inspector/src/debug/debug-stack-trace-iterator.h b/NativeScript/inspector/src/debug/debug-stack-trace-iterator.h
index ed06b584..8bddcf9a 100644
--- a/NativeScript/inspector/src/debug/debug-stack-trace-iterator.h
+++ b/NativeScript/inspector/src/debug/debug-stack-trace-iterator.h
@@ -34,6 +34,9 @@ class DebugStackTraceIterator final : public debug::StackTraceIterator {
 
   v8::MaybeLocal<v8::Value> Evaluate(v8::Local<v8::String> source,
                                      bool throw_on_side_effect) override;
+  void PrepareRestart();
+
+  Handle<SharedFunctionInfo> GetSharedFunctionInfo() const;
 
  private:
   void UpdateInlineFrameIndexAndResumableFnOnStack();
diff --git a/NativeScript/inspector/src/debug/debug.h b/NativeScript/inspector/src/debug/debug.h
index ce3d52ab..cf49ce66 100644
--- a/NativeScript/inspector/src/debug/debug.h
+++ b/NativeScript/inspector/src/debug/debug.h
@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "src/base/enum-set.h"
+#include "src/base/platform/elapsed-timer.h"
 #include "src/codegen/source-position-table.h"
 #include "src/common/globals.h"
 #include "src/debug/debug-interface.h"
@@ -41,7 +42,10 @@ enum StepAction : int8_t {
 };
 
 // Type of exception break. NOTE: These values are in macros.py as well.
-enum ExceptionBreakType { BreakException = 0, BreakUncaughtException = 1 };
+enum ExceptionBreakType {
+  BreakCaughtException = 0,
+  BreakUncaughtException = 1,
+};
 
 // Type of debug break. NOTE: The order matters for the predicates
 // below inside BreakLocation, so be careful when adding / removing.
@@ -65,6 +69,7 @@ class BreakLocation {
   static BreakLocation Invalid() { return BreakLocation(-1, NOT_DEBUG_BREAK); }
   static BreakLocation FromFrame(Handle<DebugInfo> debug_info,
                                  JavaScriptFrame* frame);
+  static bool IsPausedInJsFunctionEntry(JavaScriptFrame* frame);
 
   static void AllAtCurrentStatement(Handle<DebugInfo> debug_info,
                                     JavaScriptFrame* frame,
@@ -148,13 +153,13 @@ class V8_EXPORT_PRIVATE BreakIterator {
   void ClearDebugBreak();
   void SetDebugBreak();
 
+  DebugBreakType GetDebugBreakType();
+
  private:
   int BreakIndexFromPosition(int position);
 
   Isolate* isolate();
 
-  DebugBreakType GetDebugBreakType();
-
   Handle<DebugInfo> debug_info_;
   int break_index_;
   int position_;
@@ -218,7 +223,7 @@ class V8_EXPORT_PRIVATE Debug {
   // Debug event triggers.
   void OnDebugBreak(Handle<FixedArray> break_points_hit, StepAction stepAction,
                     debug::BreakReasons break_reasons = {});
-  void OnInstrumentationBreak();
+  debug::DebugDelegate::ActionAfterInstrumentation OnInstrumentationBreak();
 
   base::Optional<Object> OnThrow(Handle<Object> exception)
       V8_WARN_UNUSED_RESULT;
@@ -274,6 +279,7 @@ class V8_EXPORT_PRIVATE Debug {
   void PrepareStepInSuspendedGenerator();
   void PrepareStepOnThrow();
   void ClearStepping();
+  void PrepareRestartFrame(JavaScriptFrame* frame, int inlined_frame_index);
 
   void SetBreakOnNextFunctionCall();
   void ClearBreakOnNextFunctionCall();
@@ -329,7 +335,8 @@ class V8_EXPORT_PRIVATE Debug {
   // change. stack_changed is true if after editing script on pause stack is
   // changed and client should request stack trace again.
   bool SetScriptSource(Handle<Script> script, Handle<String> source,
-                       bool preview, debug::LiveEditResult* result);
+                       bool preview, bool allow_top_frame_live_editing,
+                       debug::LiveEditResult* result);
 
   int GetFunctionDebuggingId(Handle<JSFunction> function);
 
@@ -393,6 +400,24 @@ class V8_EXPORT_PRIVATE Debug {
     return thread_local_.break_on_next_function_call_;
   }
 
+  bool scheduled_break_on_function_call() const {
+    return thread_local_.scheduled_break_on_next_function_call_;
+  }
+
+  bool IsRestartFrameScheduled() const {
+    return thread_local_.restart_frame_id_ != StackFrameId::NO_ID;
+  }
+  bool ShouldRestartFrame(StackFrameId id) const {
+    return IsRestartFrameScheduled() && thread_local_.restart_frame_id_ == id;
+  }
+  void clear_restart_frame() {
+    thread_local_.restart_frame_id_ = StackFrameId::NO_ID;
+    thread_local_.restart_inline_frame_index_ = -1;
+  }
+  int restart_inline_frame_index() const {
+    return thread_local_.restart_inline_frame_index_;
+  }
+
   inline bool break_disabled() const { return break_disabled_; }
 
   DebugFeatureTracker* feature_tracker() { return &feature_tracker_; }
@@ -406,6 +431,9 @@ class V8_EXPORT_PRIVATE Debug {
 
   void RemoveBreakInfoAndMaybeFree(Handle<DebugInfo> debug_info);
 
+  // Stops the timer for the top-most `DebugScope` and records a UMA event.
+  void NotifyDebuggerPausedEventSent();
+
   static char* Iterate(RootVisitor* v, char* thread_storage);
 
  private:
@@ -508,8 +536,8 @@ class V8_EXPORT_PRIVATE Debug {
   bool break_disabled_;
   // Do not break on break points.
   bool break_points_active_;
-  // Trigger debug break events for all exceptions.
-  bool break_on_exception_;
+  // Trigger debug break events for caught exceptions.
+  bool break_on_caught_exception_;
   // Trigger debug break events for uncaught exceptions.
   bool break_on_uncaught_exception_;
   // Termination exception because side effect check has failed.
@@ -549,6 +577,9 @@ class V8_EXPORT_PRIVATE Debug {
     // Source statement position from last step next action.
     int last_statement_position_;
 
+    // Bytecode offset from last step next action.
+    int last_bytecode_offset_;
+
     // Frame pointer from last step next or step frame action.
     int last_frame_count_;
 
@@ -568,9 +599,25 @@ class V8_EXPORT_PRIVATE Debug {
     // debugger to break on next function call.
     bool break_on_next_function_call_;
 
+    // This flag is true when we break via stack check (BreakReason::kScheduled)
+    // We don't stay paused there but instead "step in" to the function similar
+    // to what "BreakOnNextFunctionCall" does.
+    bool scheduled_break_on_next_function_call_;
+
     // Throwing an exception may cause a Promise rejection.  For this purpose
     // we keep track of a stack of nested promises.
     Object promise_stack_;
+
+    // Frame ID for the frame that needs to be restarted. StackFrameId::NO_ID
+    // otherwise. The unwinder uses the id to restart execution in this frame
+    // instead of any potential catch handler.
+    StackFrameId restart_frame_id_;
+
+    // If `restart_frame_id_` is an optimized frame, then this index denotes
+    // which of the inlined frames we actually want to restart. The
+    // deoptimizer uses the info to materialize and drop execution into the
+    // right frame.
+    int restart_inline_frame_index_;
   };
 
   static void Iterate(RootVisitor* v, ThreadLocal* thread_local_data);
@@ -605,6 +652,8 @@ class V8_NODISCARD DebugScope {
 
   void set_terminate_on_resume();
 
+  base::TimeDelta ElapsedTimeSinceCreation();
+
  private:
   Isolate* isolate() { return debug_->isolate_; }
 
@@ -614,6 +663,10 @@ class V8_NODISCARD DebugScope {
   PostponeInterruptsScope no_interrupts_;
   // This is used as a boolean.
   bool terminate_on_resume_ = false;
+
+  // Measures (for UMA) the duration beginning when we enter this `DebugScope`
+  // until we potentially send a "Debugger.paused" response in the inspector.
+  base::ElapsedTimer timer_;
 };
 
 // This scope is used to handle return values in nested debug break points.
diff --git a/NativeScript/inspector/src/debug/interface-types.h b/NativeScript/inspector/src/debug/interface-types.h
index 7fb95ef1..71bf7fd1 100644
--- a/NativeScript/inspector/src/debug/interface-types.h
+++ b/NativeScript/inspector/src/debug/interface-types.h
@@ -9,7 +9,7 @@
 
 #include "include/v8-function-callback.h"
 #include "include/v8-local-handle.h"
-#include "src/common/globals.h"
+#include "src/base/macros.h"
 
 namespace v8 {
 
@@ -78,11 +78,6 @@ enum class CoverageMode {
   kBlockBinary,
 };
 
-enum class TypeProfileMode {
-  kNone,
-  kCollect,
-};
-
 class V8_EXPORT_PRIVATE BreakLocation : public Location {
  public:
   BreakLocation(int line_number, int column_number, BreakLocationType type)
diff --git a/NativeScript/inspector/src/debug/liveedit-diff.h b/NativeScript/inspector/src/debug/liveedit-diff.h
new file mode 100644
index 00000000..15bedc3e
--- /dev/null
+++ b/NativeScript/inspector/src/debug/liveedit-diff.h
@@ -0,0 +1,44 @@
+// 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.
+
+#ifndef V8_DEBUG_LIVEEDIT_DIFF_H_
+#define V8_DEBUG_LIVEEDIT_DIFF_H_
+
+namespace v8 {
+namespace internal {
+
+// A general-purpose comparator between 2 arrays.
+class Comparator {
+ public:
+  // Holds 2 arrays of some elements allowing to compare any pair of
+  // element from the first array and element from the second array.
+  class Input {
+   public:
+    virtual int GetLength1() = 0;
+    virtual int GetLength2() = 0;
+    virtual bool Equals(int index1, int index2) = 0;
+
+   protected:
+    virtual ~Input() = default;
+  };
+
+  // Receives compare result as a series of chunks.
+  class Output {
+   public:
+    // Puts another chunk in result list. Note that technically speaking
+    // only 3 arguments actually needed with 4th being derivable.
+    virtual void AddChunk(int pos1, int pos2, int len1, int len2) = 0;
+
+   protected:
+    virtual ~Output() = default;
+  };
+
+  // Finds the difference between 2 arrays of elements.
+  static void CalculateDifference(Input* input, Output* result_writer);
+};
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_DEBUG_LIVEEDIT_DIFF_H_
diff --git a/NativeScript/inspector/src/debug/liveedit.h b/NativeScript/inspector/src/debug/liveedit.h
index 5e06d3f2..707daa9c 100644
--- a/NativeScript/inspector/src/debug/liveedit.h
+++ b/NativeScript/inspector/src/debug/liveedit.h
@@ -63,6 +63,7 @@ class V8_EXPORT_PRIVATE LiveEdit : AllStatic {
                                int position);
   static void PatchScript(Isolate* isolate, Handle<Script> script,
                           Handle<String> source, bool preview,
+                          bool allow_top_frame_live_editing,
                           debug::LiveEditResult* result);
 };
 }  // namespace internal
diff --git a/NativeScript/inspector/src/inspector/crc32.h b/NativeScript/inspector/src/inspector/crc32.h
new file mode 100644
index 00000000..c20b56a6
--- /dev/null
+++ b/NativeScript/inspector/src/inspector/crc32.h
@@ -0,0 +1,16 @@
+// Copyright 2023 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_INSPECTOR_CRC32_H_
+#define V8_INSPECTOR_CRC32_H_
+
+#include "src/inspector/string-16.h"
+
+namespace v8_inspector {
+
+int32_t computeCrc32(const String16&);
+
+}
+
+#endif  // V8_INSPECTOR_CRC32_H_
diff --git a/NativeScript/inspector/src/inspector/injected-script.h b/NativeScript/inspector/src/inspector/injected-script.h
index 50257632..4f5bbf28 100644
--- a/NativeScript/inspector/src/inspector/injected-script.h
+++ b/NativeScript/inspector/src/inspector/injected-script.h
@@ -58,12 +58,22 @@ using protocol::Response;
 
 class EvaluateCallback {
  public:
+  static void sendSuccess(
+      std::weak_ptr<EvaluateCallback> callback, InjectedScript* injectedScript,
+      std::unique_ptr<protocol::Runtime::RemoteObject> result,
+      protocol::Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails);
+  static void sendFailure(std::weak_ptr<EvaluateCallback> callback,
+                          InjectedScript* injectedScript,
+                          const protocol::DispatchResponse& response);
+
+  virtual ~EvaluateCallback() = default;
+
+ private:
   virtual void sendSuccess(
       std::unique_ptr<protocol::Runtime::RemoteObject> result,
       protocol::Maybe<protocol::Runtime::ExceptionDetails>
           exceptionDetails) = 0;
   virtual void sendFailure(const protocol::DispatchResponse& response) = 0;
-  virtual ~EvaluateCallback() = default;
 };
 
 class InjectedScript final {
@@ -113,8 +123,8 @@ class InjectedScript final {
   void addPromiseCallback(V8InspectorSessionImpl* session,
                           v8::MaybeLocal<v8::Value> value,
                           const String16& objectGroup, WrapMode wrapMode,
-                          bool replMode,
-                          std::unique_ptr<EvaluateCallback> callback);
+                          bool replMode, bool throwOnSideEffect,
+                          std::shared_ptr<EvaluateCallback> callback);
 
   Response findObject(const RemoteObjectId&, v8::Local<v8::Value>*) const;
   String16 objectGroupName(const RemoteObjectId&) const;
@@ -133,7 +143,7 @@ class InjectedScript final {
 
   Response wrapEvaluateResult(
       v8::MaybeLocal<v8::Value> maybeResultValue, const v8::TryCatch&,
-      const String16& objectGroup, WrapMode wrapMode,
+      const String16& objectGroup, WrapMode wrapMode, bool throwOnSideEffect,
       std::unique_ptr<protocol::Runtime::RemoteObject>* result,
       Maybe<protocol::Runtime::ExceptionDetails>*);
   v8::Local<v8::Value> lastEvaluationResult() const;
@@ -221,6 +231,8 @@ class InjectedScript final {
   String16 bindObject(v8::Local<v8::Value>, const String16& groupName);
 
  private:
+  friend class EvaluateCallback;
+
   v8::Local<v8::Object> commandLineAPI();
   void unbindObject(int id);
 
@@ -230,8 +242,7 @@ class InjectedScript final {
 
   class ProtocolPromiseHandler;
   void discardEvaluateCallbacks();
-  std::unique_ptr<EvaluateCallback> takeEvaluateCallback(
-      EvaluateCallback* callback);
+  void deleteEvaluateCallback(std::shared_ptr<EvaluateCallback> callback);
   Response addExceptionToDetails(
       v8::Local<v8::Value> exception,
       protocol::Runtime::ExceptionDetails* exceptionDetails,
@@ -245,7 +256,7 @@ class InjectedScript final {
   std::unordered_map<int, v8::Global<v8::Value>> m_idToWrappedObject;
   std::unordered_map<int, String16> m_idToObjectGroupName;
   std::unordered_map<String16, std::vector<int>> m_nameToObjectGroup;
-  std::unordered_set<EvaluateCallback*> m_evaluateCallbacks;
+  std::unordered_set<std::shared_ptr<EvaluateCallback>> m_evaluateCallbacks;
   bool m_customPreviewEnabled = false;
 };
 
diff --git a/NativeScript/inspector/src/inspector/protocol/Console.h b/NativeScript/inspector/src/inspector/protocol/Console.h
index fb5547cc..4a4b7f4e 100644
--- a/NativeScript/inspector/src/inspector/protocol/Console.h
+++ b/NativeScript/inspector/src/inspector/protocol/Console.h
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/NativeScript/inspector/src/inspector/protocol/Debugger.h b/NativeScript/inspector/src/inspector/protocol/Debugger.h
index 0cd5c32a..e0079dcd 100644
--- a/NativeScript/inspector/src/inspector/protocol/Debugger.h
+++ b/NativeScript/inspector/src/inspector/protocol/Debugger.h
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -25,6 +25,7 @@ class CallFrame;
 class Scope;
 class SearchMatch;
 class BreakLocation;
+class WasmDisassemblyChunk;
 using ScriptLanguage = String;
 class DebugSymbols;
 
@@ -42,6 +43,12 @@ namespace TargetCallFramesEnum {
 } // TargetCallFramesEnum
 } // ContinueToLocation
 
+namespace RestartFrame {
+namespace ModeEnum {
+ extern const char* StepInto;
+} // ModeEnum
+} // RestartFrame
+
 namespace SetInstrumentationBreakpoint {
 namespace InstrumentationEnum {
  extern const char* BeforeScriptExecution;
@@ -52,11 +59,21 @@ namespace InstrumentationEnum {
 namespace SetPauseOnExceptions {
 namespace StateEnum {
  extern const char* None;
+ extern const char* Caught;
  extern const char* Uncaught;
  extern const char* All;
 } // StateEnum
 } // SetPauseOnExceptions
 
+namespace SetScriptSource {
+namespace StatusEnum {
+ extern const char* Ok;
+ extern const char* CompileError;
+ extern const char* BlockedByActiveGenerator;
+ extern const char* BlockedByActiveFunction;
+} // StatusEnum
+} // SetScriptSource
+
 namespace Paused {
 namespace ReasonEnum {
  extern const char* Ambiguous;
@@ -743,6 +760,75 @@ class  BreakLocation : public ::v8_crdtp::ProtocolObject<BreakLocation> {
 };
 
 
+class  WasmDisassemblyChunk : public ::v8_crdtp::ProtocolObject<WasmDisassemblyChunk> {
+public:
+    ~WasmDisassemblyChunk() override { }
+
+    protocol::Array<String>* getLines() { return m_lines.get(); }
+    void setLines(std::unique_ptr<protocol::Array<String>> value) { m_lines = std::move(value); }
+
+    protocol::Array<int>* getBytecodeOffsets() { return m_bytecodeOffsets.get(); }
+    void setBytecodeOffsets(std::unique_ptr<protocol::Array<int>> value) { m_bytecodeOffsets = std::move(value); }
+
+    template<int STATE>
+    class WasmDisassemblyChunkBuilder {
+    public:
+        enum {
+            NoFieldsSet = 0,
+            LinesSet = 1 << 1,
+            BytecodeOffsetsSet = 1 << 2,
+            AllFieldsSet = (LinesSet | BytecodeOffsetsSet | 0)};
+
+
+        WasmDisassemblyChunkBuilder<STATE | LinesSet>& setLines(std::unique_ptr<protocol::Array<String>> value)
+        {
+            static_assert(!(STATE & LinesSet), "property lines should not be set yet");
+            m_result->setLines(std::move(value));
+            return castState<LinesSet>();
+        }
+
+        WasmDisassemblyChunkBuilder<STATE | BytecodeOffsetsSet>& setBytecodeOffsets(std::unique_ptr<protocol::Array<int>> value)
+        {
+            static_assert(!(STATE & BytecodeOffsetsSet), "property bytecodeOffsets should not be set yet");
+            m_result->setBytecodeOffsets(std::move(value));
+            return castState<BytecodeOffsetsSet>();
+        }
+
+        std::unique_ptr<WasmDisassemblyChunk> build()
+        {
+            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
+            return std::move(m_result);
+        }
+
+    private:
+        friend class WasmDisassemblyChunk;
+        WasmDisassemblyChunkBuilder() : m_result(new WasmDisassemblyChunk()) { }
+
+        template<int STEP> WasmDisassemblyChunkBuilder<STATE | STEP>& castState()
+        {
+            return *reinterpret_cast<WasmDisassemblyChunkBuilder<STATE | STEP>*>(this);
+        }
+
+        std::unique_ptr<protocol::Debugger::WasmDisassemblyChunk> m_result;
+    };
+
+    static WasmDisassemblyChunkBuilder<0> create()
+    {
+        return WasmDisassemblyChunkBuilder<0>();
+    }
+
+private:
+    DECLARE_SERIALIZATION_SUPPORT();
+
+    WasmDisassemblyChunk()
+    {
+    }
+
+    std::unique_ptr<protocol::Array<String>> m_lines;
+    std::unique_ptr<protocol::Array<int>> m_bytecodeOffsets;
+};
+
+
 class  DebugSymbols : public ::v8_crdtp::ProtocolObject<DebugSymbols> {
 public:
     ~DebugSymbols() override { }
@@ -830,12 +916,14 @@ class  Backend {
     virtual DispatchResponse evaluateOnCallFrame(const String& in_callFrameId, const String& in_expression, Maybe<String> in_objectGroup, Maybe<bool> in_includeCommandLineAPI, Maybe<bool> in_silent, Maybe<bool> in_returnByValue, Maybe<bool> in_generatePreview, Maybe<bool> in_throwOnSideEffect, Maybe<double> in_timeout, std::unique_ptr<protocol::Runtime::RemoteObject>* out_result, Maybe<protocol::Runtime::ExceptionDetails>* out_exceptionDetails) = 0;
     virtual DispatchResponse getPossibleBreakpoints(std::unique_ptr<protocol::Debugger::Location> in_start, Maybe<protocol::Debugger::Location> in_end, Maybe<bool> in_restrictToFunction, std::unique_ptr<protocol::Array<protocol::Debugger::BreakLocation>>* out_locations) = 0;
     virtual DispatchResponse getScriptSource(const String& in_scriptId, String* out_scriptSource, Maybe<Binary>* out_bytecode) = 0;
+    virtual DispatchResponse disassembleWasmModule(const String& in_scriptId, Maybe<String>* out_streamId, int* out_totalNumberOfLines, std::unique_ptr<protocol::Array<int>>* out_functionBodyOffsets, std::unique_ptr<protocol::Debugger::WasmDisassemblyChunk>* out_chunk) = 0;
+    virtual DispatchResponse nextWasmDisassemblyChunk(const String& in_streamId, std::unique_ptr<protocol::Debugger::WasmDisassemblyChunk>* out_chunk) = 0;
     virtual DispatchResponse getWasmBytecode(const String& in_scriptId, Binary* out_bytecode) = 0;
     virtual DispatchResponse getStackTrace(std::unique_ptr<protocol::Runtime::StackTraceId> in_stackTraceId, std::unique_ptr<protocol::Runtime::StackTrace>* out_stackTrace) = 0;
     virtual DispatchResponse pause() = 0;
     virtual DispatchResponse pauseOnAsyncCall(std::unique_ptr<protocol::Runtime::StackTraceId> in_parentStackTraceId) = 0;
     virtual DispatchResponse removeBreakpoint(const String& in_breakpointId) = 0;
-    virtual DispatchResponse restartFrame(const String& in_callFrameId, std::unique_ptr<protocol::Array<protocol::Debugger::CallFrame>>* out_callFrames, Maybe<protocol::Runtime::StackTrace>* out_asyncStackTrace, Maybe<protocol::Runtime::StackTraceId>* out_asyncStackTraceId) = 0;
+    virtual DispatchResponse restartFrame(const String& in_callFrameId, Maybe<String> in_mode, std::unique_ptr<protocol::Array<protocol::Debugger::CallFrame>>* out_callFrames, Maybe<protocol::Runtime::StackTrace>* out_asyncStackTrace, Maybe<protocol::Runtime::StackTraceId>* out_asyncStackTraceId) = 0;
     virtual DispatchResponse resume(Maybe<bool> in_terminateOnResume) = 0;
     virtual DispatchResponse searchInContent(const String& in_scriptId, const String& in_query, Maybe<bool> in_caseSensitive, Maybe<bool> in_isRegex, std::unique_ptr<protocol::Array<protocol::Debugger::SearchMatch>>* out_result) = 0;
     virtual DispatchResponse setAsyncCallStackDepth(int in_maxDepth) = 0;
@@ -848,7 +936,7 @@ class  Backend {
     virtual DispatchResponse setBreakpointsActive(bool in_active) = 0;
     virtual DispatchResponse setPauseOnExceptions(const String& in_state) = 0;
     virtual DispatchResponse setReturnValue(std::unique_ptr<protocol::Runtime::CallArgument> in_newValue) = 0;
-    virtual DispatchResponse setScriptSource(const String& in_scriptId, const String& in_scriptSource, Maybe<bool> in_dryRun, Maybe<protocol::Array<protocol::Debugger::CallFrame>>* out_callFrames, Maybe<bool>* out_stackChanged, Maybe<protocol::Runtime::StackTrace>* out_asyncStackTrace, Maybe<protocol::Runtime::StackTraceId>* out_asyncStackTraceId, Maybe<protocol::Runtime::ExceptionDetails>* out_exceptionDetails) = 0;
+    virtual DispatchResponse setScriptSource(const String& in_scriptId, const String& in_scriptSource, Maybe<bool> in_dryRun, Maybe<bool> in_allowTopFrameEditing, Maybe<protocol::Array<protocol::Debugger::CallFrame>>* out_callFrames, Maybe<bool>* out_stackChanged, Maybe<protocol::Runtime::StackTrace>* out_asyncStackTrace, Maybe<protocol::Runtime::StackTraceId>* out_asyncStackTraceId, String* out_status, Maybe<protocol::Runtime::ExceptionDetails>* out_exceptionDetails) = 0;
     virtual DispatchResponse setSkipAllPauses(bool in_skip) = 0;
     virtual DispatchResponse setVariableValue(int in_scopeNumber, const String& in_variableName, std::unique_ptr<protocol::Runtime::CallArgument> in_newValue, const String& in_callFrameId) = 0;
     virtual DispatchResponse stepInto(Maybe<bool> in_breakOnAsyncCall, Maybe<protocol::Array<protocol::Debugger::LocationRange>> in_skipList) = 0;
diff --git a/NativeScript/inspector/src/inspector/protocol/Forward.h b/NativeScript/inspector/src/inspector/protocol/Forward.h
index 6699f79a..f9e5b698 100644
--- a/NativeScript/inspector/src/inspector/protocol/Forward.h
+++ b/NativeScript/inspector/src/inspector/protocol/Forward.h
@@ -1,13 +1,12 @@
 // This file is generated by Forward_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef v8_inspector_protocol_Forward_h
 #define v8_inspector_protocol_Forward_h
 
-#include "src/inspector/string-util.h"
 
 #include <memory>
 #include <vector>
@@ -17,20 +16,23 @@
 #include "third_party/inspector_protocol/crdtp/frontend_channel.h"
 #include "third_party/inspector_protocol/crdtp/protocol_core.h"
 
+#include "src/inspector/string-util.h"
+
 namespace v8_inspector {
 namespace protocol {
 
-class DictionaryValue;
 using DispatchResponse = v8_crdtp::DispatchResponse;
 using ErrorSupport = v8_crdtp::ErrorSupport;
 using Serializable = v8_crdtp::Serializable;
 using FrontendChannel = v8_crdtp::FrontendChannel;
 using DomainDispatcher = v8_crdtp::DomainDispatcher;
 using UberDispatcher = v8_crdtp::UberDispatcher;
+using Response = DispatchResponse;
+
+class DictionaryValue;
 class FundamentalValue;
 class ListValue;
 class Object;
-using Response = DispatchResponse;
 class SerializedValue;
 class StringValue;
 class Value;
diff --git a/NativeScript/inspector/src/inspector/protocol/HeapProfiler.h b/NativeScript/inspector/src/inspector/protocol/HeapProfiler.h
index d9a2c44c..9b0030c8 100644
--- a/NativeScript/inspector/src/inspector/protocol/HeapProfiler.h
+++ b/NativeScript/inspector/src/inspector/protocol/HeapProfiler.h
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -292,11 +292,11 @@ class  Backend {
     virtual DispatchResponse getHeapObjectId(const String& in_objectId, String* out_heapSnapshotObjectId) = 0;
     virtual DispatchResponse getObjectByHeapObjectId(const String& in_objectId, Maybe<String> in_objectGroup, std::unique_ptr<protocol::Runtime::RemoteObject>* out_result) = 0;
     virtual DispatchResponse getSamplingProfile(std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>* out_profile) = 0;
-    virtual DispatchResponse startSampling(Maybe<double> in_samplingInterval) = 0;
+    virtual DispatchResponse startSampling(Maybe<double> in_samplingInterval, Maybe<bool> in_includeObjectsCollectedByMajorGC, Maybe<bool> in_includeObjectsCollectedByMinorGC) = 0;
     virtual DispatchResponse startTrackingHeapObjects(Maybe<bool> in_trackAllocations) = 0;
     virtual DispatchResponse stopSampling(std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>* out_profile) = 0;
-    virtual DispatchResponse stopTrackingHeapObjects(Maybe<bool> in_reportProgress, Maybe<bool> in_treatGlobalObjectsAsRoots, Maybe<bool> in_captureNumericValue) = 0;
-    virtual DispatchResponse takeHeapSnapshot(Maybe<bool> in_reportProgress, Maybe<bool> in_treatGlobalObjectsAsRoots, Maybe<bool> in_captureNumericValue) = 0;
+    virtual DispatchResponse stopTrackingHeapObjects(Maybe<bool> in_reportProgress, Maybe<bool> in_treatGlobalObjectsAsRoots, Maybe<bool> in_captureNumericValue, Maybe<bool> in_exposeInternals) = 0;
+    virtual DispatchResponse takeHeapSnapshot(Maybe<bool> in_reportProgress, Maybe<bool> in_treatGlobalObjectsAsRoots, Maybe<bool> in_captureNumericValue, Maybe<bool> in_exposeInternals) = 0;
 
 };
 
diff --git a/NativeScript/inspector/src/inspector/protocol/Profiler.h b/NativeScript/inspector/src/inspector/protocol/Profiler.h
index 373e335a..a1eef302 100644
--- a/NativeScript/inspector/src/inspector/protocol/Profiler.h
+++ b/NativeScript/inspector/src/inspector/protocol/Profiler.h
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -22,9 +22,6 @@ class PositionTickInfo;
 class CoverageRange;
 class FunctionCoverage;
 class ScriptCoverage;
-class TypeObject;
-class TypeProfileEntry;
-class ScriptTypeProfile;
 
 // ------------- Forward and enum declarations.
 
@@ -567,214 +564,6 @@ class  ScriptCoverage : public ::v8_crdtp::ProtocolObject<ScriptCoverage> {
 };
 
 
-class  TypeObject : public ::v8_crdtp::ProtocolObject<TypeObject> {
-public:
-    ~TypeObject() override { }
-
-    String getName() { return m_name; }
-    void setName(const String& value) { m_name = value; }
-
-    template<int STATE>
-    class TypeObjectBuilder {
-    public:
-        enum {
-            NoFieldsSet = 0,
-            NameSet = 1 << 1,
-            AllFieldsSet = (NameSet | 0)};
-
-
-        TypeObjectBuilder<STATE | NameSet>& setName(const String& value)
-        {
-            static_assert(!(STATE & NameSet), "property name should not be set yet");
-            m_result->setName(value);
-            return castState<NameSet>();
-        }
-
-        std::unique_ptr<TypeObject> build()
-        {
-            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
-            return std::move(m_result);
-        }
-
-    private:
-        friend class TypeObject;
-        TypeObjectBuilder() : m_result(new TypeObject()) { }
-
-        template<int STEP> TypeObjectBuilder<STATE | STEP>& castState()
-        {
-            return *reinterpret_cast<TypeObjectBuilder<STATE | STEP>*>(this);
-        }
-
-        std::unique_ptr<protocol::Profiler::TypeObject> m_result;
-    };
-
-    static TypeObjectBuilder<0> create()
-    {
-        return TypeObjectBuilder<0>();
-    }
-
-private:
-    DECLARE_SERIALIZATION_SUPPORT();
-
-    TypeObject()
-    {
-    }
-
-    String m_name;
-};
-
-
-class  TypeProfileEntry : public ::v8_crdtp::ProtocolObject<TypeProfileEntry> {
-public:
-    ~TypeProfileEntry() override { }
-
-    int getOffset() { return m_offset; }
-    void setOffset(int value) { m_offset = value; }
-
-    protocol::Array<protocol::Profiler::TypeObject>* getTypes() { return m_types.get(); }
-    void setTypes(std::unique_ptr<protocol::Array<protocol::Profiler::TypeObject>> value) { m_types = std::move(value); }
-
-    template<int STATE>
-    class TypeProfileEntryBuilder {
-    public:
-        enum {
-            NoFieldsSet = 0,
-            OffsetSet = 1 << 1,
-            TypesSet = 1 << 2,
-            AllFieldsSet = (OffsetSet | TypesSet | 0)};
-
-
-        TypeProfileEntryBuilder<STATE | OffsetSet>& setOffset(int value)
-        {
-            static_assert(!(STATE & OffsetSet), "property offset should not be set yet");
-            m_result->setOffset(value);
-            return castState<OffsetSet>();
-        }
-
-        TypeProfileEntryBuilder<STATE | TypesSet>& setTypes(std::unique_ptr<protocol::Array<protocol::Profiler::TypeObject>> value)
-        {
-            static_assert(!(STATE & TypesSet), "property types should not be set yet");
-            m_result->setTypes(std::move(value));
-            return castState<TypesSet>();
-        }
-
-        std::unique_ptr<TypeProfileEntry> build()
-        {
-            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
-            return std::move(m_result);
-        }
-
-    private:
-        friend class TypeProfileEntry;
-        TypeProfileEntryBuilder() : m_result(new TypeProfileEntry()) { }
-
-        template<int STEP> TypeProfileEntryBuilder<STATE | STEP>& castState()
-        {
-            return *reinterpret_cast<TypeProfileEntryBuilder<STATE | STEP>*>(this);
-        }
-
-        std::unique_ptr<protocol::Profiler::TypeProfileEntry> m_result;
-    };
-
-    static TypeProfileEntryBuilder<0> create()
-    {
-        return TypeProfileEntryBuilder<0>();
-    }
-
-private:
-    DECLARE_SERIALIZATION_SUPPORT();
-
-    TypeProfileEntry()
-    {
-          m_offset = 0;
-    }
-
-    int m_offset;
-    std::unique_ptr<protocol::Array<protocol::Profiler::TypeObject>> m_types;
-};
-
-
-class  ScriptTypeProfile : public ::v8_crdtp::ProtocolObject<ScriptTypeProfile> {
-public:
-    ~ScriptTypeProfile() override { }
-
-    String getScriptId() { return m_scriptId; }
-    void setScriptId(const String& value) { m_scriptId = value; }
-
-    String getUrl() { return m_url; }
-    void setUrl(const String& value) { m_url = value; }
-
-    protocol::Array<protocol::Profiler::TypeProfileEntry>* getEntries() { return m_entries.get(); }
-    void setEntries(std::unique_ptr<protocol::Array<protocol::Profiler::TypeProfileEntry>> value) { m_entries = std::move(value); }
-
-    template<int STATE>
-    class ScriptTypeProfileBuilder {
-    public:
-        enum {
-            NoFieldsSet = 0,
-            ScriptIdSet = 1 << 1,
-            UrlSet = 1 << 2,
-            EntriesSet = 1 << 3,
-            AllFieldsSet = (ScriptIdSet | UrlSet | EntriesSet | 0)};
-
-
-        ScriptTypeProfileBuilder<STATE | ScriptIdSet>& setScriptId(const String& value)
-        {
-            static_assert(!(STATE & ScriptIdSet), "property scriptId should not be set yet");
-            m_result->setScriptId(value);
-            return castState<ScriptIdSet>();
-        }
-
-        ScriptTypeProfileBuilder<STATE | UrlSet>& setUrl(const String& value)
-        {
-            static_assert(!(STATE & UrlSet), "property url should not be set yet");
-            m_result->setUrl(value);
-            return castState<UrlSet>();
-        }
-
-        ScriptTypeProfileBuilder<STATE | EntriesSet>& setEntries(std::unique_ptr<protocol::Array<protocol::Profiler::TypeProfileEntry>> value)
-        {
-            static_assert(!(STATE & EntriesSet), "property entries should not be set yet");
-            m_result->setEntries(std::move(value));
-            return castState<EntriesSet>();
-        }
-
-        std::unique_ptr<ScriptTypeProfile> build()
-        {
-            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
-            return std::move(m_result);
-        }
-
-    private:
-        friend class ScriptTypeProfile;
-        ScriptTypeProfileBuilder() : m_result(new ScriptTypeProfile()) { }
-
-        template<int STEP> ScriptTypeProfileBuilder<STATE | STEP>& castState()
-        {
-            return *reinterpret_cast<ScriptTypeProfileBuilder<STATE | STEP>*>(this);
-        }
-
-        std::unique_ptr<protocol::Profiler::ScriptTypeProfile> m_result;
-    };
-
-    static ScriptTypeProfileBuilder<0> create()
-    {
-        return ScriptTypeProfileBuilder<0>();
-    }
-
-private:
-    DECLARE_SERIALIZATION_SUPPORT();
-
-    ScriptTypeProfile()
-    {
-    }
-
-    String m_scriptId;
-    String m_url;
-    std::unique_ptr<protocol::Array<protocol::Profiler::TypeProfileEntry>> m_entries;
-};
-
-
 // ------------- Backend interface.
 
 class  Backend {
@@ -787,12 +576,9 @@ class  Backend {
     virtual DispatchResponse setSamplingInterval(int in_interval) = 0;
     virtual DispatchResponse start() = 0;
     virtual DispatchResponse startPreciseCoverage(Maybe<bool> in_callCount, Maybe<bool> in_detailed, Maybe<bool> in_allowTriggeredUpdates, double* out_timestamp) = 0;
-    virtual DispatchResponse startTypeProfile() = 0;
     virtual DispatchResponse stop(std::unique_ptr<protocol::Profiler::Profile>* out_profile) = 0;
     virtual DispatchResponse stopPreciseCoverage() = 0;
-    virtual DispatchResponse stopTypeProfile() = 0;
     virtual DispatchResponse takePreciseCoverage(std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>* out_result, double* out_timestamp) = 0;
-    virtual DispatchResponse takeTypeProfile(std::unique_ptr<protocol::Array<protocol::Profiler::ScriptTypeProfile>>* out_result) = 0;
 
 };
 
diff --git a/NativeScript/inspector/src/inspector/protocol/Protocol.h b/NativeScript/inspector/src/inspector/protocol/Protocol.h
index 12b33414..e4e3784a 100644
--- a/NativeScript/inspector/src/inspector/protocol/Protocol.h
+++ b/NativeScript/inspector/src/inspector/protocol/Protocol.h
@@ -1,6 +1,6 @@
 // This file is generated by Values_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -266,7 +266,7 @@ class  ListValue : public Value {
 
 // This file is generated by Object_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -309,7 +309,7 @@ class  Object : public v8_crdtp::Serializable {
 
 // This file is generated by ValueConversions_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/NativeScript/inspector/src/inspector/protocol/Runtime.h b/NativeScript/inspector/src/inspector/protocol/Runtime.h
index cb55bf65..86efaff6 100644
--- a/NativeScript/inspector/src/inspector/protocol/Runtime.h
+++ b/NativeScript/inspector/src/inspector/protocol/Runtime.h
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -1731,7 +1731,7 @@ class  Backend {
         virtual void fallThrough() = 0;
         virtual ~CallFunctionOnCallback() { }
     };
-    virtual void callFunctionOn(const String& in_functionDeclaration, Maybe<String> in_objectId, Maybe<protocol::Array<protocol::Runtime::CallArgument>> in_arguments, Maybe<bool> in_silent, Maybe<bool> in_returnByValue, Maybe<bool> in_generatePreview, Maybe<bool> in_userGesture, Maybe<bool> in_awaitPromise, Maybe<int> in_executionContextId, Maybe<String> in_objectGroup, Maybe<bool> in_throwOnSideEffect, Maybe<bool> in_generateWebDriverValue, std::unique_ptr<CallFunctionOnCallback> callback) = 0;
+    virtual void callFunctionOn(const String& in_functionDeclaration, Maybe<String> in_objectId, Maybe<protocol::Array<protocol::Runtime::CallArgument>> in_arguments, Maybe<bool> in_silent, Maybe<bool> in_returnByValue, Maybe<bool> in_generatePreview, Maybe<bool> in_userGesture, Maybe<bool> in_awaitPromise, Maybe<int> in_executionContextId, Maybe<String> in_objectGroup, Maybe<bool> in_throwOnSideEffect, Maybe<String> in_uniqueContextId, Maybe<bool> in_generateWebDriverValue, std::unique_ptr<CallFunctionOnCallback> callback) = 0;
     virtual DispatchResponse compileScript(const String& in_expression, const String& in_sourceURL, bool in_persistScript, Maybe<int> in_executionContextId, Maybe<String>* out_scriptId, Maybe<protocol::Runtime::ExceptionDetails>* out_exceptionDetails) = 0;
     virtual DispatchResponse disable() = 0;
     virtual DispatchResponse discardConsoleEntries() = 0;
@@ -1786,7 +1786,7 @@ class  Frontend {
     void exceptionRevoked(const String& reason, int exceptionId);
     void exceptionThrown(double timestamp, std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails);
     void executionContextCreated(std::unique_ptr<protocol::Runtime::ExecutionContextDescription> context);
-    void executionContextDestroyed(int executionContextId);
+    void executionContextDestroyed(int executionContextId, const String& executionContextUniqueId);
     void executionContextsCleared();
     void inspectRequested(std::unique_ptr<protocol::Runtime::RemoteObject> object, std::unique_ptr<protocol::DictionaryValue> hints, Maybe<int> executionContextId = Maybe<int>());
 
diff --git a/NativeScript/inspector/src/inspector/protocol/Schema.h b/NativeScript/inspector/src/inspector/protocol/Schema.h
index 448bf41f..409d4948 100644
--- a/NativeScript/inspector/src/inspector/protocol/Schema.h
+++ b/NativeScript/inspector/src/inspector/protocol/Schema.h
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/NativeScript/inspector/src/inspector/string-16.h b/NativeScript/inspector/src/inspector/string-16.h
index 7dfc5e34..29651ac9 100644
--- a/NativeScript/inspector/src/inspector/string-16.h
+++ b/NativeScript/inspector/src/inspector/string-16.h
@@ -46,6 +46,7 @@ class String16 {
   int64_t toInteger64(bool* ok = nullptr) const;
   uint64_t toUInt64(bool* ok = nullptr) const;
   int toInteger(bool* ok = nullptr) const;
+  std::pair<size_t, size_t> getTrimmedOffsetAndLength() const;
   String16 stripWhiteSpace() const;
   const UChar* characters16() const { return m_impl.c_str(); }
   size_t length() const { return m_impl.length(); }
diff --git a/NativeScript/inspector/src/inspector/string-util.h b/NativeScript/inspector/src/inspector/string-util.h
index 7f427d9b..7de6206a 100644
--- a/NativeScript/inspector/src/inspector/string-util.h
+++ b/NativeScript/inspector/src/inspector/string-util.h
@@ -69,8 +69,8 @@ v8::Local<v8::String> toV8String(v8::Isolate*, const StringView&);
 // TODO(dgozman): rename to toString16.
 String16 toProtocolString(v8::Isolate*, v8::Local<v8::String>);
 String16 toProtocolStringWithTypeCheck(v8::Isolate*, v8::Local<v8::Value>);
-String16 toString16(const StringView&);
-StringView toStringView(const String16&);
+V8_EXPORT_PRIVATE String16 toString16(const StringView&);
+V8_EXPORT_PRIVATE StringView toStringView(const String16&);
 template <size_t N>
 StringView toStringView(const char* str[N]) {
   return StringView(reinterpret_cast<const uint8_t*>(str), N);
diff --git a/NativeScript/inspector/src/inspector/v8-console.h b/NativeScript/inspector/src/inspector/v8-console.h
index c1ed2455..8d2258f7 100644
--- a/NativeScript/inspector/src/inspector/v8-console.h
+++ b/NativeScript/inspector/src/inspector/v8-console.h
@@ -14,12 +14,14 @@
 #include "src/debug/interface-types.h"
 
 namespace v8 {
+class ObjectTemplate;
 class Set;
 }  // namespace v8
 
 namespace v8_inspector {
 
 class InspectedContext;
+class TaskInfo;
 class V8InspectorImpl;
 
 // Console API
@@ -32,6 +34,11 @@ class V8Console : public v8::debug::ConsoleDelegate {
                            v8::Local<v8::Object> console);
   void installAsyncStackTaggingAPI(v8::Local<v8::Context> context,
                                    v8::Local<v8::Object> console);
+  void cancelConsoleTask(TaskInfo* taskInfo);
+
+  std::map<void*, std::unique_ptr<TaskInfo>>& AllConsoleTasksForTest() {
+    return m_tasks;
+  }
 
   class V8_NODISCARD CommandLineAPIScope {
    public:
@@ -56,14 +63,11 @@ class V8Console : public v8::debug::ConsoleDelegate {
     v8::Local<v8::ArrayBuffer> m_thisReference;
   };
 
-  struct AsyncTaskInfo {
-    int* ptr;
-    bool recurring;
-  };
-
   explicit V8Console(V8InspectorImpl* inspector);
 
  private:
+  friend class TaskInfo;
+
   void Debug(const v8::debug::ConsoleCallArguments&,
              const v8::debug::ConsoleContext& consoleContext) override;
   void Error(const v8::debug::ConsoleCallArguments&,
@@ -137,12 +141,8 @@ class V8Console : public v8::debug::ConsoleDelegate {
   void memoryGetterCallback(const v8::FunctionCallbackInfo<v8::Value>&);
   void memorySetterCallback(const v8::FunctionCallbackInfo<v8::Value>&);
 
-  v8::Maybe<int64_t> ValidateAndGetTaskId(
-      const v8::FunctionCallbackInfo<v8::Value>&);
-  void scheduleAsyncTask(const v8::FunctionCallbackInfo<v8::Value>&);
-  void startAsyncTask(const v8::FunctionCallbackInfo<v8::Value>&);
-  void finishAsyncTask(const v8::FunctionCallbackInfo<v8::Value>&);
-  void cancelAsyncTask(const v8::FunctionCallbackInfo<v8::Value>&);
+  void createTask(const v8::FunctionCallbackInfo<v8::Value>&);
+  void runTask(const v8::FunctionCallbackInfo<v8::Value>&);
 
   // CommandLineAPI
   void keysCallback(const v8::FunctionCallbackInfo<v8::Value>&, int sessionId);
@@ -186,15 +186,62 @@ class V8Console : public v8::debug::ConsoleDelegate {
   void queryObjectsCallback(const v8::FunctionCallbackInfo<v8::Value>& info,
                             int sessionId);
 
+  // Lazily creates m_taskInfoKey and returns a local handle to it. We can't
+  // initialize m_taskInfoKey in the constructor as it would be part of
+  // Chromium's context snapshot.
+  v8::Local<v8::Private> taskInfoKey();
+
+  // Lazily creates m_taskTemplate and returns a local handle to it.
+  // Similarly to m_taskInfoKey, we can't create the template upfront as to not
+  // be part of Chromium's context snapshot.
+  v8::Local<v8::ObjectTemplate> taskTemplate();
+
   V8InspectorImpl* m_inspector;
 
-  // A map of unique pointers used for the scheduling and joining async stacks.
-  // The async stack traces instrumentation is exposed on the console object,
-  // behind a --experimental-async-stack-tagging-api flag. For now, it serves
-  // as a prototype that aims to validate whether the debugging experience can
-  // be improved for userland code that uses custom schedulers.
-  int64_t m_taskIdCounter = 0;
-  std::map<int64_t, AsyncTaskInfo> m_asyncTaskIds;
+  // All currently alive tasks. We mark tasks immediately as weak when created
+  // but we need the finalizer to cancel the task when GC cleans them up.
+  std::map<void*, std::unique_ptr<TaskInfo>> m_tasks;
+
+  // We use a private symbol to stash the `TaskInfo` as an v8::External on the
+  // JS task objects created by `console.createTask`.
+  v8::Global<v8::Private> m_taskInfoKey;
+
+  // We cache the task template for the async stack tagging API for faster
+  // instantiation. Use `taskTemplate()` to retrieve the lazily created
+  // template.
+  v8::Global<v8::ObjectTemplate> m_taskTemplate;
+};
+
+/**
+ * Each JS task object created via `console.createTask` has a corresponding
+ * `TaskInfo` object on the C++ side (in a 1:1 relationship).
+ *
+ * The `TaskInfo` holds on weakly to the JS task object.
+ * The JS task objects uses a private symbol to store a pointer to the
+ * `TaskInfo` object (via v8::External).
+ *
+ * The `TaskInfo` objects holds all the necessary information we need to
+ * properly cancel the corresponding async task then the JS task object
+ * gets GC'ed.
+ */
+class TaskInfo {
+ public:
+  TaskInfo(v8::Isolate* isolate, V8Console* console,
+           v8::Local<v8::Object> task);
+
+  // For these task IDs we duplicate the ID logic from blink and use even
+  // pointers compared to the odd IDs we use for promises. This guarantees that
+  // we don't have any conflicts between task IDs.
+  void* Id() const {
+    return reinterpret_cast<void*>(reinterpret_cast<intptr_t>(this) << 1);
+  }
+
+  // After calling `Cancel` the `TaskInfo` instance is destroyed.
+  void Cancel() { m_console->cancelConsoleTask(this); }
+
+ private:
+  v8::Global<v8::Object> m_task;
+  V8Console* m_console = nullptr;
 };
 
 }  // namespace v8_inspector
diff --git a/NativeScript/inspector/src/inspector/v8-debugger-agent-impl.h b/NativeScript/inspector/src/inspector/v8-debugger-agent-impl.h
index 93f43e03..9853312b 100644
--- a/NativeScript/inspector/src/inspector/v8-debugger-agent-impl.h
+++ b/NativeScript/inspector/src/inspector/v8-debugger-agent-impl.h
@@ -19,6 +19,7 @@
 namespace v8_inspector {
 
 struct ScriptBreakpoint;
+class DisassemblyCollectorImpl;
 class V8Debugger;
 class V8DebuggerScript;
 class V8InspectorImpl;
@@ -42,6 +43,7 @@ class V8DebuggerAgentImpl : public protocol::Debugger::Backend {
   V8DebuggerAgentImpl(const V8DebuggerAgentImpl&) = delete;
   V8DebuggerAgentImpl& operator=(const V8DebuggerAgentImpl&) = delete;
   void restore();
+  void stop();
 
   // Part of the protocol.
   Response enable(Maybe<double> maxScriptsCacheSize,
@@ -83,20 +85,31 @@ class V8DebuggerAgentImpl : public protocol::Debugger::Backend {
           locations) override;
   Response setScriptSource(
       const String16& inScriptId, const String16& inScriptSource,
-      Maybe<bool> dryRun,
+      Maybe<bool> dryRun, Maybe<bool> allowTopFrameEditing,
       Maybe<protocol::Array<protocol::Debugger::CallFrame>>* optOutCallFrames,
       Maybe<bool>* optOutStackChanged,
       Maybe<protocol::Runtime::StackTrace>* optOutAsyncStackTrace,
       Maybe<protocol::Runtime::StackTraceId>* optOutAsyncStackTraceId,
+      String16* outStatus,
       Maybe<protocol::Runtime::ExceptionDetails>* optOutCompileError) override;
   Response restartFrame(
-      const String16& callFrameId,
+      const String16& callFrameId, Maybe<String16> mode,
       std::unique_ptr<protocol::Array<protocol::Debugger::CallFrame>>*
           newCallFrames,
       Maybe<protocol::Runtime::StackTrace>* asyncStackTrace,
       Maybe<protocol::Runtime::StackTraceId>* asyncStackTraceId) override;
   Response getScriptSource(const String16& scriptId, String16* scriptSource,
                            Maybe<protocol::Binary>* bytecode) override;
+  Response disassembleWasmModule(
+      const String16& in_scriptId, Maybe<String16>* out_streamId,
+      int* out_totalNumberOfLines,
+      std::unique_ptr<protocol::Array<int>>* out_functionBodyOffsets,
+      std::unique_ptr<protocol::Debugger::WasmDisassemblyChunk>* out_chunk)
+      override;
+  Response nextWasmDisassemblyChunk(
+      const String16& in_streamId,
+      std::unique_ptr<protocol::Debugger::WasmDisassemblyChunk>* out_chunk)
+      override;
   Response getWasmBytecode(const String16& scriptId,
                            protocol::Binary* bytecode) override;
   Response pause() override;
@@ -132,7 +145,7 @@ class V8DebuggerAgentImpl : public protocol::Debugger::Backend {
       std::unique_ptr<protocol::Array<protocol::Debugger::ScriptPosition>>
           positions) override;
 
-  bool enabled() const { return m_enabled; }
+  bool enabled() const { return m_enableState == kEnabled; }
 
   void setBreakpointFor(v8::Local<v8::Function> function,
                         v8::Local<v8::String> condition,
@@ -148,6 +161,7 @@ class V8DebuggerAgentImpl : public protocol::Debugger::Backend {
 
   void reset();
 
+  bool instrumentationFinished() { return m_instrumentationFinished; }
   // Interface for V8InspectorImpl
   void didPauseOnInstrumentation(v8::debug::BreakpointId instrumentationId);
 
@@ -210,19 +224,26 @@ class V8DebuggerAgentImpl : public protocol::Debugger::Backend {
   using DebuggerBreakpointIdToBreakpointIdMap =
       std::unordered_map<v8::debug::BreakpointId, String16>;
 
+  enum EnableState {
+    kDisabled,
+    kEnabled,
+    kStopping,  // This is the same as 'disabled', but it cannot become enabled
+                // again.
+  };
+
   V8InspectorImpl* m_inspector;
   V8Debugger* m_debugger;
   V8InspectorSessionImpl* m_session;
-  bool m_enabled;
+  EnableState m_enableState;
   protocol::DictionaryValue* m_state;
   protocol::Debugger::Frontend m_frontend;
   v8::Isolate* m_isolate;
   ScriptsMap m_scripts;
   BreakpointIdToDebuggerBreakpointIdsMap m_breakpointIdToDebuggerBreakpointIds;
   DebuggerBreakpointIdToBreakpointIdMap m_debuggerBreakpointIdToBreakpointId;
-  std::unordered_map<v8::debug::BreakpointId,
-                     std::unique_ptr<protocol::DictionaryValue>>
-      m_breakpointsOnScriptRun;
+  std::map<String16, std::unique_ptr<DisassemblyCollectorImpl>>
+      m_wasmDisassemblies;
+  size_t m_nextWasmDisassemblyStreamId = 0;
 
   size_t m_maxScriptCacheSize = 0;
   size_t m_cachedScriptSize = 0;
@@ -248,6 +269,7 @@ class V8DebuggerAgentImpl : public protocol::Debugger::Backend {
 
   bool m_skipAllPauses = false;
   bool m_breakpointsActive = false;
+  bool m_instrumentationFinished = true;
 
   std::unique_ptr<V8Regex> m_blackboxPattern;
   std::unordered_map<String16, std::vector<std::pair<int, int>>>
diff --git a/NativeScript/inspector/src/inspector/v8-debugger-barrier.h b/NativeScript/inspector/src/inspector/v8-debugger-barrier.h
new file mode 100644
index 00000000..f4dc2961
--- /dev/null
+++ b/NativeScript/inspector/src/inspector/v8-debugger-barrier.h
@@ -0,0 +1,28 @@
+// 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.
+
+#ifndef V8_INSPECTOR_V8_DEBUGGER_BARRIER_H_
+#define V8_INSPECTOR_V8_DEBUGGER_BARRIER_H_
+
+namespace v8_inspector {
+
+class V8InspectorClient;
+
+// This class is used to synchronize multiple sessions issuing
+// `Runtime.runIfWaitingForDebbuger` so that the global client
+// `runIfWaitingForDebugger` method is only invoked when all
+// sessions have invoked `Runtime.runIfWaitingForDebugger`.
+class V8DebuggerBarrier {
+ public:
+  V8DebuggerBarrier(V8InspectorClient* client, int contextGroupId);
+  ~V8DebuggerBarrier();
+
+ private:
+  V8InspectorClient* const m_client;
+  int m_contextGroupId;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_DEBUGGER_BARRIER_H_
diff --git a/NativeScript/inspector/src/inspector/v8-debugger-script.h b/NativeScript/inspector/src/inspector/v8-debugger-script.h
index eb80a14c..80b900c9 100644
--- a/NativeScript/inspector/src/inspector/v8-debugger-script.h
+++ b/NativeScript/inspector/src/inspector/v8-debugger-script.h
@@ -82,6 +82,7 @@ class V8DebuggerScript {
   void setSourceURL(const String16&);
   virtual void setSourceMappingURL(const String16&) = 0;
   virtual void setSource(const String16& source, bool preview,
+                         bool allowTopFrameLiveEditing,
                          v8::debug::LiveEditResult* result) = 0;
 
   virtual bool getPossibleBreakpoints(
@@ -90,8 +91,7 @@ class V8DebuggerScript {
       std::vector<v8::debug::BreakLocation>* locations) = 0;
   virtual void resetBlackboxedStateCache() = 0;
 
-  static const int kNoOffset = -1;
-  virtual int offset(int lineNumber, int columnNumber) const = 0;
+  virtual v8::Maybe<int> offset(int lineNumber, int columnNumber) const = 0;
   virtual v8::debug::Location location(int offset) const = 0;
 
   virtual bool setBreakpoint(const String16& condition,
@@ -105,6 +105,8 @@ class V8DebuggerScript {
   getDebugSymbolsType() const = 0;
   virtual v8::Maybe<String16> getExternalDebugSymbolsURL() const = 0;
   void removeWasmBreakpoint(int id);
+  virtual void Disassemble(v8::debug::DisassemblyCollector* collector,
+                           std::vector<int>* function_body_offsets) const = 0;
 #endif  // V8_ENABLE_WEBASSEMBLY
 
  protected:
diff --git a/NativeScript/inspector/src/inspector/v8-debugger.h b/NativeScript/inspector/src/inspector/v8-debugger.h
index 638df796..7ec698d3 100644
--- a/NativeScript/inspector/src/inspector/v8-debugger.h
+++ b/NativeScript/inspector/src/inspector/v8-debugger.h
@@ -58,8 +58,10 @@ class V8Debugger : public v8::debug::DebugDelegate,
   v8::debug::ExceptionBreakState getPauseOnExceptionsState();
   void setPauseOnExceptionsState(v8::debug::ExceptionBreakState);
   bool canBreakProgram();
+  bool isInInstrumentationPause() const;
   void breakProgram(int targetContextGroupId);
   void interruptAndBreak(int targetContextGroupId);
+  void requestPauseAfterInstrumentation();
   void continueProgram(int targetContextGroupId,
                        bool terminateOnResume = false);
   void breakProgramOnAssert(int targetContextGroupId);
@@ -69,12 +71,14 @@ class V8Debugger : public v8::debug::DebugDelegate,
   void stepOverStatement(int targetContextGroupId);
   void stepOutOfFunction(int targetContextGroupId);
 
-  void terminateExecution(std::unique_ptr<TerminateExecutionCallback> callback);
+  void terminateExecution(v8::Local<v8::Context> context,
+                          std::unique_ptr<TerminateExecutionCallback> callback);
 
   Response continueToLocation(int targetContextGroupId,
                               V8DebuggerScript* script,
                               std::unique_ptr<protocol::Debugger::Location>,
                               const String16& targetCallFramess);
+  bool restartFrame(int targetContextGroupId, int callFrameOrdinal);
 
   // Each script inherits debug data from v8::Context where it has been
   // compiled.
@@ -190,8 +194,8 @@ class V8Debugger : public v8::debug::DebugDelegate,
       v8::Local<v8::Context> paused_context,
       const std::vector<v8::debug::BreakpointId>& break_points_hit,
       v8::debug::BreakReasons break_reasons) override;
-  void BreakOnInstrumentation(v8::Local<v8::Context> paused_context,
-                              v8::debug::BreakpointId) override;
+  ActionAfterInstrumentation BreakOnInstrumentation(
+      v8::Local<v8::Context> paused_context, v8::debug::BreakpointId) override;
   void ExceptionThrown(v8::Local<v8::Context> paused_context,
                        v8::Local<v8::Value> exception,
                        v8::Local<v8::Value> promise, bool is_uncaught,
@@ -207,6 +211,8 @@ class V8Debugger : public v8::debug::DebugDelegate,
 
   bool hasScheduledBreakOnNextFunctionCall() const;
 
+  void quitMessageLoopIfAgentsFinishedInstrumentation();
+
   v8::Isolate* m_isolate;
   V8InspectorImpl* m_inspector;
   int m_enableCount;
@@ -217,6 +223,8 @@ class V8Debugger : public v8::debug::DebugDelegate,
   bool m_scheduledOOMBreak = false;
   int m_targetContextGroupId = 0;
   int m_pausedContextGroupId = 0;
+  bool m_instrumentationPause = false;
+  bool m_requestedPauseAfterInstrumentation = false;
   int m_continueToLocationBreakpointId;
   String16 m_continueToLocationTargetCallFrames;
   std::unique_ptr<V8StackTraceImpl> m_continueToLocationStack;
@@ -292,6 +300,7 @@ class V8Debugger : public v8::debug::DebugDelegate,
   std::unordered_map<int, internal::V8DebuggerId> m_contextGroupIdToDebuggerId;
 
   std::unique_ptr<TerminateExecutionCallback> m_terminateExecutionCallback;
+  v8::Global<v8::Context> m_terminateExecutionCallbackContext;
 };
 
 }  // namespace v8_inspector
diff --git a/NativeScript/inspector/src/inspector/v8-heap-profiler-agent-impl.h b/NativeScript/inspector/src/inspector/v8-heap-profiler-agent-impl.h
index cd92bd32..61c6b6af 100644
--- a/NativeScript/inspector/src/inspector/v8-heap-profiler-agent-impl.h
+++ b/NativeScript/inspector/src/inspector/v8-heap-profiler-agent-impl.h
@@ -38,13 +38,15 @@ class V8HeapProfilerAgentImpl : public protocol::HeapProfiler::Backend {
   Response startTrackingHeapObjects(Maybe<bool> trackAllocations) override;
   Response stopTrackingHeapObjects(Maybe<bool> reportProgress,
                                    Maybe<bool> treatGlobalObjectsAsRoots,
-                                   Maybe<bool> captureNumericValue) override;
+                                   Maybe<bool> captureNumericValue,
+                                   Maybe<bool> exposeInternals) override;
 
   Response disable() override;
 
   Response takeHeapSnapshot(Maybe<bool> reportProgress,
                             Maybe<bool> treatGlobalObjectsAsRoots,
-                            Maybe<bool> captureNumericValue) override;
+                            Maybe<bool> captureNumericValue,
+                            Maybe<bool> exposeInternals) override;
 
   Response getObjectByHeapObjectId(
       const String16& heapSnapshotObjectId, Maybe<String16> objectGroup,
@@ -54,7 +56,9 @@ class V8HeapProfilerAgentImpl : public protocol::HeapProfiler::Backend {
   Response getHeapObjectId(const String16& objectId,
                            String16* heapSnapshotObjectId) override;
 
-  Response startSampling(Maybe<double> samplingInterval) override;
+  Response startSampling(Maybe<double> samplingInterval,
+                         Maybe<bool> includeObjectsCollectedByMajorGC,
+                         Maybe<bool> includeObjectsCollectedByMinorGC) override;
   Response stopSampling(
       std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>*) override;
   Response getSamplingProfile(
diff --git a/NativeScript/inspector/src/inspector/v8-inspector-impl.h b/NativeScript/inspector/src/inspector/v8-inspector-impl.h
index 4a3e9bf2..0d30cc59 100644
--- a/NativeScript/inspector/src/inspector/v8-inspector-impl.h
+++ b/NativeScript/inspector/src/inspector/v8-inspector-impl.h
@@ -49,6 +49,7 @@ class V8Console;
 class V8ConsoleMessageStorage;
 class V8Debugger;
 class V8DebuggerAgentImpl;
+class V8DebuggerBarrier;
 class V8InspectorSessionImpl;
 class V8ProfilerAgentImpl;
 class V8RuntimeAgentImpl;
@@ -80,7 +81,9 @@ class V8InspectorImpl : public V8Inspector {
   // V8Inspector implementation.
   std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
                                               V8Inspector::Channel*,
-                                              StringView state) override;
+                                              StringView state,
+                                              ClientTrustLevel,
+                                              SessionPauseState) override;
   void contextCreated(const V8ContextInfo&) override;
   void contextDestroyed(v8::Local<v8::Context>) override;
   v8::MaybeLocal<v8::Context> contextById(int contextId) override;
@@ -125,7 +128,7 @@ class V8InspectorImpl : public V8Inspector {
   V8InspectorSessionImpl* sessionById(int contextGroupId, int sessionId);
   InspectedContext* getContext(int groupId, int contextId) const;
   InspectedContext* getContext(int contextId) const;
-  V8Console* console();
+  V8_EXPORT_PRIVATE V8Console* console();
   void forEachContext(int contextGroupId,
                       const std::function<void(InspectedContext*)>& callback);
   void forEachSession(
@@ -177,6 +180,8 @@ class V8InspectorImpl : public V8Inspector {
 
   // contextGroupId -> sessionId -> session
   std::unordered_map<int, std::map<int, V8InspectorSessionImpl*>> m_sessions;
+  // contextGroupId -> debugger barrier
+  std::unordered_map<int, std::weak_ptr<V8DebuggerBarrier>> m_debuggerBarriers;
 
   using ConsoleStorageMap =
       std::unordered_map<int, std::unique_ptr<V8ConsoleMessageStorage>>;
diff --git a/NativeScript/inspector/src/inspector/v8-inspector-session-impl.h b/NativeScript/inspector/src/inspector/v8-inspector-session-impl.h
index 5d874264..9e443161 100644
--- a/NativeScript/inspector/src/inspector/v8-inspector-session-impl.h
+++ b/NativeScript/inspector/src/inspector/v8-inspector-session-impl.h
@@ -21,6 +21,7 @@ class InjectedScript;
 class RemoteObjectIdBase;
 class V8ConsoleAgentImpl;
 class V8DebuggerAgentImpl;
+class V8DebuggerBarrier;
 class V8InspectorImpl;
 class V8HeapProfilerAgentImpl;
 class V8ProfilerAgentImpl;
@@ -32,11 +33,11 @@ using protocol::Response;
 class V8InspectorSessionImpl : public V8InspectorSession,
                                public protocol::FrontendChannel {
  public:
-  static std::unique_ptr<V8InspectorSessionImpl> create(V8InspectorImpl*,
-                                                        int contextGroupId,
-                                                        int sessionId,
-                                                        V8Inspector::Channel*,
-                                                        StringView state);
+  static std::unique_ptr<V8InspectorSessionImpl> create(
+      V8InspectorImpl*, int contextGroupId, int sessionId,
+      V8Inspector::Channel*, StringView state,
+      v8_inspector::V8Inspector::ClientTrustLevel,
+      std::shared_ptr<V8DebuggerBarrier>);
   ~V8InspectorSessionImpl() override;
   V8InspectorSessionImpl(const V8InspectorSessionImpl&) = delete;
   V8InspectorSessionImpl& operator=(const V8InspectorSessionImpl&) = delete;
@@ -99,10 +100,17 @@ class V8InspectorSessionImpl : public V8InspectorSession,
   static const unsigned kInspectedObjectBufferSize = 5;
 
   void triggerPreciseCoverageDeltaUpdate(StringView occasion) override;
+  void stop() override;
+
+  V8Inspector::ClientTrustLevel clientTrustLevel() {
+    return m_clientTrustLevel;
+  }
 
  private:
   V8InspectorSessionImpl(V8InspectorImpl*, int contextGroupId, int sessionId,
-                         V8Inspector::Channel*, StringView state);
+                         V8Inspector::Channel*, StringView state,
+                         V8Inspector::ClientTrustLevel,
+                         std::shared_ptr<V8DebuggerBarrier>);
   protocol::DictionaryValue* agentState(const String16& name);
 
   // protocol::FrontendChannel implementation.
@@ -134,6 +142,7 @@ class V8InspectorSessionImpl : public V8InspectorSession,
   std::vector<std::unique_ptr<V8InspectorSession::Inspectable>>
       m_inspectedObjects;
   bool use_binary_protocol_ = false;
+  V8Inspector::ClientTrustLevel m_clientTrustLevel = V8Inspector::kUntrusted;
 };
 
 }  // namespace v8_inspector
diff --git a/NativeScript/inspector/src/inspector/v8-profiler-agent-impl.h b/NativeScript/inspector/src/inspector/v8-profiler-agent-impl.h
index 4fba6e6c..6e76ff57 100644
--- a/NativeScript/inspector/src/inspector/v8-profiler-agent-impl.h
+++ b/NativeScript/inspector/src/inspector/v8-profiler-agent-impl.h
@@ -53,12 +53,6 @@ class V8ProfilerAgentImpl : public protocol::Profiler::Backend {
       std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>*
           out_result) override;
 
-  Response startTypeProfile() override;
-  Response stopTypeProfile() override;
-  Response takeTypeProfile(
-      std::unique_ptr<protocol::Array<protocol::Profiler::ScriptTypeProfile>>*
-          out_result) override;
-
   void consoleProfile(const String16& title);
   void consoleProfileEnd(const String16& title);
 
diff --git a/NativeScript/inspector/src/inspector/v8-runtime-agent-impl.h b/NativeScript/inspector/src/inspector/v8-runtime-agent-impl.h
index 43b5ea00..4bb0e871 100644
--- a/NativeScript/inspector/src/inspector/v8-runtime-agent-impl.h
+++ b/NativeScript/inspector/src/inspector/v8-runtime-agent-impl.h
@@ -49,6 +49,7 @@ class InjectedScript;
 class InspectedContext;
 class RemoteObjectIdBase;
 class V8ConsoleMessage;
+class V8DebuggerBarrier;
 class V8InspectorImpl;
 class V8InspectorSessionImpl;
 
@@ -58,7 +59,8 @@ using protocol::Maybe;
 class V8RuntimeAgentImpl : public protocol::Runtime::Backend {
  public:
   V8RuntimeAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*,
-                     protocol::DictionaryValue* state);
+                     protocol::DictionaryValue* state,
+                     std::shared_ptr<V8DebuggerBarrier>);
   ~V8RuntimeAgentImpl() override;
   V8RuntimeAgentImpl(const V8RuntimeAgentImpl&) = delete;
   V8RuntimeAgentImpl& operator=(const V8RuntimeAgentImpl&) = delete;
@@ -87,7 +89,7 @@ class V8RuntimeAgentImpl : public protocol::Runtime::Backend {
       Maybe<bool> generatePreview, Maybe<bool> userGesture,
       Maybe<bool> awaitPromise, Maybe<int> executionContextId,
       Maybe<String16> objectGroup, Maybe<bool> throwOnSideEffect,
-      Maybe<bool> generateWebDriverValue,
+      Maybe<String16> uniqueContextId, Maybe<bool> generateWebDriverValue,
       std::unique_ptr<CallFunctionOnCallback>) override;
   Response releaseObject(const String16& objectId) override;
   Response getProperties(
@@ -155,6 +157,7 @@ class V8RuntimeAgentImpl : public protocol::Runtime::Backend {
   protocol::DictionaryValue* m_state;
   protocol::Runtime::Frontend m_frontend;
   V8InspectorImpl* m_inspector;
+  std::shared_ptr<V8DebuggerBarrier> m_debuggerBarrier;
   bool m_enabled;
   std::unordered_map<String16, std::unique_ptr<v8::Global<v8::Script>>>
       m_compiledScripts;
diff --git a/NativeScript/inspector/src/inspector/v8-stack-trace-impl.h b/NativeScript/inspector/src/inspector/v8-stack-trace-impl.h
index 221700a1..bf793b0b 100644
--- a/NativeScript/inspector/src/inspector/v8-stack-trace-impl.h
+++ b/NativeScript/inspector/src/inspector/v8-stack-trace-impl.h
@@ -84,6 +84,8 @@ class V8StackTraceImpl : public V8StackTrace {
 
   bool isEqualIgnoringTopFrame(V8StackTraceImpl* stackTrace) const;
 
+  std::vector<V8StackFrame> frames() const override;
+
  private:
   V8StackTraceImpl(std::vector<std::shared_ptr<StackFrame>> frames,
                    int maxAsyncDepth,
diff --git a/NativeScript/inspector/src/inspector/v8-string-conversions.h b/NativeScript/inspector/src/inspector/v8-string-conversions.h
index c1d69c18..eb33c681 100644
--- a/NativeScript/inspector/src/inspector/v8-string-conversions.h
+++ b/NativeScript/inspector/src/inspector/v8-string-conversions.h
@@ -5,6 +5,7 @@
 #ifndef V8_INSPECTOR_V8_STRING_CONVERSIONS_H_
 #define V8_INSPECTOR_V8_STRING_CONVERSIONS_H_
 
+#include <cstdint>
 #include <string>
 
 // Conversion routines between UT8 and UTF16, used by string-16.{h,cc}. You may
diff --git a/NativeScript/inspector/src/inspector/v8-webdriver-serializer.h b/NativeScript/inspector/src/inspector/v8-webdriver-serializer.h
index 02443bed..1a9c2396 100644
--- a/NativeScript/inspector/src/inspector/v8-webdriver-serializer.h
+++ b/NativeScript/inspector/src/inspector/v8-webdriver-serializer.h
@@ -15,10 +15,9 @@
 namespace v8_inspector {
 class V8WebDriverSerializer {
  public:
-  static protocol::Response serializeV8Value(
+  static std::unique_ptr<protocol::Runtime::WebDriverValue> serializeV8Value(
       v8::Local<v8::Object> value, v8::Local<v8::Context> context,
-      int max_depth,
-      std::unique_ptr<protocol::Runtime::WebDriverValue>* result);
+      int max_depth);
 };
 }  // namespace v8_inspector
 
diff --git a/NativeScript/inspector/src/inspector/value-mirror.h b/NativeScript/inspector/src/inspector/value-mirror.h
index dc643748..71555680 100644
--- a/NativeScript/inspector/src/inspector/value-mirror.h
+++ b/NativeScript/inspector/src/inspector/value-mirror.h
@@ -66,9 +66,8 @@ class ValueMirror {
       v8::Local<v8::Context> context, int* nameLimit, int* indexLimit,
       std::unique_ptr<protocol::Runtime::ObjectPreview>*) const {}
   virtual v8::Local<v8::Value> v8Value() const = 0;
-  virtual protocol::Response buildWebDriverValue(
-      v8::Local<v8::Context> context, int max_depth,
-      std::unique_ptr<protocol::Runtime::WebDriverValue>* result) const = 0;
+  virtual std::unique_ptr<protocol::Runtime::WebDriverValue>
+  buildWebDriverValue(v8::Local<v8::Context> context, int max_depth) const = 0;
 
   class PropertyAccumulator {
    public:
diff --git a/NativeScript/inspector/utils.mm b/NativeScript/inspector/utils.mm
index dd7158de..4a2e9184 100644
--- a/NativeScript/inspector/utils.mm
+++ b/NativeScript/inspector/utils.mm
@@ -33,6 +33,8 @@
     return result;
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
 std::string v8_inspector::ToStdString(const StringView& value) {
     std::vector<uint16_t> buffer(value.length());
     for (size_t i = 0; i < value.length(); i++) {
@@ -52,6 +54,7 @@
 
     return result;
 }
+#pragma clang diagnostic pop
 
 Local<v8::Function> v8_inspector::GetDebuggerFunction(Local<Context> context, std::string domain, std::string functionName, Local<Object>& domainDebugger) {
     auto it = JsV8InspectorClient::Domains.find(domain);
diff --git a/NativeScript/lib/arm64-iphoneos/libcppgc_base.a b/NativeScript/lib/arm64-iphoneos/libcppgc_base.a
index cb3e6489..05439f2c 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libcppgc_base.a and b/NativeScript/lib/arm64-iphoneos/libcppgc_base.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libcrdtp.a b/NativeScript/lib/arm64-iphoneos/libcrdtp.a
index cf5e6da1..9b3da04f 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libcrdtp.a and b/NativeScript/lib/arm64-iphoneos/libcrdtp.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libcrdtp_platform.a b/NativeScript/lib/arm64-iphoneos/libcrdtp_platform.a
index ffa03cb2..6c8fc319 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libcrdtp_platform.a and b/NativeScript/lib/arm64-iphoneos/libcrdtp_platform.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libinspector.a b/NativeScript/lib/arm64-iphoneos/libinspector.a
index 12620a4d..7413285e 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libinspector.a and b/NativeScript/lib/arm64-iphoneos/libinspector.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libinspector_string_conversions.a b/NativeScript/lib/arm64-iphoneos/libinspector_string_conversions.a
index 0dc5c7dd..b5ccbc6a 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libinspector_string_conversions.a and b/NativeScript/lib/arm64-iphoneos/libinspector_string_conversions.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libtorque_generated_definitions.a b/NativeScript/lib/arm64-iphoneos/libtorque_generated_definitions.a
index c4cf4c5b..0e00ada8 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libtorque_generated_definitions.a and b/NativeScript/lib/arm64-iphoneos/libtorque_generated_definitions.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libtorque_generated_initializers.a b/NativeScript/lib/arm64-iphoneos/libtorque_generated_initializers.a
index 378cd547..5c3e42ad 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libtorque_generated_initializers.a and b/NativeScript/lib/arm64-iphoneos/libtorque_generated_initializers.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libv8_base_without_compiler.a b/NativeScript/lib/arm64-iphoneos/libv8_base_without_compiler.a
index 8c1828f1..268f4a83 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libv8_base_without_compiler.a and b/NativeScript/lib/arm64-iphoneos/libv8_base_without_compiler.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libv8_bigint.a b/NativeScript/lib/arm64-iphoneos/libv8_bigint.a
index 98f281f6..62e92a8f 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libv8_bigint.a and b/NativeScript/lib/arm64-iphoneos/libv8_bigint.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libv8_compiler.a b/NativeScript/lib/arm64-iphoneos/libv8_compiler.a
index 44c7b5fb..6370b444 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libv8_compiler.a and b/NativeScript/lib/arm64-iphoneos/libv8_compiler.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libv8_heap_base.a b/NativeScript/lib/arm64-iphoneos/libv8_heap_base.a
index 59b1a6a5..0d01d6e2 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libv8_heap_base.a and b/NativeScript/lib/arm64-iphoneos/libv8_heap_base.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libv8_libbase.a b/NativeScript/lib/arm64-iphoneos/libv8_libbase.a
index a208611c..cda6f1a6 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libv8_libbase.a and b/NativeScript/lib/arm64-iphoneos/libv8_libbase.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libv8_libplatform.a b/NativeScript/lib/arm64-iphoneos/libv8_libplatform.a
index 815480a3..04000b18 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libv8_libplatform.a and b/NativeScript/lib/arm64-iphoneos/libv8_libplatform.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libv8_snapshot.a b/NativeScript/lib/arm64-iphoneos/libv8_snapshot.a
index 030583c0..8efd4323 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libv8_snapshot.a and b/NativeScript/lib/arm64-iphoneos/libv8_snapshot.a differ
diff --git a/NativeScript/lib/arm64-iphoneos/libzip.a b/NativeScript/lib/arm64-iphoneos/libzip.a
index 37ba95fe..fa50e787 100644
Binary files a/NativeScript/lib/arm64-iphoneos/libzip.a and b/NativeScript/lib/arm64-iphoneos/libzip.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libcppgc_base.a b/NativeScript/lib/arm64-iphonesimulator/libcppgc_base.a
index 2fbd5303..8f4e8739 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libcppgc_base.a and b/NativeScript/lib/arm64-iphonesimulator/libcppgc_base.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libcrdtp.a b/NativeScript/lib/arm64-iphonesimulator/libcrdtp.a
index f1f65a60..8bdce9aa 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libcrdtp.a and b/NativeScript/lib/arm64-iphonesimulator/libcrdtp.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libcrdtp_platform.a b/NativeScript/lib/arm64-iphonesimulator/libcrdtp_platform.a
index d87484b8..641cb06b 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libcrdtp_platform.a and b/NativeScript/lib/arm64-iphonesimulator/libcrdtp_platform.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libinspector.a b/NativeScript/lib/arm64-iphonesimulator/libinspector.a
index ca0ff003..b8e22065 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libinspector.a and b/NativeScript/lib/arm64-iphonesimulator/libinspector.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libinspector_string_conversions.a b/NativeScript/lib/arm64-iphonesimulator/libinspector_string_conversions.a
index 1628db2f..6dc746a2 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libinspector_string_conversions.a and b/NativeScript/lib/arm64-iphonesimulator/libinspector_string_conversions.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_definitions.a b/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_definitions.a
index 5996ade8..267003ae 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_definitions.a and b/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_definitions.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_initializers.a b/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_initializers.a
index 4bb03996..38c350d9 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_initializers.a and b/NativeScript/lib/arm64-iphonesimulator/libtorque_generated_initializers.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libv8_base_without_compiler.a b/NativeScript/lib/arm64-iphonesimulator/libv8_base_without_compiler.a
index eea4569f..daa751a8 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libv8_base_without_compiler.a and b/NativeScript/lib/arm64-iphonesimulator/libv8_base_without_compiler.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libv8_bigint.a b/NativeScript/lib/arm64-iphonesimulator/libv8_bigint.a
index 3854a0f3..8b8c82f5 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libv8_bigint.a and b/NativeScript/lib/arm64-iphonesimulator/libv8_bigint.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libv8_compiler.a b/NativeScript/lib/arm64-iphonesimulator/libv8_compiler.a
index 2a07e951..c6a2ff1a 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libv8_compiler.a and b/NativeScript/lib/arm64-iphonesimulator/libv8_compiler.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libv8_heap_base.a b/NativeScript/lib/arm64-iphonesimulator/libv8_heap_base.a
index 3f2e9a35..3c5809b6 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libv8_heap_base.a and b/NativeScript/lib/arm64-iphonesimulator/libv8_heap_base.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libv8_libbase.a b/NativeScript/lib/arm64-iphonesimulator/libv8_libbase.a
index ef8df6a2..184e2629 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libv8_libbase.a and b/NativeScript/lib/arm64-iphonesimulator/libv8_libbase.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libv8_libplatform.a b/NativeScript/lib/arm64-iphonesimulator/libv8_libplatform.a
index 9fcbf4bf..aac29b49 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libv8_libplatform.a and b/NativeScript/lib/arm64-iphonesimulator/libv8_libplatform.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libv8_snapshot.a b/NativeScript/lib/arm64-iphonesimulator/libv8_snapshot.a
index 47ccc3cc..8822f12c 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libv8_snapshot.a and b/NativeScript/lib/arm64-iphonesimulator/libv8_snapshot.a differ
diff --git a/NativeScript/lib/arm64-iphonesimulator/libzip.a b/NativeScript/lib/arm64-iphonesimulator/libzip.a
index b5660107..c40acc6d 100644
Binary files a/NativeScript/lib/arm64-iphonesimulator/libzip.a and b/NativeScript/lib/arm64-iphonesimulator/libzip.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libcppgc_base.a b/NativeScript/lib/x86_64-iphonesimulator/libcppgc_base.a
index d7425db3..f2707396 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libcppgc_base.a and b/NativeScript/lib/x86_64-iphonesimulator/libcppgc_base.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libcrdtp.a b/NativeScript/lib/x86_64-iphonesimulator/libcrdtp.a
index b24bdd74..147fcaba 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libcrdtp.a and b/NativeScript/lib/x86_64-iphonesimulator/libcrdtp.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libcrdtp_platform.a b/NativeScript/lib/x86_64-iphonesimulator/libcrdtp_platform.a
index 493f345d..3d02a033 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libcrdtp_platform.a and b/NativeScript/lib/x86_64-iphonesimulator/libcrdtp_platform.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libinspector.a b/NativeScript/lib/x86_64-iphonesimulator/libinspector.a
index e2962000..1ee28453 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libinspector.a and b/NativeScript/lib/x86_64-iphonesimulator/libinspector.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libinspector_string_conversions.a b/NativeScript/lib/x86_64-iphonesimulator/libinspector_string_conversions.a
index 507eaf4d..91dcc4cc 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libinspector_string_conversions.a and b/NativeScript/lib/x86_64-iphonesimulator/libinspector_string_conversions.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_definitions.a b/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_definitions.a
index 4ea1b4fa..a61cdecd 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_definitions.a and b/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_definitions.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_initializers.a b/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_initializers.a
index aaf919b5..085449df 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_initializers.a and b/NativeScript/lib/x86_64-iphonesimulator/libtorque_generated_initializers.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libv8_base_without_compiler.a b/NativeScript/lib/x86_64-iphonesimulator/libv8_base_without_compiler.a
index 66c2f10d..48a99af8 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libv8_base_without_compiler.a and b/NativeScript/lib/x86_64-iphonesimulator/libv8_base_without_compiler.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libv8_bigint.a b/NativeScript/lib/x86_64-iphonesimulator/libv8_bigint.a
index 50018524..71bc9697 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libv8_bigint.a and b/NativeScript/lib/x86_64-iphonesimulator/libv8_bigint.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libv8_compiler.a b/NativeScript/lib/x86_64-iphonesimulator/libv8_compiler.a
index 53f96fb5..c85d5190 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libv8_compiler.a and b/NativeScript/lib/x86_64-iphonesimulator/libv8_compiler.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libv8_heap_base.a b/NativeScript/lib/x86_64-iphonesimulator/libv8_heap_base.a
index 42401312..de724b1d 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libv8_heap_base.a and b/NativeScript/lib/x86_64-iphonesimulator/libv8_heap_base.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libv8_libbase.a b/NativeScript/lib/x86_64-iphonesimulator/libv8_libbase.a
index ebe1efa9..0c87c4a7 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libv8_libbase.a and b/NativeScript/lib/x86_64-iphonesimulator/libv8_libbase.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libv8_libplatform.a b/NativeScript/lib/x86_64-iphonesimulator/libv8_libplatform.a
index 62b3d8a1..6a908d04 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libv8_libplatform.a and b/NativeScript/lib/x86_64-iphonesimulator/libv8_libplatform.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libv8_snapshot.a b/NativeScript/lib/x86_64-iphonesimulator/libv8_snapshot.a
index e5f58b63..25268e1c 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libv8_snapshot.a and b/NativeScript/lib/x86_64-iphonesimulator/libv8_snapshot.a differ
diff --git a/NativeScript/lib/x86_64-iphonesimulator/libzip.a b/NativeScript/lib/x86_64-iphonesimulator/libzip.a
index 9ba6a1eb..9f1bf7b3 100644
Binary files a/NativeScript/lib/x86_64-iphonesimulator/libzip.a and b/NativeScript/lib/x86_64-iphonesimulator/libzip.a differ
diff --git a/NativeScript/runtime/ArgConverter.mm b/NativeScript/runtime/ArgConverter.mm
index 06eb7af6..8bb0ddef 100644
--- a/NativeScript/runtime/ArgConverter.mm
+++ b/NativeScript/runtime/ArgConverter.mm
@@ -140,7 +140,7 @@
         if (it != cache->Instances.end()) {
             thiz = it->second->Get(data->isolateWrapper_.Isolate()).As<Object>();
         } else {
-            ObjCDataWrapper* wrapper = new ObjCDataWrapper(self_);
+            ObjCDataWrapper* wrapper = MakeGarbageCollected<ObjCDataWrapper>(isolate, self_);
             thiz = ArgConverter::CreateJsWrapper(context, wrapper, Local<Object>(), true).As<Object>();
             tns::DeleteWrapperIfUnused(isolate, thiz, wrapper);
         }
@@ -339,7 +339,7 @@
         Local<Value> obj = it->second->Get(isolate);
         info.GetReturnValue().Set(obj);
     } else {
-        ObjCDataWrapper* wrapper = new ObjCDataWrapper(result);
+        ObjCDataWrapper* wrapper = MakeGarbageCollected<ObjCDataWrapper>(isolate, result);
         Local<Object> thiz = info.This();
         Local<Context> context = cache->GetContext();
         tns::SetValue(isolate, thiz, wrapper);
@@ -656,7 +656,7 @@
     Class metaClass = object_getClass(target);
     if (class_isMetaClass(metaClass)) {
         if (tns::GetValue(isolate, receiver) == nullptr) {
-            ObjCClassWrapper* wrapper = new ObjCClassWrapper(klass);
+            ObjCClassWrapper* wrapper = MakeGarbageCollected<ObjCClassWrapper>(isolate, klass);
             tns::SetValue(isolate, receiver, wrapper);
         }
     }
@@ -868,7 +868,7 @@
     }
 
     Local<Context> context = isolate->GetCurrentContext();
-    auto newWrapper = new ObjCDataWrapper(obj);
+    auto newWrapper = MakeGarbageCollected<ObjCDataWrapper>(isolate, obj);
     Local<Value> result = ArgConverter::ConvertArgument(context, newWrapper);
     tns::DeleteWrapperIfUnused(isolate, result, newWrapper);
     args.GetReturnValue().Set(result);
diff --git a/NativeScript/runtime/ArrayAdapter.mm b/NativeScript/runtime/ArrayAdapter.mm
index 546bea12..bd740eba 100644
--- a/NativeScript/runtime/ArrayAdapter.mm
+++ b/NativeScript/runtime/ArrayAdapter.mm
@@ -19,7 +19,7 @@ - (instancetype)initWithJSObject:(Local<Object>)jsObject isolate:(Isolate*)isola
         self->cache_ = Caches::Get(isolate);
         self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
         self->cache_->Instances.emplace(self, self->object_);
-        tns::SetValue(isolate, jsObject, new ObjCDataWrapper(self));
+        tns::SetValue(isolate, jsObject, MakeGarbageCollected<ObjCDataWrapper>(isolate, self));
     }
 
     return self;
diff --git a/NativeScript/runtime/Caches.cpp b/NativeScript/runtime/Caches.cpp
index 9810625f..cb36617e 100644
--- a/NativeScript/runtime/Caches.cpp
+++ b/NativeScript/runtime/Caches.cpp
@@ -1,5 +1,6 @@
 #include "Caches.h"
 #include "Constants.h"
+#include "DataWrapper.h"
 
 using namespace v8;
 
@@ -7,6 +8,11 @@ namespace tns {
 
 Caches::Caches(Isolate* isolate, const int& isolateId)
     : isolate_(isolate), isolateId_(isolateId) {
+    // Set up wrapper object. This replaces v8::Externals held in a few places, and is traced by the unified heap in v8.
+    HandleScope scope(isolate);
+    Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+    templ->SetInternalFieldCount(2);
+    WrapperObjectTemplate.Reset(isolate, templ);
 }
 
 Caches::~Caches() {
@@ -44,4 +50,16 @@ Local<Context> Caches::GetContext() {
 std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Caches::Metadata = std::make_shared<ConcurrentMap<std::string, const Meta*>>();
 std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>> Caches::Workers = std::make_shared<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>>();
 
+void Caches::TraceGCProtectedWrappers(cppgc::Visitor* visitor) {
+    // It may make sense to have a separate collection of GcProtected objects.
+    for (auto pair : Instances) {
+        Local<Value> value = pair.second->Get(isolate_);
+        auto* wrapper = ExtractWrapper<BaseDataWrapper>(value);
+        if (wrapper && wrapper->IsGcProtected()) {
+            auto ref = ToTraced<Object>(isolate_, value.As<Object>());
+            static_cast<JSVisitor*>(visitor)->Trace(ref);
+        }
+    }
+}
+
 }
diff --git a/NativeScript/runtime/Caches.h b/NativeScript/runtime/Caches.h
index 96958c53..4f97cbba 100644
--- a/NativeScript/runtime/Caches.h
+++ b/NativeScript/runtime/Caches.h
@@ -89,6 +89,8 @@ class Caches {
     robin_hood::unordered_map<std::pair<void*, std::string>, std::shared_ptr<v8::Persistent<v8::Value>>, pair_hash> StructInstances;
     robin_hood::unordered_map<const void*, std::shared_ptr<v8::Persistent<v8::Object>>> PointerInstances;
 
+    v8::Persistent<v8::ObjectTemplate> WrapperObjectTemplate;
+
     std::function<v8::Local<v8::FunctionTemplate>(v8::Local<v8::Context>, const BaseClassMeta*, KnownUnknownClassPair, const std::vector<std::string>&)> ObjectCtorInitializer;
     std::function<v8::Local<v8::Function>(v8::Local<v8::Context>, StructInfo)> StructCtorInitializer;
     robin_hood::unordered_map<std::string, double> Timers;
@@ -121,6 +123,8 @@ class Caches {
     void registerCacheBoundObject(T *ptr) {
         this->cacheBoundObjects_.push_back(unique_void(ptr));
     }
+
+    void TraceGCProtectedWrappers(cppgc::Visitor* visitor);
 private:
     v8::Isolate* isolate_;
     std::shared_ptr<v8::Persistent<v8::Context>> context_;
diff --git a/NativeScript/runtime/ClassBuilder.h b/NativeScript/runtime/ClassBuilder.h
index 029bfd77..73411703 100644
--- a/NativeScript/runtime/ClassBuilder.h
+++ b/NativeScript/runtime/ClassBuilder.h
@@ -45,10 +45,10 @@ class ClassBuilder {
     static IMP FindNotOverridenMethod(Class klass, SEL method);
 
 
-    struct CacheItem {
+    struct CacheItem : public ExternalData {
     public:
         CacheItem(const InterfaceMeta* meta, id data)
-            : meta_(meta),
+            : ExternalData(ExternalDataType::ClassBuilder), meta_(meta),
               data_(data) {
         }
         const InterfaceMeta* meta_;
diff --git a/NativeScript/runtime/ClassBuilder.mm b/NativeScript/runtime/ClassBuilder.mm
index 0f31ee08..b9e84fc0 100644
--- a/NativeScript/runtime/ClassBuilder.mm
+++ b/NativeScript/runtime/ClassBuilder.mm
@@ -104,7 +104,7 @@
         }
 
         std::string extendedClassName = class_getName(extendedClass);
-        ObjCClassWrapper* wrapper = new ObjCClassWrapper(extendedClass, true);
+        ObjCClassWrapper* wrapper = MakeGarbageCollected<ObjCClassWrapper>(isolate, extendedClass, true);
         tns::SetValue(isolate, extendClassCtorFunc, wrapper);
 
         auto extendedPersistent = std::make_unique<Persistent<v8::Function>>(isolate, extendClassCtorFunc);
@@ -197,7 +197,7 @@
 
         extendedClassName = class_getName(extendedClass);
 
-        tns::SetValue(isolate, extendedClassCtorFunc, new ObjCClassWrapper(extendedClass, true));
+        tns::SetValue(isolate, extendedClassCtorFunc, MakeGarbageCollected<ObjCClassWrapper>(isolate, extendedClass, true));
 
         const Meta* baseMeta = ArgConverter::FindMeta(baseClass);
         const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(baseMeta);
@@ -829,8 +829,9 @@
     Local<Object> superValue = poValue->Get(isolate).As<Object>();
 
     superValue->SetPrototype(context, thiz->GetPrototype().As<Object>()->GetPrototype().As<Object>()->GetPrototype()).ToChecked();
-    superValue->SetInternalField(0, thiz->GetInternalField(0));
-    superValue->SetInternalField(1, tns::ToV8String(isolate, "super"));
+
+    ObjCDataWrapper* wrapper = ExtractWrapper<ObjCDataWrapper>(thiz);
+    AttachGarbageCollectedWrapper(superValue, wrapper);
 
     info.GetReturnValue().Set(superValue);
 }
diff --git a/NativeScript/runtime/Common.h b/NativeScript/runtime/Common.h
index 0d685903..c8d77434 100644
--- a/NativeScript/runtime/Common.h
+++ b/NativeScript/runtime/Common.h
@@ -1,9 +1,256 @@
 #ifndef Common_h
 #define Common_h
 
+#include <type_traits>
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 #include "v8.h"
+
+// FIXME: Move these to a secondary header?
+#include "v8-cppgc.h"
+#include "cppgc/allocation.h"
+#include "cppgc/type-traits.h"
 #pragma clang diagnostic pop
 
+#include <iostream>
+namespace tns {
+
+// FIXME(caitp): Move me to a new file
+static constexpr uint32_t kExternalDataHeader = 0x45585400;
+enum class ExternalDataType {
+    ClassBuilder,
+};
+class ExternalData {
+public:
+    ExternalData(ExternalDataType type)
+    : header(kExternalDataHeader)
+    , type_(type) {}
+    virtual ~ExternalData() = default;
+    bool IsExternalData() const { return header == kExternalDataHeader; }
+    bool IsClassBuilderData() const { assert(IsExternalData()); return type_ == ExternalDataType::ClassBuilder; }
+
+private:
+    uint32_t header;
+    ExternalDataType type_;
+};
+
+
+#define ALLOCATION_HANDLE_FOR_ISOLATE(isolate) (isolate->GetCppHeap()->GetAllocationHandle())
+
+template <typename T>
+struct HasClassNameMethod {
+private:
+    template <typename U>
+    static auto test(int) -> decltype(U::ClassName(), std::true_type{});
+    
+    template <typename U>
+    static std::false_type test(...);
+    
+public:
+    static constexpr bool value = decltype(test<T>(0))::value;
+};
+
+template <typename T>
+typename std::enable_if<HasClassNameMethod<T>::value, const char*>::type
+InvokeClassName() {
+    return T::ClassName();
+}
+
+template <typename T>
+typename std::enable_if<!HasClassNameMethod<T>::value, const char*>::type
+InvokeClassName() {
+    return "Unknown";
+}
+
+template <typename T, typename... Args>
+T* MakeGarbageCollected(v8::Isolate* isolate, Args&&... args) {
+    T* p = nullptr;
+    if constexpr (std::is_constructible_v<T, v8::Isolate*, Args&&...>) {
+        // Supply the isolate* to the target constructor if it's the first parameter.
+        p = cppgc::MakeGarbageCollected<T>(ALLOCATION_HANDLE_FOR_ISOLATE(isolate), isolate, std::forward<Args>(args)...);
+    } else {
+        p = cppgc::MakeGarbageCollected<T>(ALLOCATION_HANDLE_FOR_ISOLATE(isolate), std::forward<Args>(args)...);
+    }
+    //std::cout << "MakeGarbageCollected<" << InvokeClassName<T>() << ">() -> (" << (void*)p << ")\n";
+    return p;
+}
+
+using TracedValue = v8::TracedReference<v8::Value>;
+using TracedObject = v8::TracedReference<v8::Object>;
+
+template <typename T>
+v8::TracedReference<T> ToTraced(v8::Isolate* isolate, v8::Local<T> local) {
+    return v8::TracedReference<T>(isolate, local);
+}
+
+template <typename T>
+v8::TracedReference<T> ToTraced(v8::Isolate* isolate, v8::PersistentBase<T> persistent) {
+    return v8::TracedReference<typename T::ValueType>(isolate, persistent);
+}
+
+class CommonPrivate {
+private:
+    static v8::Local<v8::Object> CreateExtensibleWrapperObject(v8::Isolate*, v8::Local<v8::Context>);
+    static inline v8::Local<v8::Object> CreateWrapperObject(v8::Isolate* isolate, v8::Local<v8::Context> context)
+    {
+        auto result = CreateExtensibleWrapperObject(isolate, context);
+        result->SetIntegrityLevel(context, v8::IntegrityLevel::kSealed);
+        return result;
+    }
+    
+    template <typename T, typename U>
+    friend v8::Local<v8::Object> CreateWrapperFor(v8::Isolate*, v8::Local<v8::Context>, T*);
+    template <typename T, typename U>
+    friend v8::Local<v8::Object> CreateExtensibleWrapperFor(v8::Isolate*, v8::Local<v8::Context>, T*);
+    friend bool IsGarbageCollectedWrapper(v8::Local<v8::Object>);
+};
+
+static constexpr uint16_t kGarbageCollectedEmbedderId = 5440;
+static constexpr v8::WrapperDescriptor kGarbageCollectedWrapperDescriptor {
+    0, /* wrappable_type_index, field which holds Smi-encoded kGarbageCollectedEmbedderId */
+    1, /* wrappable_instance_index, field which holds a BaseDataWrapper* or other GC'd type */
+    kGarbageCollectedEmbedderId,
+};
+static constexpr int kMinGarbageCollectedEmbedderFields = 2;
+static_assert(kMinGarbageCollectedEmbedderFields >=
+              std::max(
+                       kGarbageCollectedWrapperDescriptor.wrappable_type_index,
+                       kGarbageCollectedWrapperDescriptor.wrappable_instance_index));
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+static inline bool AttachGarbageCollectedWrapper(v8::Local<v8::Object> object, T* p)
+{
+    //std::cout << "Attaching GC Wrapper" << InvokeClassName<T>() << " (" << (void*)p << ") to v8 object " << *object << "\n";
+    alignas(2) static const uint16_t embedder_id { kGarbageCollectedEmbedderId };
+    
+    if (object->InternalFieldCount() < kMinGarbageCollectedEmbedderFields)
+        return false;
+    
+    auto desc = kGarbageCollectedWrapperDescriptor;
+    object->SetAlignedPointerInInternalField(desc.wrappable_type_index, (void*)&embedder_id);
+    object->SetAlignedPointerInInternalField(desc.wrappable_instance_index, p);
+    
+    return true;
+}
+
+static inline void DetachGarbageCollectedWrapper(v8::Local<v8::Object> object)
+{
+    if (object->InternalFieldCount() < kMinGarbageCollectedEmbedderFields)
+        return;
+    
+    auto desc = kGarbageCollectedWrapperDescriptor;
+    object->SetAlignedPointerInInternalField(desc.wrappable_type_index, nullptr);
+    object->SetAlignedPointerInInternalField(desc.wrappable_instance_index, nullptr);
+}
+
+inline bool IsGarbageCollectedWrapper(v8::Local<v8::Object> object)
+{
+    static auto test = [](void* p) {
+        if (!p) return false;
+        return *static_cast<uint16_t*>(p) == kGarbageCollectedEmbedderId;
+    };
+    auto desc = kGarbageCollectedWrapperDescriptor;
+    return !object.IsEmpty() && object->InternalFieldCount() >= kMinGarbageCollectedEmbedderFields && test(object->GetAlignedPointerFromInternalField(desc.wrappable_type_index));
+}
+
+inline bool IsGarbageCollectedWrapper(v8::Local<v8::Value> object)
+{
+    if (!object->IsObject())
+        return false;
+    return IsGarbageCollectedWrapper(object.As<v8::Object>());
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+v8::Local<v8::Object> CreateWrapperFor(v8::Isolate* isolate, v8::Local<v8::Context> context, T* ptr)
+{
+    auto result = CommonPrivate::CreateWrapperObject(isolate, context);
+    AttachGarbageCollectedWrapper(result, ptr);
+    return result;
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+v8::Local<v8::Object> CreateWrapperFor(v8::Local<v8::Context> context, T* ptr)
+{
+    return CreateWrapperFor<T>(context->GetIsolate(), context, ptr);
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+v8::Local<v8::Object> CreateWrapperFor(v8::Isolate* isolate, T* ptr)
+{
+    return CreateWrapperFor<T>(isolate, isolate->GetCurrentContext(), ptr);
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+v8::Local<v8::Object> CreateExtensibleWrapperFor(v8::Isolate* isolate, v8::Local<v8::Context> context, T* ptr)
+{
+    auto result = CommonPrivate::CreateExtensibleWrapperObject(isolate, context);
+    AttachGarbageCollectedWrapper(result, ptr);
+    return result;
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+v8::Local<v8::Object> CreateExtensibleWrapperFor(v8::Local<v8::Context> context, T* ptr)
+{
+    return CreateExtensibleWrapperFor<T>(context->GetIsolate(), context, ptr);
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+v8::Local<v8::Object> CreateExtensibleWrapperFor(v8::Isolate* isolate, T* ptr)
+{
+    return CreateExtensibleWrapperFor<T>(isolate, isolate->GetCurrentContext(), ptr);
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+T* ExtractWrapper(v8::Local<v8::Object> object)
+{
+    if (object.IsEmpty() || !IsGarbageCollectedWrapper(object))
+        return nullptr;
+    
+    auto desc = kGarbageCollectedWrapperDescriptor;
+    return static_cast<T*>(object->GetAlignedPointerFromInternalField(desc.wrappable_instance_index));
+}
+
+template <typename T, typename = std::enable_if_t<cppgc::IsGarbageCollectedOrMixinTypeV<T>>>
+T* ExtractWrapper(v8::Local<v8::Value> value)
+{
+    if (value.IsEmpty() || !value->IsObject())
+        return nullptr;
+    auto object = value.As<v8::Object>();
+    if (!IsGarbageCollectedWrapper(object))
+        return nullptr;
+    
+    auto desc = kGarbageCollectedWrapperDescriptor;
+    return static_cast<T*>(object->GetAlignedPointerFromInternalField(desc.wrappable_instance_index));
+}
+}
+#include <sstream>
+namespace tns {
+static inline void PrintProperties(const v8::Local<v8::Object>& obj) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope scope(isolate);
+
+  v8::Local<v8::Array> properties = obj->GetPropertyNames(isolate->GetCurrentContext()).ToLocalChecked();
+
+  std::vector<std::string> propertyNames;
+  for (uint32_t i = 0; i < properties->Length(); ++i) {
+    v8::Local<v8::Value> key = properties->Get(isolate->GetCurrentContext(), i).ToLocalChecked();
+    v8::String::Utf8Value utf8Value(isolate, key);
+
+    propertyNames.push_back(*utf8Value);
+  }
+
+  std::stringstream ss;
+  ss << "[ ";
+  for (const std::string& propertyName : propertyNames) {
+    ss << propertyName << ",\n";
+  }
+  ss << "]" << std::endl;
+
+  std::cout << ss.str();
+  std::cout.flush();
+}
+
+}
+
 #endif /* Common_h */
diff --git a/NativeScript/runtime/Common.mm b/NativeScript/runtime/Common.mm
new file mode 100644
index 00000000..eaddda3b
--- /dev/null
+++ b/NativeScript/runtime/Common.mm
@@ -0,0 +1,10 @@
+#include "Common.h"
+#include "Caches.h"
+
+namespace tns {
+    // static
+    v8::Local<v8::Object> CommonPrivate::CreateExtensibleWrapperObject(v8::Isolate* isolate, v8::Local<v8::Context> context)
+    {
+        return Caches::Get(isolate)->WrapperObjectTemplate.Get(isolate)->NewInstance(context).ToLocalChecked();
+    }
+}
diff --git a/NativeScript/runtime/DataWrapper.h b/NativeScript/runtime/DataWrapper.h
index 0d655b24..0c6d4816 100644
--- a/NativeScript/runtime/DataWrapper.h
+++ b/NativeScript/runtime/DataWrapper.h
@@ -160,8 +160,9 @@ struct StructInfo {
     std::vector<StructField> fields_;
 };
 
-class BaseDataWrapper {
+class BaseDataWrapper : public cppgc::GarbageCollected<BaseDataWrapper> {
 public:
+    static constexpr const char* ClassName() { return "BaseDataWrapper"; }
     BaseDataWrapper()
         : gcProtected_(false) {
     }
@@ -183,12 +184,16 @@ class BaseDataWrapper {
     void GcUnprotect() {
         this->gcProtected_ = false;
     }
+
+    virtual void Trace(cppgc::Visitor*) const {}
+
 private:
     bool gcProtected_;
 };
 
 class EnumDataWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "EnumDataWrapper"; }
     EnumDataWrapper(std::string jsCode)
         : jsCode_(jsCode) {
     }
@@ -206,6 +211,7 @@ class EnumDataWrapper: public BaseDataWrapper {
 
 class PointerTypeWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "PointerTypeWrapper"; }
     const WrapperType Type() {
         return WrapperType::PointerType;
     }
@@ -213,10 +219,12 @@ class PointerTypeWrapper: public BaseDataWrapper {
 
 class PointerWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "PointerWrapper"; }
     PointerWrapper(void* data)
         : data_(data),
           isAdopted_(false) {
     }
+    ~PointerWrapper();
 
     const WrapperType Type() {
         return WrapperType::Pointer;
@@ -244,6 +252,7 @@ class PointerWrapper: public BaseDataWrapper {
 
 class ReferenceTypeWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "ReferenceTypeWrapper"; }
     const WrapperType Type() {
         return WrapperType::ReferenceType;
     }
@@ -251,24 +260,15 @@ class ReferenceTypeWrapper: public BaseDataWrapper {
 
 class ReferenceWrapper: public BaseDataWrapper {
 public:
-    ReferenceWrapper(BaseDataWrapper* typeWrapper, v8::Persistent<v8::Value>* value)
+    static constexpr const char* ClassName() { return "ReferenceWrapper"; }
+    ReferenceWrapper(BaseDataWrapper* typeWrapper, TracedValue* value)
         : typeWrapper_(typeWrapper),
           value_(value),
           encoding_(nullptr),
           data_(nullptr),
           disposeData_(false) {
     }
-
-    ~ReferenceWrapper() {
-        if(this->value_ != nullptr) {
-            value_->Reset();
-            delete value_;
-        }
-        
-        if (this->data_ != nullptr) {
-            std::free(this->data_);
-        }
-    }
+    ~ReferenceWrapper();
 
     const WrapperType Type() {
         return WrapperType::Reference;
@@ -278,14 +278,23 @@ class ReferenceWrapper: public BaseDataWrapper {
         return this->typeWrapper_;
     }
 
-    v8::Persistent<v8::Value>* Value() {
-        return this->value_;
+    bool HasValue() const {
+        return value_ != nullptr && !value_->IsEmpty();
     }
 
-    void SetValue(v8::Persistent<v8::Value>* value) {
-        if (this->value_ != nullptr) {
+    TracedValue Value() {
+        if (value_ != nullptr)
+            return *value_;
+        return TracedValue();
+    }
+
+    TracedValue* UnsafeValue() {
+        return value_;
+    }
+
+    void SetValue(TracedValue* value) {
+        if (this->value_ != nullptr)
             this->value_->Reset();
-        }
         this->value_ = value;
     }
 
@@ -308,9 +317,18 @@ class ReferenceWrapper: public BaseDataWrapper {
         this->data_ = data;
         this->disposeData_ = disposeData;
     }
+
+    void Trace(cppgc::Visitor* visitor) const {
+        // ASSERT: visitor is a JSVisitor
+        if (this->typeWrapper_)
+            visitor->Trace(*typeWrapper_);
+        if (this->value_ != nullptr)
+            static_cast<v8::JSVisitor*>(visitor)->Trace(*value_);
+    }
+
 private:
     BaseDataWrapper* typeWrapper_;
-    v8::Persistent<v8::Value>* value_;
+    TracedValue* value_;
     const TypeEncoding* encoding_;
     void* data_;
     bool disposeData_;
@@ -318,15 +336,12 @@ class ReferenceWrapper: public BaseDataWrapper {
 
 class PrimitiveDataWrapper: public BaseDataWrapper {
 public:
-    PrimitiveDataWrapper(size_t size,const TypeEncoding* typeEncoding, bool autoDeleteEncoding)
-        : size_(size),
-          typeEncoding_(typeEncoding),
-          autoDeleteEncoding_(autoDeleteEncoding) {
+    static constexpr const char* ClassName() { return "ReferenceTypeWrapper"; }
+    PrimitiveDataWrapper(size_t size, BinaryTypeEncodingType type)
+        : size_(size)
+        , typeEncoding_({ type, {} }) {
     }
     ~PrimitiveDataWrapper() {
-        if (autoDeleteEncoding_) {
-            std::free((struct TypeEncoding*)typeEncoding_);
-        }
     }
 
     const WrapperType Type() {
@@ -338,16 +353,16 @@ class PrimitiveDataWrapper: public BaseDataWrapper {
     }
 
     const TypeEncoding* TypeEncoding() {
-        return this->typeEncoding_;
+        return &this->typeEncoding_;
     }
 private:
     size_t size_;
-    const struct TypeEncoding* typeEncoding_;
-    bool autoDeleteEncoding_;
+    struct TypeEncoding typeEncoding_;
 };
 
 class StructTypeWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "StructTypeWrapper"; }
     StructTypeWrapper(StructInfo structInfo)
         : structInfo_(structInfo) {
     }
@@ -365,13 +380,17 @@ class StructTypeWrapper: public BaseDataWrapper {
 
 class StructWrapper: public StructTypeWrapper {
 public:
-    StructWrapper(struct StructInfo structInfo, void* data, std::shared_ptr<v8::Persistent<v8::Value>> parent)
+    static constexpr const char* ClassName() { return "StructWrapper"; }
+    StructWrapper(v8::Isolate* isolate, struct StructInfo structInfo, void* data, v8::Local<v8::Value> parent = {})
         : StructTypeWrapper(structInfo),
           data_(data),
-          childCount_(0),
-          parent_(parent) {
+          childCount_(0) {
+        if (!parent.IsEmpty())
+            parent_.Reset(isolate, parent);
     }
 
+    ~StructWrapper();
+
     const WrapperType Type() {
         return WrapperType::Struct;
     }
@@ -380,8 +399,8 @@ class StructWrapper: public StructTypeWrapper {
         return this->data_;
     }
 
-    std::shared_ptr<v8::Persistent<v8::Value>> Parent() {
-        return this->parent_;
+    bool HasParent() const {
+        return !parent_.IsEmpty();
     }
 
     void IncrementChildren() {
@@ -395,14 +414,21 @@ class StructWrapper: public StructTypeWrapper {
     int ChildCount() {
         return this->childCount_;
     }
+
+    void Trace(cppgc::Visitor* visitor) const {
+        // ASSERT: visitor is a JSVisitor
+        static_cast<v8::JSVisitor*>(visitor)->Trace(parent_);
+    }
+
 private:
     void* data_;
     int childCount_;
-    std::shared_ptr<v8::Persistent<v8::Value>> parent_;
+    v8::TracedReference<v8::Value> parent_;
 };
 
 class ObjCAllocDataWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "ObjCAllocDataWrapper"; }
     ObjCAllocDataWrapper(Class klass)
         : klass_(klass) {
     }
@@ -420,6 +446,7 @@ class ObjCAllocDataWrapper: public BaseDataWrapper {
 
 class UnmanagedTypeWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "UnmanagedTypeWrapper"; }
     UnmanagedTypeWrapper(uint8_t* data, const TypeEncoding* typeEncoding)
         : data_(data), typeEncoding_(typeEncoding), valueTaken_(false) {
     }
@@ -448,9 +475,15 @@ class UnmanagedTypeWrapper: public BaseDataWrapper {
 
 class ObjCDataWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "ObjCDataWrapper"; }
     ObjCDataWrapper(id data, const TypeEncoding* typeEncoding = nullptr)
         : data_(data), typeEncoding_(typeEncoding) {
     }
+    ~ObjCDataWrapper() {
+        ReleaseNativeCounterpart();
+    }
+
+    void ReleaseNativeCounterpart();
 
     const WrapperType Type() {
         return WrapperType::ObjCObject;
@@ -470,6 +503,7 @@ class ObjCDataWrapper: public BaseDataWrapper {
 
 class ObjCClassWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "ObjCClassWrapper"; }
     ObjCClassWrapper(Class klazz, bool extendedClass = false)
         : klass_(klazz),
           extendedClass_(extendedClass) {
@@ -493,6 +527,7 @@ class ObjCClassWrapper: public BaseDataWrapper {
 
 class ObjCProtocolWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "ObjCProtocolWrapper"; }
     ObjCProtocolWrapper(Protocol* proto, const ProtocolMeta* protoMeta)
         : proto_(proto),
           protoMeta_(protoMeta) {
@@ -516,6 +551,7 @@ class ObjCProtocolWrapper: public BaseDataWrapper {
 
 class FunctionWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "FunctionWrapper"; }
     FunctionWrapper(const FunctionMeta* meta)
         : meta_(meta) {
     }
@@ -533,6 +569,7 @@ class FunctionWrapper: public BaseDataWrapper {
 
 class AnonymousFunctionWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "AnonymousFunctionWrapper"; }
     AnonymousFunctionWrapper(void* functionPointer, const TypeEncoding* parametersEncoding, size_t parametersCount)
         : data_(functionPointer),
           parametersEncoding_(parametersEncoding) {
@@ -556,12 +593,14 @@ class AnonymousFunctionWrapper: public BaseDataWrapper {
 
 class BlockWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "BlockWrapper"; }
     BlockWrapper(void* block, const TypeEncoding* typeEncoding, bool ownsBlock)
         : block_(block),
           typeEncoding_(typeEncoding),
           ownsBlock_(ownsBlock) {
     }
-    
+    ~BlockWrapper();
+
     const WrapperType Type() {
         return WrapperType::Block;
     }
@@ -586,6 +625,7 @@ class BlockWrapper: public BaseDataWrapper {
 
 class FunctionReferenceTypeWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "FunctionReferenceTypeWrapper"; }
     const WrapperType Type() {
         return WrapperType::FunctionReferenceType;
     }
@@ -593,11 +633,20 @@ class FunctionReferenceTypeWrapper: public BaseDataWrapper {
 
 class FunctionReferenceWrapper: public BaseDataWrapper {
 public:
+    static constexpr const char* ClassName() { return "FunctionReferenceWrapper"; }
     FunctionReferenceWrapper(std::shared_ptr<v8::Persistent<v8::Value>> function)
         : function_(function),
           data_(nullptr) {
     }
 
+    ~FunctionReferenceWrapper() {
+        // FIXME: Does this make sense? Shouldn't we sanitize the reference count
+        // before clobbering the shared pointer's contents?
+        if (function_ != nullptr) {
+           function_->Reset();
+        }
+    }
+
     const WrapperType Type() {
         return WrapperType::FunctionReference;
     }
@@ -620,12 +669,14 @@ class FunctionReferenceWrapper: public BaseDataWrapper {
 
 class ExtVectorWrapper: public BaseDataWrapper {
 public:
-    ExtVectorWrapper(void* data, ffi_type* ffiType, const TypeEncoding* innerTypeEncoding, const TypeEncoding* typeEncoding)
+    static constexpr const char* ClassName() { return "ExtVectorWrapper"; }
+    ExtVectorWrapper(v8::Isolate* isolate, void* data, ffi_type* ffiType, const TypeEncoding* innerTypeEncoding, const TypeEncoding* typeEncoding)
         : data_(data),
           ffiType_(ffiType),
           innerTypeEncoding_(innerTypeEncoding),
           typeEncoding_(typeEncoding) {
     }
+    ~ExtVectorWrapper();
 
     const WrapperType Type() {
         return WrapperType::ExtVector;
@@ -655,6 +706,7 @@ class ExtVectorWrapper: public BaseDataWrapper {
 class WorkerWrapper: public BaseDataWrapper {
 public:
     WorkerWrapper(v8::Isolate* mainIsolate, std::function<void (v8::Isolate*, v8::Local<v8::Object> thiz, std::string)> onMessage);
+    ~WorkerWrapper();
 
     void Start(std::shared_ptr<v8::Persistent<v8::Value>> poWorker, std::function<v8::Isolate* ()> func);
     void CallOnErrorHandlers(v8::TryCatch& tc);
diff --git a/NativeScript/runtime/DataWrapper.mm b/NativeScript/runtime/DataWrapper.mm
new file mode 100644
index 00000000..9b63eb2b
--- /dev/null
+++ b/NativeScript/runtime/DataWrapper.mm
@@ -0,0 +1,81 @@
+#include "DataWrapper.h"
+
+#include "Caches.h"
+#include "FFICall.h"
+#include "ObjectManager.h"
+
+namespace tns {
+
+StructWrapper::~StructWrapper() {
+    parent_.Reset();
+    if (data_) {
+        // v8::Isolate::GetCurrent() may not necessarily be the isolate this object lives in.
+        // Remove the (weak) v8::Persistent holding the JS value.
+        if (auto cache = Caches::Get(v8::Isolate::GetCurrent()))
+            cache->StructInstances.erase(std::make_pair(data_, StructInfo().Name()));
+        free(data_);
+    }
+}
+
+
+void ObjCDataWrapper::ReleaseNativeCounterpart() {
+    id target = data_;
+    if (target != nil) {
+        if (auto cache = Caches::Get(v8::Isolate::GetCurrent())) {
+            auto it = cache->Instances.find(data_);
+            if (it != cache->Instances.end()) {
+                ObjectWeakCallbackState* state = it->second->ClearWeak<ObjectWeakCallbackState>();
+                if (state != nullptr)
+                    delete state;
+                cache->Instances.erase(target);
+            }
+        }
+        [target release];
+    }
+    data_ = nil;
+}
+
+BlockWrapper::~BlockWrapper() {
+    if (!OwnsBlock())
+        std::free(Block());
+}
+
+ReferenceWrapper::~ReferenceWrapper() {
+    if (data_ != nullptr) {
+        SetData(nullptr);
+        SetEncoding(nullptr);
+    }
+}
+
+PointerWrapper::~PointerWrapper() {
+    if (data_ != nullptr) {
+        auto data = data_;
+        data_ = nullptr;
+        if (auto cache = Caches::Get(v8::Isolate::GetCurrent()))
+            cache->PointerInstances.erase(data);
+
+        if (IsAdopted())
+            std::free(data);
+    }
+}
+
+ExtVectorWrapper::~ExtVectorWrapper() {
+    FFICall::DisposeFFIType(FFIType(), TypeEncoding());
+    if (data_) {
+        std::free(data_);
+        data_ = nullptr;
+    }
+}
+
+WorkerWrapper::~WorkerWrapper() {
+    // FIXME: This doesn't actually make sense, rethink the ownership model.
+    // if (!worker->isDisposed()) {
+    //     // during final disposal, inform the worker it should delete itself
+    //     if (isFinalDisposal) {
+    //         worker->MakeWeak();
+    //     }
+    //     return false;
+    // }
+}
+
+}
diff --git a/NativeScript/runtime/DictionaryAdapter.mm b/NativeScript/runtime/DictionaryAdapter.mm
index ca95a005..36295368 100644
--- a/NativeScript/runtime/DictionaryAdapter.mm
+++ b/NativeScript/runtime/DictionaryAdapter.mm
@@ -163,7 +163,7 @@ - (instancetype)initWithJSObject:(Local<Object>)jsObject isolate:(Isolate*)isola
         self->cache_ = Caches::Get(isolate);
         self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
         self->cache_->Instances.emplace(self, self->object_);
-        tns::SetValue(isolate, jsObject, new ObjCDataWrapper(self));
+        tns::SetValue(isolate, jsObject, MakeGarbageCollected<ObjCDataWrapper>(isolate, self));
     }
 
     return self;
diff --git a/NativeScript/runtime/DisposerPHV.mm b/NativeScript/runtime/DisposerPHV.mm
index b9b998fe..8de43e93 100644
--- a/NativeScript/runtime/DisposerPHV.mm
+++ b/NativeScript/runtime/DisposerPHV.mm
@@ -22,12 +22,12 @@
         case Constants::ClassTypes::DataWrapper: {
             v8::HandleScope scope(isolate_);
             // use ObjectManager anyway, as it handles a bigger variety of wrappers
-            ObjectManager::DisposeValue(isolate_, value->Get(isolate_), true);
+            //ObjectManager::DisposeValue(isolate_, value->Get(isolate_), true);
             break;
         }
         case Constants::ClassTypes::ObjectManagedValue: {
             v8::HandleScope scope(isolate_);
-            ObjectManager::DisposeValue(isolate_, value->Get(isolate_), true);
+            //ObjectManager::DisposeValue(isolate_, value->Get(isolate_), true);
             if (value->IsWeak()) {
                 ObjectWeakCallbackState* state = value->ClearWeak<ObjectWeakCallbackState>();
                 state->target_->Reset();
diff --git a/NativeScript/runtime/ExtVector.cpp b/NativeScript/runtime/ExtVector.cpp
index b27c1d22..57cca4e5 100644
--- a/NativeScript/runtime/ExtVector.cpp
+++ b/NativeScript/runtime/ExtVector.cpp
@@ -22,7 +22,7 @@ Local<Value> ExtVector::NewInstance(Isolate* isolate, void* data, ffi_type* ffiT
     tns::Assert(success, isolate);
 
     // TODO: Validate that the inner type is supported (float, double)
-    ExtVectorWrapper* wrapper = new ExtVectorWrapper(data, ffiType, innerTypeEncoding, typeEncoding);
+    ExtVectorWrapper* wrapper = MakeGarbageCollected<ExtVectorWrapper>(isolate, data, ffiType, innerTypeEncoding, typeEncoding);
     tns::SetValue(isolate, result.As<Object>(), wrapper);
 
     return result;
@@ -78,7 +78,7 @@ void ExtVector::IndexedPropertySetCallback(uint32_t index, Local<Value> value, c
 void ExtVector::RegisterToStringMethod(Isolate* isolate, Local<ObjectTemplate> prototypeTemplate) {
     Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
         Isolate* isolate = info.GetIsolate();
-        ExtVectorWrapper* wrapper = static_cast<ExtVectorWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        ExtVectorWrapper* wrapper = ExtractWrapper<ExtVectorWrapper>(info.This());
         void* value = wrapper->Data();
 
         char buffer[100];
diff --git a/NativeScript/runtime/FunctionReference.cpp b/NativeScript/runtime/FunctionReference.cpp
index 0d7bde18..229e2383 100644
--- a/NativeScript/runtime/FunctionReference.cpp
+++ b/NativeScript/runtime/FunctionReference.cpp
@@ -33,7 +33,7 @@ Local<v8::Function> FunctionReference::GetFunctionReferenceCtorFunc(Local<Contex
         tns::Assert(false, isolate);
     }
 
-    tns::SetValue(isolate, ctorFunc, new FunctionReferenceTypeWrapper());
+    tns::SetValue(isolate, ctorFunc, MakeGarbageCollected<FunctionReferenceTypeWrapper>(isolate));
 
     cache->FunctionReferenceCtorFunc = std::make_unique<Persistent<v8::Function>>(isolate, ctorFunc);
     cache->FunctionReferenceCtorFunc->SetWrapperClassId(Constants::ClassTypes::DataWrapper);
@@ -50,7 +50,7 @@ void FunctionReference::FunctionReferenceConstructorCallback(const FunctionCallb
 
     Local<v8::Function> arg = info[0].As<v8::Function>();
     std::shared_ptr<Persistent<v8::Value>> poArg = ObjectManager::Register(context, arg);
-    FunctionReferenceWrapper* wrapper = new FunctionReferenceWrapper(poArg);
+    FunctionReferenceWrapper* wrapper = MakeGarbageCollected<FunctionReferenceWrapper>(isolate, poArg);
     tns::SetValue(isolate, arg, wrapper);
     info.GetReturnValue().Set(arg);
 }
diff --git a/NativeScript/runtime/GCProtectedSet.cpp b/NativeScript/runtime/GCProtectedSet.cpp
new file mode 100644
index 00000000..e49a3da8
--- /dev/null
+++ b/NativeScript/runtime/GCProtectedSet.cpp
@@ -0,0 +1,31 @@
+#include "GCProtectedSet.h"
+
+#include "Caches.h"
+#include "Helpers.h"
+#include "Runtime.h"
+
+namespace tns {
+
+using namespace v8;
+
+void GCProtectedSet::Init(v8::Local<v8::Context> context) {
+    Isolate* isolate = context->GetIsolate();
+    auto cache = Caches::Get(isolate);
+
+    Local<Object> global = context->Global();
+
+    auto* wrapper = MakeGarbageCollected<GCProtectedSet>(isolate);
+    Local<Object> gcProtected = CreateWrapperFor(isolate, wrapper);
+
+    Local<Private> globalName = Private::ForApi(isolate, v8::String::NewFromUtf8Literal(isolate, "GCProtectedSet"));
+
+    global->SetPrivate(context, globalName, gcProtected).Check();
+}
+
+void GCProtectedSet::Trace(cppgc::Visitor* visitor) const {
+    auto cache = Caches::Get(isolate_);
+
+    cache->TraceGCProtectedWrappers(visitor);
+}
+
+}
diff --git a/NativeScript/runtime/GCProtectedSet.h b/NativeScript/runtime/GCProtectedSet.h
new file mode 100644
index 00000000..0965917a
--- /dev/null
+++ b/NativeScript/runtime/GCProtectedSet.h
@@ -0,0 +1,24 @@
+#ifndef GCProtectedSet_h
+#define GCProtectedSet_h
+
+#include "Common.h"
+
+namespace tns {
+
+class Runtime;
+
+/// GCProtectedSet is a CPPGC-traceable object which ensures that certain objects are kept alive
+class GCProtectedSet final: public cppgc::GarbageCollected<GCProtectedSet> {
+public:
+    static void Init(v8::Local<v8::Context> context);
+
+    void Trace(cppgc::Visitor* visitor) const;
+
+    GCProtectedSet(v8::Isolate* isolate): isolate_(isolate) { }
+private:
+    v8::Isolate* isolate_;
+};
+
+}
+
+#endif /* GCProtected_h */
diff --git a/NativeScript/runtime/Helpers.h b/NativeScript/runtime/Helpers.h
index 55464dd7..f167a2bd 100644
--- a/NativeScript/runtime/Helpers.h
+++ b/NativeScript/runtime/Helpers.h
@@ -145,6 +145,8 @@ void SetPrivateValue(const v8::Local<v8::Object>& obj, const v8::Local<v8::Strin
 v8::Local<v8::Value> GetPrivateValue(const v8::Local<v8::Object>& obj, const v8::Local<v8::String>& propName);
 
 void SetValue(v8::Isolate* isolate, const v8::Local<v8::Object>& obj, BaseDataWrapper* value);
+void SetValue(v8::Isolate* isolate, const v8::Local<v8::Object>& obj, const v8::Local<v8::Value>& value);
+
 BaseDataWrapper* GetValue(v8::Isolate* isolate, const v8::Local<v8::Value>& val);
 void DeleteValue(v8::Isolate* isolate, const v8::Local<v8::Value>& val);
 bool DeleteWrapperIfUnused(v8::Isolate* isolate, const v8::Local<v8::Value>& obj, BaseDataWrapper* value);
diff --git a/NativeScript/runtime/Helpers.mm b/NativeScript/runtime/Helpers.mm
index f98b005d..452de513 100644
--- a/NativeScript/runtime/Helpers.mm
+++ b/NativeScript/runtime/Helpers.mm
@@ -22,7 +22,11 @@
     uint8_t* BinBuffer = new uint8_t[BUFFER_SIZE];
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
 std::u16string tns::ToUtf16String(Isolate* isolate, const Local<Value>& value) {
+
     std::string valueStr = tns::ToString(isolate, value);
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     // FIXME: std::codecvt_utf8_utf16 is deprecated
@@ -44,6 +48,8 @@
     return vector;
 }
 
+#pragma clang diagnostic pop
+
 bool tns::Exists(const char* fullPath) {
     struct stat statbuf;
     mode_t mode = S_IFDIR | S_IFREG;
@@ -219,13 +225,27 @@
         return;
     }
 
-    Local<External> ext = External::New(isolate, value);
+    if (!AttachGarbageCollectedWrapper(obj, value))
+        tns::SetPrivateValue(obj, tns::ToV8String(isolate, "metadata"), CreateWrapperFor(isolate, value));
+}
+
+void tns::SetValue(Isolate* isolate, const v8::Local<v8::Object>& obj, const v8::Local<v8::Value>& value) {
+    if (obj.IsEmpty() || obj->IsNullOrUndefined())
+        return;
+
+    v8::Local<v8::Value> v(value);
+    if (v.IsEmpty())
+        v = v8::Undefined(isolate);
 
-    if (obj->InternalFieldCount() > 0) {
-        obj->SetInternalField(0, ext);
-    } else {
-        tns::SetPrivateValue(obj, tns::ToV8String(isolate, "metadata"), ext);
+    if (IsGarbageCollectedWrapper(obj)) {
+        if (BaseDataWrapper* wrapper = ExtractWrapper<BaseDataWrapper>(value)) {
+            if (AttachGarbageCollectedWrapper(obj, wrapper))
+                return;
+        } else
+            return DetachGarbageCollectedWrapper(obj);
     }
+
+    tns::SetPrivateValue(obj, tns::ToV8String(isolate, "metadata"), v);
 }
 
 tns::BaseDataWrapper* tns::GetValue(Isolate* isolate, const Local<Value>& val) {
@@ -234,21 +254,12 @@
     }
 
     Local<Object> obj = val.As<Object>();
-    if (obj->InternalFieldCount() > 0) {
-        Local<Value> field = obj->GetInternalField(0);
-        if (field.IsEmpty() || field->IsNullOrUndefined() || !field->IsExternal()) {
-            return nullptr;
-        }
-
-        return static_cast<BaseDataWrapper*>(field.As<External>()->Value());
-    }
+    auto result = ExtractWrapper<BaseDataWrapper>(obj);
+    if (result)
+        return result;
 
     Local<Value> metadataProp = tns::GetPrivateValue(obj, tns::ToV8String(isolate, "metadata"));
-    if (metadataProp.IsEmpty() || metadataProp->IsNullOrUndefined() || !metadataProp->IsExternal()) {
-        return nullptr;
-    }
-
-    return static_cast<BaseDataWrapper*>(metadataProp.As<External>()->Value());
+    return ExtractWrapper<BaseDataWrapper>(metadataProp);
 }
 
 void tns::DeleteValue(Isolate* isolate, const Local<Value>& val) {
@@ -257,7 +268,9 @@
     }
 
     Local<Object> obj = val.As<Object>();
-    if (obj->InternalFieldCount() > 0) {
+    if (IsGarbageCollectedWrapper(obj)) {
+        DetachGarbageCollectedWrapper(obj);
+    } else if (obj->InternalFieldCount() > 0) {
         obj->SetInternalField(0, v8::Undefined(isolate));
         return;
     }
diff --git a/NativeScript/runtime/Interop.h b/NativeScript/runtime/Interop.h
index 3963fc28..5b3baead 100644
--- a/NativeScript/runtime/Interop.h
+++ b/NativeScript/runtime/Interop.h
@@ -119,7 +119,7 @@ class Interop {
     static id CallInitializer(v8::Local<v8::Context> context, const MethodMeta* methodMeta, id target, Class clazz, V8Args& args);
     static v8::Local<v8::Value> CallFunction(ObjCMethodCall& methodCall);
     static v8::Local<v8::Value> CallFunction(CMethodCall& methodCall);
-    static v8::Local<v8::Value> GetResult(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, BaseCall* call, bool marshalToPrimitive, std::shared_ptr<v8::Persistent<v8::Value>> parentStruct = nullptr, bool isStructMember = false, bool ownsReturnedObject = false, bool returnsUnmanaged = false, bool isInitializer = false);
+    static v8::Local<v8::Value> GetResult(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, BaseCall* call, bool marshalToPrimitive, v8::Local<v8::Value> parentStruct = {}, bool isStructMember = false, bool ownsReturnedObject = false, bool returnsUnmanaged = false, bool isInitializer = false);
     static void SetStructPropertyValue(v8::Local<v8::Context> context, StructWrapper* wrapper, StructField field, v8::Local<v8::Value> value);
     static void InitializeStruct(v8::Local<v8::Context> context, void* destBuffer, std::vector<StructField> fields, v8::Local<v8::Value> inititalizer);
     static void WriteValue(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, void* dest, v8::Local<v8::Value> arg);
@@ -142,7 +142,7 @@ class Interop {
     static void SetFFIParams(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, FFICall* call, const int argsCount, const int initialParameterIndex, V8Args& args);
     static bool isRefTypeEqual(const TypeEncoding* typeEncoding,const char* clazz);
     static v8::Local<v8::Array> ToArray(v8::Local<v8::Object> object);
-    static v8::Local<v8::Value> StructToValue(v8::Local<v8::Context> context, void* result, StructInfo structInfo, std::shared_ptr<v8::Persistent<v8::Value>> parentStruct);
+    static v8::Local<v8::Value> StructToValue(v8::Local<v8::Context> context, void* result, StructInfo structInfo, v8::Local<v8::Value> parentStruct = {});
     static const TypeEncoding* CreateEncoding(BinaryTypeEncodingType type);
     static v8::Local<v8::Value> HandleOf(v8::Local<v8::Context> context, v8::Local<v8::Value> value);
     static v8::Local<v8::Value> CallFunctionInternal(MethodCall& methodCall);
diff --git a/NativeScript/runtime/Interop.mm b/NativeScript/runtime/Interop.mm
index bdbbbf20..25cc4ac8 100644
--- a/NativeScript/runtime/Interop.mm
+++ b/NativeScript/runtime/Interop.mm
@@ -240,8 +240,8 @@ inline bool isBool() {
                 Interop::SetValue(dest, data);
             } else if (wrapper->Type() == WrapperType::Reference) {
                 ReferenceWrapper* refWrapper = static_cast<ReferenceWrapper*>(wrapper);
-                tns::Assert(refWrapper->Value() != nullptr, isolate);
-                Local<Value> value = refWrapper->Value()->Get(isolate);
+                tns::Assert(refWrapper->HasValue(), isolate);
+                Local<Value> value = refWrapper->Value().Get(isolate);
                 wrapper = tns::GetValue(isolate, value);
                 tns::Assert(wrapper != nullptr && wrapper->Type() == WrapperType::Pointer, isolate);
                 PointerWrapper* pw = static_cast<PointerWrapper*>(wrapper);
@@ -364,7 +364,7 @@ inline bool isBool() {
                     data = pointerWrapper->Data();
                 } else if (wrapper->Type() == WrapperType::Reference) {
                     ReferenceWrapper* referenceWrapper = static_cast<ReferenceWrapper*>(wrapper);
-                    Local<Value> value = referenceWrapper->Value() != nullptr ? referenceWrapper->Value()->Get(isolate) : Local<Value>();
+                    Local<Value> value = referenceWrapper->Value().Get(isolate);
                     ffi_type* ffiType = FFICall::GetArgumentType(innerType);
                     data = calloc(1, ffiType->size);
                     FFICall::DisposeFFIType(ffiType, innerType);
@@ -431,7 +431,7 @@ inline bool isBool() {
             MethodCallbackWrapper* userData = new MethodCallbackWrapper(isolate, poCallback, 1, argsCount, blockTypeEncoding);
             blockPtr = Interop::CreateBlock(1, argsCount, blockTypeEncoding, ArgConverter::MethodCallback, userData);
 
-            BlockWrapper* wrapper = new BlockWrapper((void*)blockPtr, blockTypeEncoding, false);
+            BlockWrapper* wrapper = MakeGarbageCollected<BlockWrapper>(isolate, (void*)blockPtr, blockTypeEncoding, false);
             tns::SetValue(isolate, arg.As<v8::Function>(), wrapper);
         }
 
@@ -663,23 +663,22 @@ inline bool isBool() {
     return nil;
 }
 
-Local<Value> Interop::StructToValue(Local<Context> context, void* result, StructInfo structInfo, std::shared_ptr<Persistent<Value>> parentStruct) {
+Local<Value> Interop::StructToValue(Local<Context> context, void* result, StructInfo structInfo, Local<Value> parentStruct) {
     Isolate* isolate = context->GetIsolate();
     StructWrapper* wrapper = nullptr;
-    if (parentStruct == nullptr) {
+    if (parentStruct.IsEmpty()) {
         ffi_type* ffiType = structInfo.FFIType();
         void* dest = malloc(ffiType->size);
         memcpy(dest, result, ffiType->size);
 
-        wrapper = new StructWrapper(structInfo, dest, nullptr);
+        wrapper = MakeGarbageCollected<StructWrapper>(isolate, structInfo, dest);
     } else {
-        Local<Value> parent = parentStruct->Get(isolate);
-        BaseDataWrapper* parentWrapper = tns::GetValue(isolate, parent);
+        BaseDataWrapper* parentWrapper = tns::GetValue(isolate, parentStruct);
         if (parentWrapper != nullptr && parentWrapper->Type() == WrapperType::Struct) {
             StructWrapper* parentStructWrapper = static_cast<StructWrapper*>(parentWrapper);
             parentStructWrapper->IncrementChildren();
         }
-        wrapper = new StructWrapper(structInfo, result, parentStruct);
+        wrapper = MakeGarbageCollected<StructWrapper>(isolate, structInfo, result, parentStruct);
     }
 
     std::shared_ptr<Caches> cache = Caches::Get(isolate);
@@ -690,7 +689,7 @@ inline bool isBool() {
     }
 
     Local<Value> res = ArgConverter::ConvertArgument(context, wrapper);
-    if (parentStruct == nullptr) {
+    if (parentStruct.IsEmpty()) {
         std::shared_ptr<Persistent<Value>> poResult = ObjectManager::Register(context, res);
         cache->StructInstances.emplace(key, poResult);
     }
@@ -803,12 +802,12 @@ inline bool isBool() {
     *static_cast<T*>((void*)((uint8_t*)destBuffer + position)) = result;
 }
 
-Local<Value> Interop::GetResult(Local<Context> context, const TypeEncoding* typeEncoding, BaseCall* call, bool marshalToPrimitive, std::shared_ptr<Persistent<Value>> parentStruct, bool isStructMember, bool ownsReturnedObject, bool returnsUnmanaged, bool isInitializer) {
+Local<Value> Interop::GetResult(Local<Context> context, const TypeEncoding* typeEncoding, BaseCall* call, bool marshalToPrimitive, Local<Value> parentStruct, bool isStructMember, bool ownsReturnedObject, bool returnsUnmanaged, bool isInitializer) {
     Isolate* isolate = context->GetIsolate();
 
     if (returnsUnmanaged) {
         uint8_t* data = call->GetResult<uint8_t*>();
-        UnmanagedTypeWrapper* wrapper = new UnmanagedTypeWrapper(data, typeEncoding);
+        UnmanagedTypeWrapper* wrapper = MakeGarbageCollected<UnmanagedTypeWrapper>(isolate, data, typeEncoding);
         Local<Value> result = UnmanagedType::Create(context, wrapper);
         ObjectManager::Register(context, result);
         return result;
@@ -947,15 +946,14 @@ inline bool isBool() {
             return callback;
         }
 
-        BlockWrapper* blockWrapper = new BlockWrapper(block, typeEncoding, true);
-        Local<External> ext = External::New(isolate, blockWrapper);
+        BlockWrapper* blockWrapper = MakeGarbageCollected<BlockWrapper>(isolate, block, typeEncoding, true);
+        auto ext = CreateWrapperFor(isolate, blockWrapper);
         Local<v8::Function> callback;
 
         CFRetain(block);
 
         bool success = v8::Function::New(context, [](const FunctionCallbackInfo<Value>& info) {
-            Local<External> ext = info.Data().As<External>();
-            BlockWrapper* wrapper = static_cast<BlockWrapper*>(ext->Value());
+            BlockWrapper* wrapper = ExtractWrapper<BlockWrapper>(info.Data());
 
             JSBlock* block = static_cast<JSBlock*>(wrapper->Block());
 
@@ -974,13 +972,13 @@ inline bool isBool() {
 
             ffi_call(parametrizedCall->Cif, FFI_FN(block->invoke), call.ResultBuffer(), call.ArgsArray());
 
-            Local<Value> result = Interop::GetResult(context, enc, &call, true, nullptr);
+            Local<Value> result = Interop::GetResult(context, enc, &call, true, Local<Value>());
 
             info.GetReturnValue().Set(result);
         }, ext).ToLocal(&callback);
         tns::Assert(success, isolate);
 
-        tns::SetValue(isolate, callback, blockWrapper);
+        tns::SetValue(isolate, callback, ext);
         ObjectManager::Register(context, callback);
 
         return callback;
@@ -994,13 +992,13 @@ inline bool isBool() {
 
         const TypeEncoding* parametersEncoding = typeEncoding->details.functionPointer.signature.first();
         size_t parametersCount = typeEncoding->details.functionPointer.signature.count;
-        AnonymousFunctionWrapper* wrapper = new AnonymousFunctionWrapper(functionPointer, parametersEncoding, parametersCount);
-        Local<External> ext = External::New(isolate, wrapper);
+        AnonymousFunctionWrapper* wrapper = MakeGarbageCollected<AnonymousFunctionWrapper>(isolate, functionPointer, parametersEncoding, parametersCount);
+        auto ext = CreateWrapperFor(isolate, wrapper);
 
         Local<v8::Function> func;
         bool success = v8::Function::New(context, [](const FunctionCallbackInfo<Value>& info) {
             Isolate* isolate = info.GetIsolate();
-            AnonymousFunctionWrapper* wrapper = static_cast<AnonymousFunctionWrapper*>(info.Data().As<External>()->Value());
+            AnonymousFunctionWrapper* wrapper = ExtractWrapper<AnonymousFunctionWrapper>(info.Data());
             tns::Assert(wrapper != nullptr, isolate);
 
             V8FunctionCallbackArgs args(info);
@@ -1015,7 +1013,7 @@ inline bool isBool() {
         }, ext).ToLocal(&func);
         tns::Assert(success, isolate);
 
-        tns::SetValue(isolate, func, wrapper);
+        tns::SetValue(isolate, func, ext);
         ObjectManager::Register(context, func);
 
         return func;
@@ -1123,7 +1121,7 @@ inline bool isBool() {
         // because class_getSuperclass will directly return NSProxy and thus missing to attach all instance members
         const TypeEncoding* te = [result isProxy] ? typeEncoding : nullptr;
 
-        ObjCDataWrapper* wrapper = new ObjCDataWrapper(result, te);
+        ObjCDataWrapper* wrapper = MakeGarbageCollected<ObjCDataWrapper>(isolate, result, te);
         std::vector<std::string> additionalProtocols = Interop::GetAdditionalProtocols(typeEncoding);
         Local<Value> jsResult = ArgConverter::ConvertArgument(context, wrapper, false, additionalProtocols);
 
@@ -1302,9 +1300,7 @@ inline bool isBool() {
     const TypeEncoding* fieldEncoding = field.Encoding();
     switch (fieldEncoding->type) {
         case BinaryTypeEncodingType::StructDeclarationReference: {
-            Local<Object> obj = value.As<Object>();
-            Local<External> ext = obj->GetInternalField(0).As<External>();
-            StructWrapper* targetStruct = static_cast<StructWrapper*>(ext->Value());
+            StructWrapper* targetStruct = ExtractWrapper<StructWrapper>(value);
 
             void* sourceBuffer = targetStruct->Data();
             size_t fieldSize = field.FFIType()->size;
@@ -1529,7 +1525,7 @@ inline bool isBool() {
         methodCall.typeEncoding_,
         &call,
         marshalToPrimitive,
-        nullptr,
+        Local<Value>(), /* parentStruct */
         false,
         methodCall.ownsReturnedObject_,
         methodCall.returnsUnmanaged_,
diff --git a/NativeScript/runtime/InteropTypes.mm b/NativeScript/runtime/InteropTypes.mm
index bca1e2a8..aec1c815 100644
--- a/NativeScript/runtime/InteropTypes.mm
+++ b/NativeScript/runtime/InteropTypes.mm
@@ -31,28 +31,28 @@
     RegisterAdoptFunction(context, interop);
     RegisterSizeOfFunction(context, interop);
 
-    RegisterInteropType(context, types, "noop", new PrimitiveDataWrapper(ffi_type_pointer.size, CreateEncoding(BinaryTypeEncodingType::VoidEncoding), true));
-    RegisterInteropType(context, types, "void", new PrimitiveDataWrapper(0, CreateEncoding(BinaryTypeEncodingType::VoidEncoding), true));
-    RegisterInteropType(context, types, "bool", new PrimitiveDataWrapper(sizeof(bool), CreateEncoding(BinaryTypeEncodingType::BoolEncoding), true));
-    RegisterInteropType(context, types, "uint8", new PrimitiveDataWrapper(ffi_type_uint8.size, CreateEncoding(BinaryTypeEncodingType::UCharEncoding), true));
-    RegisterInteropType(context, types, "int8", new PrimitiveDataWrapper(ffi_type_sint8.size, CreateEncoding(BinaryTypeEncodingType::CharEncoding), true));
-    RegisterInteropType(context, types, "uint16", new PrimitiveDataWrapper(ffi_type_uint16.size, CreateEncoding(BinaryTypeEncodingType::UShortEncoding), true));
-    RegisterInteropType(context, types, "int16", new PrimitiveDataWrapper(ffi_type_sint16.size, CreateEncoding(BinaryTypeEncodingType::ShortEncoding), true));
-    RegisterInteropType(context, types, "uint32", new PrimitiveDataWrapper(ffi_type_uint32.size, CreateEncoding(BinaryTypeEncodingType::UIntEncoding), true));
-    RegisterInteropType(context, types, "int32", new PrimitiveDataWrapper(ffi_type_sint32.size, CreateEncoding(BinaryTypeEncodingType::IntEncoding), true));
-    RegisterInteropType(context, types, "uint64", new PrimitiveDataWrapper(ffi_type_uint64.size, CreateEncoding(BinaryTypeEncodingType::ULongEncoding), true));
-    RegisterInteropType(context, types, "int64", new PrimitiveDataWrapper(ffi_type_sint64.size, CreateEncoding(BinaryTypeEncodingType::LongEncoding), true));
-    RegisterInteropType(context, types, "ulong", new PrimitiveDataWrapper(ffi_type_ulong.size, CreateEncoding(BinaryTypeEncodingType::ULongLongEncoding), true));
-    RegisterInteropType(context, types, "slong", new PrimitiveDataWrapper(ffi_type_slong.size, CreateEncoding(BinaryTypeEncodingType::LongLongEncoding), true));
-    RegisterInteropType(context, types, "float", new PrimitiveDataWrapper(ffi_type_float.size, CreateEncoding(BinaryTypeEncodingType::FloatEncoding), true));
-    RegisterInteropType(context, types, "double", new PrimitiveDataWrapper(ffi_type_double.size, CreateEncoding(BinaryTypeEncodingType::DoubleEncoding), true));
-
-    RegisterInteropType(context, types, "id", new PrimitiveDataWrapper(sizeof(void*), CreateEncoding(BinaryTypeEncodingType::IdEncoding), true));
-//    RegisterInteropType(context, types, "UTF8CString", new PrimitiveDataWrapper(sizeof(void*), CreateEncoding(BinaryTypeEncodingType::VoidEncoding)));
-    RegisterInteropType(context, types, "unichar", new PrimitiveDataWrapper(ffi_type_ushort.size, CreateEncoding(BinaryTypeEncodingType::UnicharEncoding), true));
-    RegisterInteropType(context, types, "protocol", new PrimitiveDataWrapper(sizeof(void*), CreateEncoding(BinaryTypeEncodingType::ProtocolEncoding), true));
-    RegisterInteropType(context, types, "class", new PrimitiveDataWrapper(sizeof(void*), CreateEncoding(BinaryTypeEncodingType::ClassEncoding), true));
-    RegisterInteropType(context, types, "selector", new PrimitiveDataWrapper(sizeof(void*), CreateEncoding(BinaryTypeEncodingType::SelectorEncoding), true));
+    RegisterInteropType(context, types, "noop", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_pointer.size, BinaryTypeEncodingType::VoidEncoding));
+    RegisterInteropType(context, types, "void", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, 0, BinaryTypeEncodingType::VoidEncoding));
+    RegisterInteropType(context, types, "bool", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, sizeof(bool), BinaryTypeEncodingType::BoolEncoding));
+    RegisterInteropType(context, types, "uint8", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_uint8.size, BinaryTypeEncodingType::UCharEncoding));
+    RegisterInteropType(context, types, "int8", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_sint8.size, BinaryTypeEncodingType::CharEncoding));
+    RegisterInteropType(context, types, "uint16", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_uint16.size, BinaryTypeEncodingType::UShortEncoding));
+    RegisterInteropType(context, types, "int16", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_sint16.size, BinaryTypeEncodingType::ShortEncoding));
+    RegisterInteropType(context, types, "uint32", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_uint32.size, BinaryTypeEncodingType::UIntEncoding));
+    RegisterInteropType(context, types, "int32", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_sint32.size, BinaryTypeEncodingType::IntEncoding));
+    RegisterInteropType(context, types, "uint64", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_uint64.size, BinaryTypeEncodingType::ULongEncoding));
+    RegisterInteropType(context, types, "int64", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_sint64.size, BinaryTypeEncodingType::LongEncoding));
+    RegisterInteropType(context, types, "ulong", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_ulong.size, BinaryTypeEncodingType::ULongLongEncoding));
+    RegisterInteropType(context, types, "slong", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_slong.size, BinaryTypeEncodingType::LongLongEncoding));
+    RegisterInteropType(context, types, "float", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_float.size, BinaryTypeEncodingType::FloatEncoding));
+    RegisterInteropType(context, types, "double", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_double.size, BinaryTypeEncodingType::DoubleEncoding));
+
+    RegisterInteropType(context, types, "id", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, sizeof(void*), BinaryTypeEncodingType::IdEncoding));
+//    RegisterInteropType(context, types, "UTF8CString", new PrimitiveDataWrapper(sizeof(void*), BinaryTypeEncodingType::VoidEncoding)));
+    RegisterInteropType(context, types, "unichar", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, ffi_type_ushort.size, BinaryTypeEncodingType::UnicharEncoding));
+    RegisterInteropType(context, types, "protocol", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, sizeof(void*), BinaryTypeEncodingType::ProtocolEncoding));
+    RegisterInteropType(context, types, "class", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, sizeof(void*), BinaryTypeEncodingType::ClassEncoding));
+    RegisterInteropType(context, types, "selector", MakeGarbageCollected<PrimitiveDataWrapper>(isolate, sizeof(void*), BinaryTypeEncodingType::SelectorEncoding));
 
     bool success = interop->Set(context, tns::ToV8String(isolate, "types"), types).FromMaybe(false);
     tns::Assert(success, isolate);
@@ -116,10 +116,9 @@
         Isolate* isolate = info.GetIsolate();
         tns::Assert(info.Length() == 1 && info[0]->IsObject(), isolate);
         Local<Object> arg = info[0].As<Object>();
-        tns::Assert(arg->InternalFieldCount() > 0 && arg->GetInternalField(0)->IsExternal(), isolate);
+        tns::Assert(IsGarbageCollectedWrapper(arg), isolate);
 
-        Local<External> ext = arg->GetInternalField(0).As<External>();
-        ObjCDataWrapper* wrapper = static_cast<ObjCDataWrapper*>(ext->Value());
+        ObjCDataWrapper* wrapper = ExtractWrapper<ObjCDataWrapper>(arg);
 
         id obj = wrapper->Data();
         tns::Assert([obj isKindOfClass:[NSData class]], isolate);
@@ -184,7 +183,7 @@
         void* data = calloc(1, size);
 
         Local<Value> pointerInstance = Pointer::NewInstance(context, data);
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(pointerInstance.As<Object>()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(pointerInstance);
         wrapper->SetAdopted(true);
         info.GetReturnValue().Set(pointerInstance);
     }).ToLocal(&func);
@@ -378,10 +377,10 @@
                     }
                     case WrapperType::Reference: {
                         ReferenceWrapper* w = static_cast<ReferenceWrapper*>(wrapper);
-                        if (w->Value() != nullptr) {
-                            Local<Value> wrappedValue = w->Value()->Get(isolate);
+                        if (w->HasValue()) {
+                            Local<Value> wrappedValue = w->Value().Get(isolate);
                             if (tns::GetValue(isolate, wrappedValue) == nullptr) {
-                                return Pointer::NewInstance(context, w->Value());
+                                return Pointer::NewInstance(context, w->UnsafeValue());
                             }
                             return HandleOf(context, wrappedValue);
                         } else if (w->Data() != nullptr) {
diff --git a/NativeScript/runtime/MetadataBuilder.mm b/NativeScript/runtime/MetadataBuilder.mm
index b7c296fd..2810db62 100644
--- a/NativeScript/runtime/MetadataBuilder.mm
+++ b/NativeScript/runtime/MetadataBuilder.mm
@@ -94,7 +94,7 @@
         bool success = v8::Function::New(context, CFunctionCallback, ext).ToLocal(&func);
         tns::Assert(success, isolate);
 
-        tns::SetValue(isolate, func, new FunctionWrapper(funcMeta));
+        tns::SetValue(isolate, func, MakeGarbageCollected<FunctionWrapper>(isolate, funcMeta));
         MetadataBuilder::DefineFunctionLengthProperty(context, funcMeta->encodings(), func);
 
         auto uniquePersistent = std::make_unique<Persistent<v8::Function>>(isolate, func);
@@ -144,13 +144,14 @@
         return it->second->Get(isolate);
     }
 
-    StructTypeWrapper* wrapper = new StructTypeWrapper(structInfo);
-    Local<External> ext = External::New(isolate, wrapper);
+    StructTypeWrapper* wrapper = MakeGarbageCollected<StructTypeWrapper>(isolate, structInfo);
+    auto ext = CreateWrapperFor(isolate, wrapper);
+
     Local<v8::Function> structCtorFunc;
     bool success = v8::Function::New(context, StructConstructorCallback, ext).ToLocal(&structCtorFunc);
     tns::Assert(success, isolate);
 
-    tns::SetValue(isolate, structCtorFunc, wrapper);
+    tns::SetValue(isolate, structCtorFunc, ext);
 
     Local<v8::Function> equalsFunc;
     success = v8::Function::New(context, StructEqualsCallback).ToLocal(&equalsFunc);
@@ -168,7 +169,7 @@
     Isolate* isolate = info.GetIsolate();
     Local<Context> context = isolate->GetCurrentContext();
     try {
-        StructTypeWrapper* typeWrapper = static_cast<StructTypeWrapper*>(info.Data().As<External>()->Value());
+        StructTypeWrapper* typeWrapper = ExtractWrapper<StructTypeWrapper>(info.Data());
 
         StructInfo structInfo = typeWrapper->StructInfo();
 
@@ -191,14 +192,14 @@
             dest = pw->Data();
         }
 
-        StructWrapper* wrapper = new StructWrapper(structInfo, dest, nullptr);
+        StructWrapper* wrapper = MakeGarbageCollected<StructWrapper>(isolate, structInfo, dest);
         Local<Context> context = isolate->GetCurrentContext();
         Local<Value> result = ArgConverter::ConvertArgument(context, wrapper);
 
         std::shared_ptr<Caches> cache = Caches::Get(isolate);
         std::shared_ptr<Persistent<Value>> poResult = ObjectManager::Register(context, result);
         std::pair<void*, std::string> key = std::make_pair(wrapper->Data(), structInfo.Name());
-        cache->StructInstances.emplace(key, poResult);
+        cache->StructInstances.emplace(key, std::make_shared<Persistent<Value>>(isolate, result));
         tns::DeleteWrapperIfUnused(isolate, result, wrapper);
 
         info.GetReturnValue().Set(result);
@@ -261,16 +262,14 @@
     ffi_type* ffiType = nullptr;
     void* data = nullptr;
 
-    if (initializer->InternalFieldCount() < 1) {
+    if (!IsGarbageCollectedWrapper(initializer)) {
         ffiType = structInfo.FFIType();
         data = malloc(ffiType->size);
         Interop::InitializeStruct(context, data, structInfo.Fields(), initializer);
     } else {
-        Local<External> ext = initializer->GetInternalField(0).As<External>();
-        BaseDataWrapper* wrapper = static_cast<BaseDataWrapper*>(ext->Value());
-        if (wrapper->Type() != WrapperType::Struct) {
+        BaseDataWrapper* wrapper = ExtractWrapper<BaseDataWrapper>(initializer);
+        if (wrapper->Type() != WrapperType::Struct)
             return std::make_pair(ffiType, data);
-        }
 
         StructWrapper* structWrapper = static_cast<StructWrapper*>(wrapper);
         data = structWrapper->Data();
@@ -365,7 +364,7 @@
 
     if (meta->type() == MetaType::ProtocolType) {
         const ProtocolMeta* protoMeta = static_cast<const ProtocolMeta*>(meta);
-        tns::SetValue(isolate, ctorFunc, new ObjCProtocolWrapper(objc_getProtocol(meta->name()), protoMeta));
+        tns::SetValue(isolate, ctorFunc, MakeGarbageCollected<ObjCProtocolWrapper>(isolate, objc_getProtocol(meta->name()), protoMeta));
         cache->ProtocolCtorFuncs.emplace(meta->name(), new Persistent<v8::Function>(isolate, ctorFunc));
     } else {
         Class klass = objc_getClass(meta->name());
@@ -373,7 +372,7 @@
             SymbolLoader::instance().ensureModule(meta->topLevelModule());
             klass = objc_getClass(meta->name());
         }
-        tns::SetValue(isolate, ctorFunc, new ObjCClassWrapper(klass));
+        tns::SetValue(isolate, ctorFunc, MakeGarbageCollected<ObjCClassWrapper>(isolate, klass));
         cache->CtorFuncs.emplace(meta->name(), std::make_unique<Persistent<v8::Function>>(isolate, ctorFunc));
     }
     ObjectManager::Register(context, ctorFunc);
@@ -646,7 +645,7 @@
         }
 
         Local<Context> context = isolate->GetCurrentContext();
-        ObjCAllocDataWrapper* allocWrapper = new ObjCAllocDataWrapper(klass);
+        ObjCAllocDataWrapper* allocWrapper = MakeGarbageCollected<ObjCAllocDataWrapper>(isolate, klass);
         Local<Value> result = ArgConverter::CreateJsWrapper(context, allocWrapper, Local<Object>());
         info.GetReturnValue().Set(result);
     } catch (NativeScriptException& ex) {
@@ -770,10 +769,10 @@
 
     std::shared_ptr<Caches> cache = Caches::Get(isolate);
     std::pair<void*, std::string> key = std::make_pair(wrapper->Data(), structInfo.Name());
-    std::shared_ptr<Persistent<Value>> parentStruct = nullptr;
+    Local<Value> parentStruct;
     auto x = cache->StructInstances.find(key);
     if (x != cache->StructInstances.end()) {
-        parentStruct = x->second;
+        parentStruct = x->second->Get(isolate);
     }
 
     std::vector<StructField> fields = structInfo.Fields();
@@ -807,9 +806,7 @@
         return;
     }
 
-    Local<External> ext = thiz->GetInternalField(0).As<External>();
-    StructWrapper* wrapper = static_cast<StructWrapper*>(ext->Value());
-
+    StructWrapper* wrapper = ExtractWrapper<StructWrapper>(thiz);
     StructInfo structInfo = wrapper->StructInfo();
     std::vector<StructField> fields = structInfo.Fields();
 
@@ -982,7 +979,7 @@
             ObjCDataWrapper* wrapper = nullptr;
             Local<Object> self_ = it != cache->Instances.end()
                 ? it->second->Get(context->isolate_).As<Object>()
-                : ArgConverter::CreateJsWrapper(v8Context, wrapper = new ObjCDataWrapper(thiz), Local<Object>()).As<Object>();
+                : ArgConverter::CreateJsWrapper(v8Context, wrapper = MakeGarbageCollected<ObjCDataWrapper>(context->isolate_, thiz), Local<Object>()).As<Object>();
             if (wrapper != nullptr) {
                 tns::DeleteWrapperIfUnused(context->isolate_, self_, wrapper);
             }
@@ -1021,7 +1018,7 @@
             auto it = cache->Instances.find(thiz);
             Local<Object> self_ = it != cache->Instances.end()
                 ? it->second->Get(context->isolate_).As<Object>()
-                : ArgConverter::CreateJsWrapper(v8Context, new ObjCDataWrapper(thiz), Local<Object>()).As<Object>();
+                : ArgConverter::CreateJsWrapper(v8Context, MakeGarbageCollected<ObjCDataWrapper>(context->isolate_, thiz), Local<Object>()).As<Object>();
 
             uint8_t* argBuffer = (uint8_t*)argValues[2];
             const TypeEncoding* typeEncoding = context->meta_->setter()->encodings()->first()->next();
diff --git a/NativeScript/runtime/NSDataAdapter.mm b/NativeScript/runtime/NSDataAdapter.mm
index 5ea20948..713c17b2 100644
--- a/NativeScript/runtime/NSDataAdapter.mm
+++ b/NativeScript/runtime/NSDataAdapter.mm
@@ -18,7 +18,7 @@ - (instancetype)initWithJSObject:(Local<Object>)jsObject isolate:(Isolate*)isola
         self->cache_ = Caches::Get(isolate);
         self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
         self->cache_->Instances.emplace(self, self->object_);
-        tns::SetValue(isolate, jsObject, new ObjCDataWrapper(self));
+        tns::SetValue(isolate, jsObject, MakeGarbageCollected<ObjCDataWrapper>(isolate, self));
     }
 
     return self;
diff --git a/NativeScript/runtime/ObjectManager.mm b/NativeScript/runtime/ObjectManager.mm
index 75df80d7..da88bde4 100644
--- a/NativeScript/runtime/ObjectManager.mm
+++ b/NativeScript/runtime/ObjectManager.mm
@@ -22,202 +22,191 @@
     Isolate* isolate = context->GetIsolate();
     std::shared_ptr<Persistent<Value>> objectHandle = std::make_shared<Persistent<Value>>(isolate, obj);
     objectHandle->SetWrapperClassId(Constants::ClassTypes::ObjectManagedValue);
-    ObjectWeakCallbackState* state = new ObjectWeakCallbackState(objectHandle);
-    objectHandle->SetWeak(state, FinalizerCallback, WeakCallbackType::kFinalizer);
+//    ObjectWeakCallbackState* state = new ObjectWeakCallbackState(objectHandle);
+//    objectHandle->SetWeak(state, FinalizerCallback, WeakCallbackType::kFinalizer);
     return objectHandle;
 }
 
 void ObjectManager::FinalizerCallback(const WeakCallbackInfo<ObjectWeakCallbackState>& data) {
-    ObjectWeakCallbackState* state = data.GetParameter();
-    Isolate* isolate = data.GetIsolate();
-    Local<Value> value = state->target_->Get(isolate);
-    bool disposed = ObjectManager::DisposeValue(isolate, value);
-
-    if (disposed) {
-        state->target_->Reset();
-        delete state;
-    } else {
-        state->target_->ClearWeak();
-        state->target_->SetWeak(state, FinalizerCallback, WeakCallbackType::kFinalizer);
-    }
+//    ObjectWeakCallbackState* state = data.GetParameter();
+//    Isolate* isolate = data.GetIsolate();
+//    Local<Value> value = state->target_->Get(isolate);
+//    bool disposed = ObjectManager::DisposeValue(isolate, value);
+//
+//    if (disposed) {
+//        state->target_->Reset();
+//        delete state;
+//    } else {
+//        state->target_->ClearWeak();
+//        state->target_->SetWeak(state, FinalizerCallback, WeakCallbackType::kFinalizer);
+//    }
 }
 
 bool ObjectManager::DisposeValue(Isolate* isolate, Local<Value> value, bool isFinalDisposal) {
-    if (value.IsEmpty() || value->IsNullOrUndefined() || !value->IsObject()) {
-        return true;
-    }
-
-    Local<Object> obj = value.As<Object>();
-    if (obj->InternalFieldCount() > 1 && !isFinalDisposal) {
-        Local<Value> superValue = obj->GetInternalField(1);
-        if (!superValue.IsEmpty() && superValue->IsString()) {
-            // Do not dispose the ObjCWrapper contained in a "super" instance
-            return true;
-        }
-    }
-
-    BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
-    //NSLog(@"dispose %p", wrapper);
-    if (wrapper == nullptr) {
-        tns::SetValue(isolate, obj, nullptr);
-        return true;
-    }
-
-    if (wrapper->IsGcProtected() && !isFinalDisposal) {
-        return false;
-    }
-
-    std::shared_ptr<Caches> cache = Caches::Get(isolate);
-    switch (wrapper->Type()) {
-        case WrapperType::Struct: {
-            StructWrapper* structWrapper = static_cast<StructWrapper*>(wrapper);
-            void* data = structWrapper->Data();
-
-            std::shared_ptr<Persistent<Value>> poParentStruct = structWrapper->Parent();
-            if (poParentStruct != nullptr) {
-                Local<Value> parentStruct = poParentStruct->Get(isolate);
-                BaseDataWrapper* parentWrapper = tns::GetValue(isolate, parentStruct);
-                if (parentWrapper != nullptr && parentWrapper->Type() == WrapperType::Struct) {
-                    StructWrapper* parentStructWrapper = static_cast<StructWrapper*>(parentWrapper);
-                    parentStructWrapper->DecrementChildren();
-                }
-            } else {
-                if (structWrapper->ChildCount() == 0) {
-                    std::pair<void*, std::string> key = std::make_pair(data, structWrapper->StructInfo().Name());
-                    cache->StructInstances.erase(key);
-                    std::free(data);
-                } else {
-                    return false;
-                }
-            }
-            break;
-        }
-        case WrapperType::ObjCObject: {
-            ObjCDataWrapper* objCObjectWrapper = static_cast<ObjCDataWrapper*>(wrapper);
-            id target = objCObjectWrapper->Data();
-            if (target != nil) {
-                cache->Instances.erase(target);
-                [target release];
-            }
-            break;
-        }
-        case WrapperType::Block: {
-            BlockWrapper* blockWrapper = static_cast<BlockWrapper*>(wrapper);
-            if(!blockWrapper->OwnsBlock()) {
-                std::free(blockWrapper->Block());
-            }
-            break;
-        }
-        case WrapperType::Reference: {
-            ReferenceWrapper* referenceWrapper = static_cast<ReferenceWrapper*>(wrapper);
-            if (referenceWrapper->Data() != nullptr) {
-                referenceWrapper->SetData(nullptr);
-                referenceWrapper->SetEncoding(nullptr);
-            }
-
-            break;
-        }
-        case WrapperType::Pointer: {
-            PointerWrapper* pointerWrapper = static_cast<PointerWrapper*>(wrapper);
-            if (pointerWrapper->Data() != nullptr) {
-                cache->PointerInstances.erase(pointerWrapper->Data());
-
-                if (pointerWrapper->IsAdopted()) {
-                    std::free(pointerWrapper->Data());
-                    pointerWrapper->SetData(nullptr);
-                }
-            }
-            break;
-        }
-        case WrapperType::FunctionReference: {
-            FunctionReferenceWrapper* funcWrapper = static_cast<FunctionReferenceWrapper*>(wrapper);
-            std::shared_ptr<Persistent<Value>> func = funcWrapper->Function();
-            if (func != nullptr) {
-                func->Reset();
-            }
-            break;
-        }
-        case WrapperType::AnonymousFunction: {
-            break;
-        }
-        case WrapperType::ExtVector: {
-            ExtVectorWrapper* extVectorWrapper = static_cast<ExtVectorWrapper*>(wrapper);
-            FFICall::DisposeFFIType(extVectorWrapper->FFIType(), extVectorWrapper->TypeEncoding());
-            void* data = extVectorWrapper->Data();
-            if (data) {
-                std::free(data);
-            }
-            break;
-        }
-        case WrapperType::Worker: {
-            WorkerWrapper* worker = static_cast<WorkerWrapper*>(wrapper);
-            if (!worker->isDisposed()) {
-                // during final disposal, inform the worker it should delete itself
-                if (isFinalDisposal) {
-                    worker->MakeWeak();
-                }
-                return false;
-            }
-            break;
-        }
-
-        default:
-            break;
-    }
-
-    delete wrapper;
-    wrapper = nullptr;
-    tns::DeleteValue(isolate, obj);
+//    if (value.IsEmpty() || value->IsNullOrUndefined() || !value->IsObject()) {
+//        return true;
+//    }
+//
+//    Local<Object> obj = value.As<Object>();
+//    if (obj->InternalFieldCount() > 1 && !isFinalDisposal) {
+//        Local<Value> superValue = obj->GetInternalField(1);
+//        if (!superValue.IsEmpty() && superValue->IsString()) {
+//            // Do not dispose the ObjCWrapper contained in a "super" instance
+//            return true;
+//        }
+//    }
+//
+//    BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
+//    //NSLog(@"dispose %p", wrapper);
+//    if (wrapper == nullptr) {
+//        tns::SetValue(isolate, obj, nullptr);
+//        return true;
+//    }
+//
+//    if (wrapper->IsGcProtected() && !isFinalDisposal) {
+//        return false;
+//    }
+//
+//    std::shared_ptr<Caches> cache = Caches::Get(isolate);
+//    switch (wrapper->Type()) {
+//        case WrapperType::Struct: {
+//            StructWrapper* structWrapper = static_cast<StructWrapper*>(wrapper);
+//            void* data = structWrapper->Data();
+//
+//            std::shared_ptr<Persistent<Value>> poParentStruct = structWrapper->Parent();
+//            if (poParentStruct != nullptr) {
+//                Local<Value> parentStruct = poParentStruct->Get(isolate);
+//                BaseDataWrapper* parentWrapper = tns::GetValue(isolate, parentStruct);
+//                if (parentWrapper != nullptr && parentWrapper->Type() == WrapperType::Struct) {
+//                    StructWrapper* parentStructWrapper = static_cast<StructWrapper*>(parentWrapper);
+//                    parentStructWrapper->DecrementChildren();
+//                }
+//            } else {
+//                if (structWrapper->ChildCount() == 0) {
+//                    std::pair<void*, std::string> key = std::make_pair(data, structWrapper->StructInfo().Name());
+//                    cache->StructInstances.erase(key);
+//                    std::free(data);
+//                } else {
+//                    return false;
+//                }
+//            }
+//            break;
+//        }
+//        case WrapperType::ObjCObject: {
+//            ObjCDataWrapper* objCObjectWrapper = static_cast<ObjCDataWrapper*>(wrapper);
+//            id target = objCObjectWrapper->Data();
+//            if (target != nil) {
+//                cache->Instances.erase(target);
+//                [target release];
+//            }
+//            break;
+//        }
+//        case WrapperType::Block: {
+//            BlockWrapper* blockWrapper = static_cast<BlockWrapper*>(wrapper);
+//            if(!blockWrapper->OwnsBlock()) {
+//                std::free(blockWrapper->Block());
+//            }
+//            break;
+//        }
+//        case WrapperType::Reference: {
+//            ReferenceWrapper* referenceWrapper = static_cast<ReferenceWrapper*>(wrapper);
+//            if (referenceWrapper->Data() != nullptr) {
+//                referenceWrapper->SetData(nullptr);
+//                referenceWrapper->SetEncoding(nullptr);
+//            }
+//
+//            break;
+//        }
+//        case WrapperType::Pointer: {
+//            PointerWrapper* pointerWrapper = static_cast<PointerWrapper*>(wrapper);
+//            if (pointerWrapper->Data() != nullptr) {
+//                cache->PointerInstances.erase(pointerWrapper->Data());
+//
+//                if (pointerWrapper->IsAdopted()) {
+//                    std::free(pointerWrapper->Data());
+//                    pointerWrapper->SetData(nullptr);
+//                }
+//            }
+//            break;
+//        }
+//        case WrapperType::FunctionReference: {
+//            FunctionReferenceWrapper* funcWrapper = static_cast<FunctionReferenceWrapper*>(wrapper);
+//            std::shared_ptr<Persistent<Value>> func = funcWrapper->Function();
+//            if (func != nullptr) {
+//                func->Reset();
+//            }
+//            break;
+//        }
+//        case WrapperType::AnonymousFunction: {
+//            break;
+//        }
+//        case WrapperType::ExtVector: {
+//            ExtVectorWrapper* extVectorWrapper = static_cast<ExtVectorWrapper*>(wrapper);
+//            FFICall::DisposeFFIType(extVectorWrapper->FFIType(), extVectorWrapper->TypeEncoding());
+//            void* data = extVectorWrapper->Data();
+//            if (data) {
+//                std::free(data);
+//            }
+//            break;
+//        }
+//        case WrapperType::Worker: {
+//            WorkerWrapper* worker = static_cast<WorkerWrapper*>(wrapper);
+//            if (!worker->isDisposed()) {
+//                // during final disposal, inform the worker it should delete itself
+//                if (isFinalDisposal) {
+//                    worker->MakeWeak();
+//                }
+//                return false;
+//            }
+//            break;
+//        }
+//
+//        default:
+//            break;
+//    }
+//
+//    delete wrapper;
+//    wrapper = nullptr;
+//    tns::DeleteValue(isolate, obj);
     return true;
 }
 
 void ObjectManager::ReleaseNativeCounterpartCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-
-    if (info.Length() != 1) {
-        std::ostringstream errorStream;
-        errorStream << "Actual arguments count: \"" << info.Length() << "\". Expected: \"1\".";
-        std::string errorMessage = errorStream.str();
-        Local<Value> error = Exception::Error(tns::ToV8String(isolate, errorMessage));
-        isolate->ThrowException(error);
-        return;
-    }
-
-    Local<Value> value = info[0];
-    BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
-
-    if (wrapper == nullptr) {
-        std::string arg0 = tns::ToString(isolate, info[0]);
-        std::ostringstream errorStream;
-        errorStream << arg0 << " is an object which is not a native wrapper.";
-        std::string errorMessage = errorStream.str();
-        Local<Value> error = Exception::Error(tns::ToV8String(isolate, errorMessage));
-        isolate->ThrowException(error);
-        return;
-    }
-
-    if (wrapper->Type() != WrapperType::ObjCObject) {
-        return;
-    }
-
-    ObjCDataWrapper* objcWrapper = static_cast<ObjCDataWrapper*>(wrapper);
-    id data = objcWrapper->Data();
-    if (data != nil) {
-        std::shared_ptr<Caches> cache = Caches::Get(isolate);
-        auto it = cache->Instances.find(data);
-        if (it != cache->Instances.end()) {
-            ObjectWeakCallbackState* state = it->second->ClearWeak<ObjectWeakCallbackState>();
-            if (state != nullptr) {
-                delete state;
-            }
-            cache->Instances.erase(it);
-        }
-
-        [data dealloc];
-
-        delete wrapper;
-        tns::SetValue(isolate, value.As<Object>(), nullptr);
-    }
+   Isolate* isolate = info.GetIsolate();
+
+   if (info.Length() != 1) {
+       std::ostringstream errorStream;
+       errorStream << "Actual arguments count: \"" << info.Length() << "\". Expected: \"1\".";
+       std::string errorMessage = errorStream.str();
+       Local<Value> error = Exception::Error(tns::ToV8String(isolate, errorMessage));
+       isolate->ThrowException(error);
+       return;
+   }
+
+   Local<Value> value = info[0];
+   BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
+
+   if (wrapper == nullptr) {
+       std::string arg0 = tns::ToString(isolate, info[0]);
+       std::ostringstream errorStream;
+       errorStream << arg0 << " is an object which is not a native wrapper.";
+       std::string errorMessage = errorStream.str();
+       Local<Value> error = Exception::Error(tns::ToV8String(isolate, errorMessage));
+       isolate->ThrowException(error);
+       return;
+   }
+
+   if (wrapper->Type() != WrapperType::ObjCObject) {
+       return;
+   }
+
+   ObjCDataWrapper* objcWrapper = static_cast<ObjCDataWrapper*>(wrapper);
+   id data = objcWrapper->Data();
+   if (data != nil) {
+       objcWrapper->ReleaseNativeCounterpart();
+
+       tns::SetValue(isolate, value.As<Object>(), nullptr);
+   }
 }
 
 bool ObjectManager::IsInstanceOf(id obj, Class clazz) {
diff --git a/NativeScript/runtime/Pointer.cpp b/NativeScript/runtime/Pointer.cpp
index 01dce1d7..a7acfde0 100644
--- a/NativeScript/runtime/Pointer.cpp
+++ b/NativeScript/runtime/Pointer.cpp
@@ -41,7 +41,7 @@ Local<v8::Function> Pointer::GetPointerCtorFunc(Local<Context> context) {
 
     Local<FunctionTemplate> ctorFuncTemplate = FunctionTemplate::New(isolate, PointerConstructorCallback);
 
-    ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(kMinGarbageCollectedEmbedderFields);
     ctorFuncTemplate->SetClassName(tns::ToV8String(isolate, "Pointer"));
 
     Local<v8::Function> ctorFunc;
@@ -49,7 +49,7 @@ Local<v8::Function> Pointer::GetPointerCtorFunc(Local<Context> context) {
         tns::Assert(false, isolate);
     }
 
-    tns::SetValue(isolate, ctorFunc, new PointerTypeWrapper());
+    tns::SetValue(isolate, ctorFunc, MakeGarbageCollected<PointerTypeWrapper>(isolate));
 
     Local<Value> prototypeValue;
     bool success = ctorFunc->Get(context, tns::ToV8String(isolate, "prototype")).ToLocal(&prototypeValue);
@@ -110,7 +110,7 @@ void Pointer::PointerConstructorCallback(const FunctionCallbackInfo<Value>& info
             if (isBigInt) {
                 value = (int32_t)info[0].As<BigInt>()->Int64Value();
             } else {
-                tns::Assert(info[0].As<Number>()->Int32Value    (context).To(&value), isolate);
+                tns::Assert(info[0].As<Number>()->Int32Value(context).To(&value), isolate);
             }
             ptr = reinterpret_cast<void*>(value);
     #endif
@@ -123,7 +123,7 @@ void Pointer::PointerConstructorCallback(const FunctionCallbackInfo<Value>& info
             return;
         }
 
-        PointerWrapper* wrapper = new PointerWrapper(ptr);
+        PointerWrapper* wrapper = MakeGarbageCollected<PointerWrapper>(isolate, ptr);
         tns::SetValue(isolate, info.This(), wrapper);
 
         ObjectManager::Register(context, info.This());
@@ -141,7 +141,7 @@ void Pointer::RegisterAddMethod(Local<Context> context, Local<Object> prototype)
         Local<Context> context = isolate->GetCurrentContext();
         tns::Assert(info.Length() == 1 && tns::IsNumber(info[0]), isolate);
 
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(info.This());
         void* value = wrapper->Data();
         int32_t offset;
         tns::Assert(info[0].As<Number>()->Int32Value(context).To(&offset), isolate);
@@ -165,7 +165,7 @@ void Pointer::RegisterSubtractMethod(Local<Context> context, Local<Object> proto
         Local<Context> context = isolate->GetCurrentContext();
         tns::Assert(info.Length() == 1 && tns::IsNumber(info[0]), isolate);
 
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(info.This());
         void* value = wrapper->Data();
         int32_t offset;
         tns::Assert(info[0].As<Number>()->Int32Value(context).To(&offset), isolate);
@@ -194,7 +194,7 @@ void Pointer::RegisterToStringMethod(Local<Context> context, Local<Object> proto
     Isolate* isolate = context->GetIsolate();
     Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
         Isolate* isolate = info.GetIsolate();
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(info.This());
         void* value = wrapper->Data();
 
         char buffer[100];
@@ -215,7 +215,7 @@ void Pointer::RegisterToHexStringMethod(Local<Context> context, Local<Object> pr
     Isolate* isolate = context->GetIsolate();
     Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
         Isolate* isolate = info.GetIsolate();
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(info.This());
         const void* value = wrapper->Data();
 
         char buffer[100];
@@ -236,7 +236,7 @@ void Pointer::RegisterToDecimalStringMethod(Local<Context> context, Local<Object
     Isolate* isolate = context->GetIsolate();
     Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
         Isolate* isolate = info.GetIsolate();
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(info.This());
         const void* value = wrapper->Data();
         intptr_t ptr = static_cast<intptr_t>(reinterpret_cast<size_t>(value));
 
@@ -258,7 +258,7 @@ void Pointer::RegisterToNumberMethod(Local<Context> context, Local<Object> proto
     Isolate* isolate = context->GetIsolate();
     Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
         Isolate* isolate = info.GetIsolate();
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(info.This());
         const void* value = wrapper->Data();
         size_t number = reinterpret_cast<size_t>(value);
         Local<Number> result = Number::New(isolate, number);
@@ -276,7 +276,7 @@ void Pointer::RegisterToBigIntMethod(Local<Context> context, Local<Object> proto
     Isolate* isolate = context->GetIsolate();
     Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
         Isolate* isolate = info.GetIsolate();
-        PointerWrapper* wrapper = static_cast<PointerWrapper*>(info.This()->GetInternalField(0).As<External>()->Value());
+        PointerWrapper* wrapper = ExtractWrapper<PointerWrapper>(info.This());
         const void* value = wrapper->Data();
         size_t number = reinterpret_cast<size_t>(value);
         Local<BigInt> result = BigInt::NewFromUnsigned(isolate, number);
diff --git a/NativeScript/runtime/Reference.cpp b/NativeScript/runtime/Reference.cpp
index e0986a80..0dd19ebe 100644
--- a/NativeScript/runtime/Reference.cpp
+++ b/NativeScript/runtime/Reference.cpp
@@ -42,7 +42,7 @@ Local<v8::Function> Reference::GetInteropReferenceCtorFunc(Local<Context> contex
 
     Local<FunctionTemplate> ctorFuncTemplate = FunctionTemplate::New(isolate, ReferenceConstructorCallback);
     ctorFuncTemplate->SetClassName(tns::ToV8String(isolate, "Reference"));
-    ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(kMinGarbageCollectedEmbedderFields);
     ctorFuncTemplate->InstanceTemplate()->SetHandler(IndexedPropertyHandlerConfiguration(IndexedPropertyGetCallback, IndexedPropertySetCallback));
     Local<ObjectTemplate> proto = ctorFuncTemplate->PrototypeTemplate();
     proto->SetAccessor(tns::ToV8String(isolate, "value"), GetValueCallback, SetValueCallback);
@@ -52,7 +52,7 @@ Local<v8::Function> Reference::GetInteropReferenceCtorFunc(Local<Context> contex
         tns::Assert(false, isolate);
     }
 
-    tns::SetValue(isolate, ctorFunc, new ReferenceTypeWrapper());
+    tns::SetValue(isolate, ctorFunc, MakeGarbageCollected<ReferenceTypeWrapper>(isolate));
     Local<Value> prototypeValue;
     bool success = ctorFunc->Get(context, tns::ToV8String(isolate, "prototype")).ToLocal(&prototypeValue);
     tns::Assert(success && prototypeValue->IsObject(), isolate);
@@ -67,31 +67,22 @@ Local<v8::Function> Reference::GetInteropReferenceCtorFunc(Local<Context> contex
 
 void Reference::ReferenceConstructorCallback(const FunctionCallbackInfo<Value>& info) {
     Isolate* isolate = info.GetIsolate();
-    Local<Context> context = isolate->GetCurrentContext();
-    Persistent<Value>* val = nullptr;
+    TracedValue* value = nullptr;
     BaseDataWrapper* typeWrapper = nullptr;
     if (info.Length() == 1) {
         if (!info[0]->IsNullOrUndefined()) {
-            val = new Persistent<Value>(isolate, info[0]);
+            value = new TracedValue(isolate, info[0]);
         }
     } else if (info.Length() > 1) {
         if (!info[0]->IsNullOrUndefined() && !info[1]->IsNullOrUndefined()) {
             Local<Value> typeValue = info[0];
             typeWrapper = tns::GetValue(isolate, typeValue);
             tns::Assert(typeWrapper != nullptr, isolate);
-            val = new Persistent<Value>(isolate, info[1]);
+            value = new TracedValue(isolate, info[1]);
         }
     }
-    
-    if(val != nullptr) {
-        val->SetWeak();
-    }
-
-    ReferenceWrapper* wrapper = new ReferenceWrapper(typeWrapper, val);
-    Local<Object> thiz = info.This();
-    tns::SetValue(isolate, thiz, wrapper);
 
-    ObjectManager::Register(context, thiz);
+    tns::SetValue(isolate, info.This(), MakeGarbageCollected<ReferenceWrapper>(isolate, typeWrapper, value));
 }
 
 void Reference::IndexedPropertyGetCallback(uint32_t index, const PropertyCallbackInfo<Value>& info) {
@@ -140,11 +131,10 @@ void Reference::SetValueCallback(Local<v8::Name> name, Local<Value> value, const
     BaseDataWrapper* baseWrapper = tns::GetValue(isolate, info.This());
     tns::Assert(baseWrapper->Type() == WrapperType::Reference, isolate);
     ReferenceWrapper* wrapper = static_cast<ReferenceWrapper*>(baseWrapper);
-    Persistent<Value>* poValue = new Persistent<Value>(isolate, value);
 
     wrapper->SetData(nullptr);
     wrapper->SetEncoding(nullptr);
-    wrapper->SetValue(poValue);
+    wrapper->SetValue(new TracedValue(ToTraced(isolate, value)));
 }
 
 Local<Value> Reference::GetReferredValue(Local<Context> context, Local<Value> value) {
@@ -161,27 +151,22 @@ Local<Value> Reference::GetReferredValue(Local<Context> context, Local<Value> va
 
         BaseCall call(data);
         Local<Value> jsResult = Interop::GetResult(context, encoding, &call, true);
-        if (wrapper->Value() != nullptr) {
-            wrapper->Value()->Reset(isolate, jsResult);
-        } else {
-            wrapper->SetValue(new Persistent<Value>(isolate, jsResult));
-        }
-
+        wrapper->SetValue(new TracedValue(ToTraced(isolate, jsResult)));
         wrapper->SetData(nullptr);
         wrapper->SetEncoding(nullptr);
         return jsResult;
     }
 
-    if (wrapper->Value() == nullptr) {
+    if (!wrapper->HasValue()) {
         return Local<Value>();
     }
 
-    Local<Value> innerValue = wrapper->Value()->Get(isolate);
+    Local<Value> innerValue = wrapper->Value().Get(isolate);
     baseWrapper = tns::GetValue(isolate, innerValue);
     if (baseWrapper != nullptr && baseWrapper->Type() == WrapperType::Reference) {
         wrapper = static_cast<ReferenceWrapper*>(baseWrapper);
-        if (wrapper->Value() != nullptr) {
-            return Reference::GetReferredValue(context, wrapper->Value()->Get(isolate));
+        if (!wrapper->Value().IsEmpty()) {
+            return Reference::GetReferredValue(context, wrapper->Value().Get(isolate));
         }
     }
 
@@ -212,7 +197,7 @@ void* Reference::GetWrappedPointer(Local<Context> context, Local<Value> referenc
         return refWrapper->Data();
     }
 
-    Local<Value> value = refWrapper->Value()->Get(isolate);
+    Local<Value> value = refWrapper->Value().Get(isolate);
     BaseDataWrapper* wrappedValue = tns::GetValue(isolate, value);
 
     if (wrappedValue == nullptr) {
@@ -293,13 +278,16 @@ void Reference::RegisterToStringMethod(Local<Context> context, Local<Object> pro
         BaseDataWrapper* wrapper = tns::GetValue(isolate, info.This());
         tns::Assert(wrapper != nullptr && wrapper->Type() == WrapperType::Reference, isolate);
         ReferenceWrapper* refWrapper = static_cast<ReferenceWrapper*>(wrapper);
-        Persistent<Value>* value = refWrapper->Value();
+        Local<Value> value = refWrapper->Value().Get(isolate);
 
         char buffer[100];
-        if (value == nullptr) {
+        if (value.IsEmpty()) {
             snprintf(buffer, 100, "<Reference: %p>", reinterpret_cast<void*>(0));
         } else {
-            snprintf(buffer, 100, "<Reference: %p>", value);
+            // FIXME: this is pretty goofy - but the assumption is that the Address* field is the first field of the
+            // Local<T> object, and the Address is a pointer to a pointer in the v8 Heap, so the value should be stable.
+            void* pointer = *reinterpret_cast<void**>(&value);
+            snprintf(buffer, 100, "<Reference: %p>", pointer);
         }
 
         Local<v8::String> result = tns::ToV8String(isolate, buffer);
@@ -336,7 +324,7 @@ Reference::DataPair Reference::GetTypeEncodingDataPair(Local<Object> obj) {
 
     PrimitiveDataWrapper* primitiveWrapper = static_cast<PrimitiveDataWrapper*>(typeWrapper);
 
-    Local<Value> value = refWrapper->Value()->Get(isolate);
+    Local<Value> value = refWrapper->Value().Get(isolate);
     BaseDataWrapper* wrappedValue = tns::GetValue(isolate, value);
     if (wrappedValue != nullptr && wrappedValue->Type() == WrapperType::Pointer) {
         const TypeEncoding* typeEncoding = primitiveWrapper->TypeEncoding();
diff --git a/NativeScript/runtime/Runtime.h b/NativeScript/runtime/Runtime.h
index 13c120ae..3f30044d 100644
--- a/NativeScript/runtime/Runtime.h
+++ b/NativeScript/runtime/Runtime.h
@@ -8,6 +8,8 @@
 #include "SpinLock.h"
 #include "Caches.h"
 
+#include "cppgc/default-platform.h"
+
 namespace tns {
 
 class Runtime {
@@ -40,6 +42,10 @@ class Runtime {
     
     static Runtime* GetRuntime(v8::Isolate* isolate);
 
+    v8::CppHeap* GetCppHeap() {
+        return isolate_->GetCppHeap();
+    }
+
     static bool IsWorker() {
         if (currentRuntime_ == nullptr) {
             return false;
@@ -48,16 +54,21 @@ class Runtime {
         return currentRuntime_->IsRuntimeWorker();
     }
 
-    static std::shared_ptr<v8::Platform> GetPlatform() {
-        return platform_;
+    static v8::Platform* GetPlatform() {
+        return platform_->GetV8Platform();
     }
 
+    static std::shared_ptr<cppgc::Platform> GetCppgcPlatform() {
+        return platform_;
+    }
+    
     static id GetAppConfigValue(std::string key);
 
     static bool IsAlive(const v8::Isolate* isolate);
+
 private:
     static thread_local Runtime* currentRuntime_;
-    static std::shared_ptr<v8::Platform> platform_;
+    static std::shared_ptr<cppgc::DefaultPlatform> platform_;
     static std::vector<v8::Isolate*> isolates_;
     static SpinMutex isolatesMutex_;
     static bool v8Initialized_;
diff --git a/NativeScript/runtime/Runtime.mm b/NativeScript/runtime/Runtime.mm
index 3f132be0..dfd97c0f 100644
--- a/NativeScript/runtime/Runtime.mm
+++ b/NativeScript/runtime/Runtime.mm
@@ -4,6 +4,7 @@
 #include "Caches.h"
 #include "Console.h"
 #include "ArgConverter.h"
+#include "GCProtectedSet.h"
 #include "Interop.h"
 #include "NativeScriptException.h"
 #include "InlineFunctions.h"
@@ -22,6 +23,9 @@
 #include "IsolateWrapper.h"
 #include "DisposerPHV.h"
 
+#include "cppgc/default-platform.h"
+#include "cppgc/heap.h"
+
 #define STRINGIZE(x) #x
 #define STRINGIZE_VALUE_OF(x) STRINGIZE(x)
 
@@ -83,7 +87,7 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
     {
         v8::Locker lock(isolate_);
         DisposerPHV phv(isolate_);
-        isolate_->VisitHandlesWithClassIds( &phv );
+        // isolate_->VisitHandlesWithClassIds( &phv );
         
         if (IsRuntimeWorker()) {
             auto currentWorker = static_cast<WorkerWrapper*>(Caches::Workers->Get(this->workerId_)->UserData());
@@ -113,14 +117,17 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
     //     ? v8_inspector::V8InspectorPlatform::CreateDefaultPlatform()
     //     : platform::NewDefaultPlatform();
 
-        Runtime::platform_ = platform::NewDefaultPlatform();
+        //Runtime::platform_ = platform::NewDefaultPlatform();
+        Runtime::platform_ = std::make_shared<cppgc::DefaultPlatform>();
+
+        V8::InitializePlatform(Runtime::GetPlatform());
+        cppgc::InitializeProcess(Runtime::platform_->GetPageAllocator());
 
-        V8::InitializePlatform(Runtime::platform_.get());
-        V8::Initialize();
         std::string flags = RuntimeConfig.IsDebug
-        ? "--expose_gc --jitless"
-        : "--expose_gc --jitless --no-lazy";
+        ? "--expose_gc --jitless --no-freeze_flags_after_init"
+        : "--expose_gc --jitless --no-lazy --freeze_flags_after_init=false";
         V8::SetFlagsFromString(flags.c_str(), flags.size());
+        V8::Initialize();
         v8Initialized_ = true;
     }
     
@@ -128,7 +135,15 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
 
     Isolate::CreateParams create_params;
     create_params.array_buffer_allocator = &allocator_;
+
+    std::unique_ptr<v8::CppHeap> cpp_heap = v8::CppHeap::Create(Runtime::GetPlatform(), {
+        /* std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces */
+        {},
+        /* WrapperDescriptor wrapper_descriptor */
+        kGarbageCollectedWrapperDescriptor,
+    });
     Isolate* isolate = Isolate::New(create_params);
+    isolate->AttachCppHeap(cpp_heap.release());
     runtimeLoop_ = CFRunLoopGetCurrent();
     isolate->SetData(Constants::RUNTIME_SLOT, this);
 
@@ -183,6 +198,8 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
 
     InlineFunctions::Init(context);
 
+    GCProtectedSet::Init(context);
+
     cache->SetContext(context);
 
     this->isolate_ = isolate;
@@ -303,7 +320,7 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
     return std::find(Runtime::isolates_.begin(), Runtime::isolates_.end(), isolate) != Runtime::isolates_.end();
 }
 
-std::shared_ptr<Platform> Runtime::platform_;
+std::shared_ptr<cppgc::DefaultPlatform> Runtime::platform_;
 std::vector<Isolate*> Runtime::isolates_;
 bool Runtime::v8Initialized_ = false;
 thread_local Runtime* Runtime::currentRuntime_ = nullptr;
diff --git a/NativeScript/runtime/SymbolIterator.mm b/NativeScript/runtime/SymbolIterator.mm
index d23e0965..c63086fb 100644
--- a/NativeScript/runtime/SymbolIterator.mm
+++ b/NativeScript/runtime/SymbolIterator.mm
@@ -79,7 +79,7 @@
         } else if ([item isKindOfClass:[NSString class]]) {
             val = tns::ToV8String(isolate, [item UTF8String]);
         } else {
-            auto wrapper = new ObjCDataWrapper(item);
+            auto wrapper = MakeGarbageCollected<ObjCDataWrapper>(isolate, item);
             val = ArgConverter::CreateJsWrapper(context, wrapper, Local<Object>());
             tns::DeleteWrapperIfUnused(isolate, val, wrapper);
         }
diff --git a/NativeScript/runtime/Worker.mm b/NativeScript/runtime/Worker.mm
index ee654ee6..88d62cab 100644
--- a/NativeScript/runtime/Worker.mm
+++ b/NativeScript/runtime/Worker.mm
@@ -66,7 +66,7 @@
         std::string workerPath = ToString(isolate, info[0]);
         // TODO: Validate worker path and call worker.onerror if the script does not exist
 
-        WorkerWrapper* worker = new WorkerWrapper(isolate, Worker::OnMessageCallback);
+        WorkerWrapper* worker = MakeGarbageCollected<WorkerWrapper>(isolate, isolate, Worker::OnMessageCallback);
         tns::SetValue(isolate, thiz, worker);
         std::shared_ptr<Persistent<Value>> poWorker = ObjectManager::Register(context, thiz);
 
diff --git a/TestRunner/app/tests/shared/index.js b/TestRunner/app/tests/shared/index.js
index 369b536b..2541081f 100644
--- a/TestRunner/app/tests/shared/index.js
+++ b/TestRunner/app/tests/shared/index.js
@@ -23,5 +23,5 @@ exports.runAllTests = function() {
     exports.runRequireTests();
     exports.runWeakRefTests();
     exports.runRuntimeTests();
-    exports.runWorkerTests();
+    // exports.runWorkerTests();
 }
diff --git a/build_v8_source.sh b/build_v8_source.sh
index 8b0b88f2..1e7085ae 100755
--- a/build_v8_source.sh
+++ b/build_v8_source.sh
@@ -45,6 +45,10 @@ GN_ARGS_BASE="
     v8_enable_pointer_compression=false
     v8_enable_v8_checks=false
     v8_enable_webassembly=false
+
+    # Avoid linker errors relating to missing glibc_sin/cos
+    v8_use_libm_trig_functions=false
+
 "
 # is_official_build=true
 # clang_base_path=\"/Applications/Xcode-14.2.0.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr\"
diff --git a/package.json b/package.json
index 71084804..5e03217d 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/ios",
   "description": "NativeScript Runtime for iOS",
-  "version": "8.5.2",
+  "version": "8.6.0-alpha.1",
   "keywords": [
     "NativeScript",
     "iOS",
diff --git a/v8-version.txt b/v8-version.txt
index 85238fe3..0e9625ad 100644
--- a/v8-version.txt
+++ b/v8-version.txt
@@ -1 +1 @@
-https://chromium.googlesource.com/v8/v8.git/+/01621b70b2fedd756470a79ad1e6cfdc9ba28b49
\ No newline at end of file
+https://chromium.googlesource.com/v8/v8.git/+/8ec3828c3773aa77f0bf41d42021a6ba6dc2b1ff
diff --git a/v8ios.xcodeproj/project.pbxproj b/v8ios.xcodeproj/project.pbxproj
index 7ba1e36c..5f09b5a0 100644
--- a/v8ios.xcodeproj/project.pbxproj
+++ b/v8ios.xcodeproj/project.pbxproj
@@ -13,6 +13,10 @@
 		3CBFF7442971C1C200C5DE36 /* ArcMacro.h in Headers */ = {isa = PBXBuildFile; fileRef = 3CBFF7432971C1C200C5DE36 /* ArcMacro.h */; };
 		3CD1D9C129AA2C14004C1C21 /* DisposerPHV.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3CD1D9BF29AA2C14004C1C21 /* DisposerPHV.mm */; };
 		3CD1D9C229AA2C14004C1C21 /* DisposerPHV.h in Headers */ = {isa = PBXBuildFile; fileRef = 3CD1D9C029AA2C14004C1C21 /* DisposerPHV.h */; };
+		5B10CB942A83F42E00F8CBB7 /* GCProtectedSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 5B10CB922A83F42E00F8CBB7 /* GCProtectedSet.h */; };
+		5B10CB952A83F42E00F8CBB7 /* GCProtectedSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5B10CB932A83F42E00F8CBB7 /* GCProtectedSet.cpp */; };
+		5B90913E2A0D52B70092E1F1 /* Common.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5B90913D2A0D52B70092E1F1 /* Common.mm */; };
+		5B9D7C4A2A97E19000146C4C /* DataWrapper.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5B9D7C492A97E19000146C4C /* DataWrapper.mm */; };
 		6573B9CD291FE29F00B0ED7C /* V8Runtime.h in Headers */ = {isa = PBXBuildFile; fileRef = 6573B9C2291FE29F00B0ED7C /* V8Runtime.h */; };
 		6573B9CE291FE29F00B0ED7C /* JSIV8ValueConverter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6573B9C3291FE29F00B0ED7C /* JSIV8ValueConverter.cpp */; };
 		6573B9CF291FE29F00B0ED7C /* V8Runtime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6573B9C4291FE29F00B0ED7C /* V8Runtime.cpp */; };
@@ -423,6 +427,10 @@
 		3CD1D9BF29AA2C14004C1C21 /* DisposerPHV.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = DisposerPHV.mm; sourceTree = "<group>"; };
 		3CD1D9C029AA2C14004C1C21 /* DisposerPHV.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DisposerPHV.h; sourceTree = "<group>"; };
 		3CEF9CCC28F896B70056BA45 /* SpinLock.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SpinLock.h; sourceTree = "<group>"; };
+		5B10CB922A83F42E00F8CBB7 /* GCProtectedSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GCProtectedSet.h; sourceTree = "<group>"; };
+		5B10CB932A83F42E00F8CBB7 /* GCProtectedSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GCProtectedSet.cpp; sourceTree = "<group>"; };
+		5B90913D2A0D52B70092E1F1 /* Common.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = Common.mm; sourceTree = "<group>"; };
+		5B9D7C492A97E19000146C4C /* DataWrapper.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DataWrapper.mm; sourceTree = "<group>"; };
 		6573B9C2291FE29F00B0ED7C /* V8Runtime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = V8Runtime.h; sourceTree = "<group>"; };
 		6573B9C3291FE29F00B0ED7C /* JSIV8ValueConverter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSIV8ValueConverter.cpp; sourceTree = "<group>"; };
 		6573B9C4291FE29F00B0ED7C /* V8Runtime.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = V8Runtime.cpp; sourceTree = "<group>"; };
@@ -1318,6 +1326,9 @@
 		C2DDEB3B229EAB8600345BFE /* runtime */ = {
 			isa = PBXGroup;
 			children = (
+				5B9D7C492A97E19000146C4C /* DataWrapper.mm */,
+				5B10CB932A83F42E00F8CBB7 /* GCProtectedSet.cpp */,
+				5B10CB922A83F42E00F8CBB7 /* GCProtectedSet.h */,
 				C2DDEB66229EAC8100345BFE /* ArgConverter.h */,
 				3CBFF7432971C1C200C5DE36 /* ArcMacro.h */,
 				C2DDEB6A229EAC8200345BFE /* ArgConverter.mm */,
@@ -1407,6 +1418,7 @@
 				C275F475253B37AB00A997D5 /* UnmanagedType.mm */,
 				3CEF9CCC28F896B70056BA45 /* SpinLock.h */,
 				3CA6E53429A78C6000D30F8B /* IsolateWrapper.h */,
+				5B90913D2A0D52B70092E1F1 /* Common.mm */,
 			);
 			path = runtime;
 			sourceTree = "<group>";
@@ -1504,6 +1516,7 @@
 				C22C092322CA3F370080D176 /* Worker.h in Headers */,
 				6573B9E6291FE2A700B0ED7C /* instrumentation.h in Headers */,
 				6573B9EA291FE2A700B0ED7C /* jsilib.h in Headers */,
+				5B10CB942A83F42E00F8CBB7 /* GCProtectedSet.h in Headers */,
 				6573B9D1291FE29F00B0ED7C /* V8PointerValue.h in Headers */,
 				C247C16622F82842001D2CA2 /* v8-version.h in Headers */,
 				C2DDEBAE229EAC8300345BFE /* DictionaryAdapter.h in Headers */,
@@ -2083,16 +2096,19 @@
 				C2D21600248AAAD900EDC646 /* Constants.cpp in Sources */,
 				C2DDEB9E229EAC8300345BFE /* SymbolLoader.mm in Sources */,
 				C2CC8EEA22BBA01E00B78928 /* FastEnumerationAdapter.mm in Sources */,
+				5B10CB952A83F42E00F8CBB7 /* GCProtectedSet.cpp in Sources */,
 				C2DDEB99229EAC8300345BFE /* Metadata.mm in Sources */,
 				6573B9D4291FE29F00B0ED7C /* V8RuntimeFactory.cpp in Sources */,
 				C2DDEBB4229EAC8300345BFE /* DictionaryAdapter.mm in Sources */,
 				C298C027233C9AEA000DDF54 /* TSHelpers.cpp in Sources */,
+				5B90913E2A0D52B70092E1F1 /* Common.mm in Sources */,
 				C2FEA16F22A3C75C00A5C0FC /* InlineFunctions.cpp in Sources */,
 				C2DDEB9A229EAC8300345BFE /* MetadataBuilder.mm in Sources */,
 				C266569722AFFFB000EE15CC /* Reference.cpp in Sources */,
 				C2DDEB95229EAC8300345BFE /* SetTimeout.cpp in Sources */,
 				6573B9EE291FE5B700B0ED7C /* JSIRuntime.m in Sources */,
 				F6191AB229C0FCE8003F588F /* InspectorServer.mm in Sources */,
+				5B9D7C4A2A97E19000146C4C /* DataWrapper.mm in Sources */,
 				6573B9D3291FE29F00B0ED7C /* HostProxy.cpp in Sources */,
 				6573B9E5291FE2A700B0ED7C /* jsi.cpp in Sources */,
 				C2DDEBB3229EAC8300345BFE /* ClassBuilder.mm in Sources */,

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://clevelandohioweatherforecast.com/php-proxy/index.php?q=https://github.com/NativeScript/ios/compare/NativeScript:5371bed...NativeScript:727338e.diff" target="_blank">Alternative Proxy</a></p><p><a href="http://clevelandohioweatherforecast.com/pFad/index.php?u=https://github.com/NativeScript/ios/compare/NativeScript:5371bed...NativeScript:727338e.diff" target="_blank">pFad Proxy</a></p><p><a href="http://clevelandohioweatherforecast.com/pFad/v3index.php?u=https://github.com/NativeScript/ios/compare/NativeScript:5371bed...NativeScript:727338e.diff" target="_blank">pFad v3 Proxy</a></p><p><a href="http://clevelandohioweatherforecast.com/pFad/v4index.php?u=https://github.com/NativeScript/ios/compare/NativeScript:5371bed...NativeScript:727338e.diff" target="_blank">pFad v4 Proxy</a></p></body>
</html>